func (blockchain *blockchain) buildBlock(block *protos.Block, stateHash []byte) *protos.Block {
	block.SetPreviousBlockHash(blockchain.previousBlockHash)
	block.StateHash = stateHash
	return block
}

type Ledger struct {
	blockchain *blockchain //区块链
	state      *state.State //状态
	currentID  interface{} //当前ID
}

func (ledger *Ledger) GetTXBatchPreviewBlock(id interface{},
	transactions []*protos.Transaction, metadata []byte) (*protos.Block, error) {
	err := ledger.checkValidIDCommitORRollback(id)
	if err != nil {
		return nil, err
	}
	stateHash, err := ledger.state.GetHash()
	if err != nil {
		return nil, err
	}
	return ledger.blockchain.buildBlock(protos.NewBlock(transactions, metadata), stateHash), nil
}

func (ledger *Ledger) TxBegin(txUUID string) {
	ledger.state.TxBegin(txUUID)
}

func (ledger *Ledger) TxFinished(txUUID string, txSuccessful bool) {
	ledger.state.TxFinish(txUUID, txSuccessful)
}

func (ledger *Ledger) GetStateSnapshot() (*state.StateSnapshot, error) {
	dbSnapshot := db.GetDBHandle().GetSnapshot()
	blockHeight, err := fetchBlockchainSizeFromSnapshot(dbSnapshot)
	if err != nil {
		dbSnapshot.Release()
		return nil, err
	}
	if 0 == blockHeight {
		dbSnapshot.Release()
		return nil, fmt.Errorf("Blockchain has no blocks, cannot determine block number")
	}
	return ledger.state.GetSnapshot(blockHeight-1, dbSnapshot)
}

func (stateImpl *StateImpl) Initialize(configs map[string]interface{}) error {
	initConfig(configs)
	rootBucketNode, err := fetchBucketNodeFromDB(constructRootBucketKey())
	if err != nil {
		return err
	}
	if rootBucketNode != nil {
		stateImpl.persistedStateHash = rootBucketNode.computeCryptoHash()
		stateImpl.lastComputedCryptoHash = stateImpl.persistedStateHash
	}
	return nil
//我们可以创建一个高速缓存，并保持所有的bucket节点预加载。
//因为，铲斗节点不包含实际数据和最大可能的bucket是预先确定的，所述存储器需求
//可能不是非常高，或者可以容易地控制 - 通过保持在高速缓存中选择性bucket（bucket
//树的最可能的前面几级 - 因为，较高的bucket的水平，
//更是将需要散列重新计算的几率）
	
}

func (stateImpl *StateImpl) PrepareWorkingSet(stateDelta *statemgmt.StateDelta) error {
	logger.Debug("Enter - PrepareWorkingSet()")
	if stateDelta.IsEmpty() {
		logger.Debug("Ignoring working-set as it is empty")
		return nil
	}
	stateImpl.dataNodesDelta = newDataNodesDelta(stateDelta)
	stateImpl.bucketTreeDelta = newBucketTreeDelta()
	stateImpl.recomputeCryptoHash = true
	return nil
}

func NewState() *State {
	stateImplName := viper.GetString("ledger.state.dataStructure.name")
	stateImplConfigs := viper.GetStringMap("ledger.state.dataStructure.configs")

	if len(stateImplName) == 0 {
		stateImplName = detaultStateImpl
		stateImplConfigs = nil
	}

	switch stateImplName {
	case "buckettree":
		stateImpl = buckettree.NewStateImpl()
	case "trie":
		stateImpl = trie.NewStateTrie()
	default:
		panic(fmt.Errorf("Error during initialization of state implementation. State data structure '%s' is not valid.", stateImplName))
	}

	err := stateImpl.Initialize(stateImplConfigs)
	if err != nil {
		panic(fmt.Errorf("Error during initialization of state implementation: %s", err))
	}
	deltaHistorySize := viper.GetInt("ledger.state.deltaHistorySize")
	if deltaHistorySize < 0 {
		panic(fmt.Errorf("Delta history size must be greater than or equal to 0. Current value is %d.", deltaHistorySize))
	}
	return &State{stateImpl, statemgmt.NewStateDelta(), statemgmt.NewStateDelta(), "", make(map[string][]byte),
		false, uint64(deltaHistorySize)}
}

func (state *State) TxBegin(txUUID string) {
	logger.Debug("txBegin() for txUuid [%s]", txUUID)
	if state.txInProgress() {
		panic(fmt.Errorf("A tx [%s] is already in progress. Received call for begin of another tx [%s]", state.currentTxUUID, txUUID))
	}
	state.currentTxUUID = txUUID
}

func (state *State) Get(chaincodeID string, key string, committed bool) ([]byte, error) {
	if !committed {
		valueHolder := state.currentTxStateDelta.Get(chaincodeID, key)
		if valueHolder != nil {
			return valueHolder.GetValue(), nil
		}
		valueHolder = state.stateDelta.Get(chaincodeID, key)
		if valueHolder != nil {
			return valueHolder.GetValue(), nil
		}
	}
	return state.stateImpl.Get(chaincodeID, key)
}

func (state *State) GetRangeScanIterator(chaincodeID string, startKey string, endKey string, committed bool) (statemgmt.RangeScanIterator, error) {
	stateImplItr, err := state.stateImpl.GetRangeScanIterator(chaincodeID, startKey, endKey)
	if err != nil {
		return nil, err
	}

	if committed {
		return stateImplItr, nil
	}
	return newCompositeRangeScanIterator(
		statemgmt.NewStateDeltaRangeScanIterator(state.currentTxStateDelta, chaincodeID, startKey, endKey),
		statemgmt.NewStateDeltaRangeScanIterator(state.stateDelta, chaincodeID, startKey, endKey),
		stateImplItr), nil
}

func (state *State) GetHash() ([]byte, error) {
	logger.Debug("Enter - GetHash()")
	if state.updateStateImpl {
		logger.Debug("updating stateImpl with working-set")
		state.stateImpl.PrepareWorkingSet(state.stateDelta)
		state.updateStateImpl = false
	}
	hash, err := state.stateImpl.ComputeCryptoHash()
	if err != nil {
		return nil, err
	}
	logger.Debug("Exit - GetHash()")
	return hash, nil
}

func (trieNode *trieNode) mergeMissingAttributesFrom(dbTrieNode *trieNode) {
	stateTrieLogger.Debug("Enter mergeMissingAttributesFrom() baseNode=[%s], mergeNode=[%s]", trieNode, dbTrieNode)
	if !trieNode.valueUpdated {
		trieNode.value = dbTrieNode.value
	}
	for k, v := range dbTrieNode.childrenCryptoHashes {
		if !trieNode.childrenCryptoHashesUpdated[k] {
			trieNode.childrenCryptoHashes[k] = v
		}
	}
	stateTrieLogger.Debug("Exit mergeMissingAttributesFrom() mergedNode=[%s]", trieNode)
}

func (trieNode *trieNode) computeCryptoHash() []byte {
	stateTrieLogger.Debug("Enter computeCryptoHash() for trieNode [%s]", trieNode)
	var cryptoHashContent []byte
	if trieNode.containsValue() {
		stateTrieLogger.Debug("Adding value to hash computation for trieNode [%s]", trieNode)
		key := trieNode.trieKey.getEncodedBytes()
		cryptoHashContent = append(cryptoHashContent, proto.EncodeVarint(uint64(len(key)))...)
		cryptoHashContent = append(cryptoHashContent, key...)
		cryptoHashContent = append(cryptoHashContent, trieNode.value...)
	}

	sortedChildrenIndexes := trieNode.getSortedChildrenIndex()
	for _, index := range sortedChildrenIndexes {
		childCryptoHash := trieNode.childrenCryptoHashes[index]
		stateTrieLogger.Debug("Adding hash [%#v] for child number [%d] to hash computation for trieNode [%s]", childCryptoHash, index, trieNode)
		cryptoHashContent = append(cryptoHashContent, childCryptoHash...)
	}

	if cryptoHashContent == nil {
		// 节点没有关联值，也没有关联孩子节点。
		stateTrieLogger.Debug("Returning nil as hash for trieNode = [%s]. Also, marking this key for deletion.", trieNode)
		trieNode.markedForDeletion = true
		return nil
	}

	if !trieNode.containsValue() && trieNode.getNumChildren() == 1 {
		// 节点没有关联值，并且只有一个孩子节点，传递的孩子hash丢失
		stateTrieLogger.Debug("Returning hash as of a single child for trieKey = [%s]", trieNode.trieKey)
		return cryptoHashContent
	}

	stateTrieLogger.Debug("Recomputing hash for trieKey = [%s]", trieNode)
	return util.ComputeCryptoHash(cryptoHashContent)
}

func newTrieDelta(stateDelta *statemgmt.StateDelta) *trieDelta {
	trieDelta := &trieDelta{0, make(map[int]levelDeltaMap)}
	chaincodes := stateDelta.GetUpdatedChaincodeIds(false)
	for _, chaincodeID := range chaincodes {
		updates := stateDelta.GetUpdates(chaincodeID)
		for key, updatedvalue := range updates {
			if updatedvalue.IsDelete() {
				trieDelta.delete(chaincodeID, key)
			} else {
				if stateDelta.RollBackwards {
					trieDelta.set(chaincodeID, key, updatedvalue.GetPreviousValue())
				} else {
					trieDelta.set(chaincodeID, key, updatedvalue.GetValue())
				}
			}
		}
	}
	return trieDelta
}

func fetchTrieNodeFromDB(key *trieKey) (*trieNode, error) {
	stateTrieLogger.Debug("Enter fetchTrieNodeFromDB() for trieKey [%s]", key)
	openchainDB := db.GetDBHandle()
	trieNodeBytes, err := openchainDB.GetFromStateCF(key.getEncodedBytes())
	if err != nil {
		stateTrieLogger.Error("Error in retrieving trie node from DB for triekey [%s]. Error:%s", key, err)
		return nil, err
	}

	if trieNodeBytes == nil {
		return nil, nil
	}

	trieNode, err := unmarshalTrieNode(key, trieNodeBytes)
	if err != nil {
		stateTrieLogger.Error("Error in unmarshalling trie node for triekey [%s]. Error:%s", key, err)
		return nil, err
	}
	stateTrieLogger.Debug("Exit fetchTrieNodeFromDB() for trieKey [%s]", key)
	return trieNode, nil
}

func (stateTrie *StateTrie) processChangedNode(changedNode *trieNode) error {
	stateTrieLogger.Debug("Enter - processChangedNode() for node [%s]", changedNode)
	dbNode, err := fetchTrieNodeFromDB(changedNode.trieKey)
	if err != nil {
		return err
	}
	if dbNode != nil {
		stateTrieLogger.Debug("processChangedNode() - merging attributes from db node [%s]", dbNode)
		changedNode.mergeMissingAttributesFrom(dbNode)
	}
	newCryptoHash := changedNode.computeCryptoHash()
	parentNode := stateTrie.trieDelta.getParentOf(changedNode)
	if parentNode == nil {
		parentNode = newTrieNode(changedNode.getParentTrieKey(), nil, false)
		stateTrie.trieDelta.addTrieNode(parentNode)
	}
	parentNode.setChildCryptoHash(changedNode.getIndexInParent(), newCryptoHash)
	if logHashOfEveryNode {
		stateTrieLogger.Debug("Hash for changedNode[%s]", changedNode)
		stateTrieLogger.Debug("%#v", newCryptoHash)
	}
	stateTrieLogger.Debug("Exit - processChangedNode() for node [%s]", changedNode)
	return nil
}

func (stateTrie *StateTrie) AddChangesForPersistence(writeBatch *gorocksdb.WriteBatch) error {
	if stateTrie.recomputeCryptoHash {
		_, err := stateTrie.ComputeCryptoHash()
		if err != nil {
			return err
		}
	}

	if stateTrie.trieDelta == nil {
		stateTrieLogger.Info("trieDelta is nil. Not writing anything to DB")
		return nil
	}

	openchainDB := db.GetDBHandle()
	lowestLevel := stateTrie.trieDelta.getLowestLevel()
	for level := lowestLevel; level >= 0; level-- {
		changedNodes := stateTrie.trieDelta.deltaMap[level]
		for _, changedNode := range changedNodes {
			if changedNode.markedForDeletion {
				writeBatch.DeleteCF(openchainDB.StateCF, changedNode.trieKey.getEncodedBytes())
				continue
			}
			serializedContent, err := changedNode.marshal()
			if err != nil {
				return err
			}
			writeBatch.PutCF(openchainDB.StateCF, changedNode.trieKey.getEncodedBytes(), serializedContent)
		}
	}
	stateTrieLogger.Debug("Added changes to DB")
	return nil
}

type HashableState interface {

	//提供了一个机会来初始化。例如， 可以加载数据库的一些数据来实现state
	Initialize(configs map[string]interface{}) error

	// 从数据库获取值
	Get(chaincodeID string, key string) ([]byte, error)

	// 需要施加到状态，通过捕获需要的变化的stateDelta
	PrepareWorkingSet(stateDelta *StateDelta) error

	//计算状态加密哈希来实现state假设状态增量适用以PrepareWorkingSet方法传递
	ComputeCryptoHash() ([]byte, error)

	//添加的所有键值对，它需要为数据库持续触发statedelta（在、、//PrepareWorkingSet方法传递）。
//除了在StateDelta中的信息，实现还可能希望
//更快进行持久化中间结果的加密哈希计算
	AddChangesForPersistence(writeBatch *gorocksdb.WriteBatch) error

	// ClearWorkingSet可能会清除state实现，它可能已经建立了计算哈希加密和持续变化的状态增量的数据结构
	ClearWorkingSet(changesPersisted bool)

	
	GetStateSnapshotIterator(snapshot *gorocksdb.Snapshot) (StateSnapshotIterator, error)

	//提供一种应该给一个给定的chaincodeID使得返回键应该词法更大//所有键值迭代大于或等于startKey且小于或等于endKey。如果startKey参//数的值是假设一个空字符串startKey是在DB的chaincodeID可用最小的关//键。同样，对于endKey参数为空字符串假定endKey可用的分贝为chaincodeID//的最大键
	GetRangeScanIterator(chaincodeID string, startKey string, endKey string) (RangeScanIterator, error)

	//与StateDelta之前一些提示制备和PrepareWorkingSet方法通//过提供了可能。一个state的实现可以使用这个提示的预取相关数据，因此，//如果这可以提高哈希加密计算方法的性能（当被调用在以后的时间）
	PerfHintKeyChanged(chaincodeID string, key string)
}

func (stateDelta *StateDelta) ApplyChanges(anotherStateDelta *StateDelta) {
	for chaincodeID, chaincodeStateDelta := range anotherStateDelta.ChaincodeStateDeltas {
		existingChaincodeStateDelta, existingChaincode := stateDelta.ChaincodeStateDeltas[chaincodeID]
		for key, valueHolder := range chaincodeStateDelta.UpdatedKVs {
			var previousValue []byte
			if existingChaincode {
				existingUpdateValue, existingUpdate := existingChaincodeStateDelta.UpdatedKVs[key]
				if existingUpdate {
					// 现有的状态增量已经为这个键值的更新值
					previousValue = existingUpdateValue.PreviousValue
				} else {
					//使用以前的值在新的状态增量的设置
					previousValue = valueHolder.PreviousValue
				}
			} else {
				//使用之前值的状态增量
				previousValue = valueHolder.PreviousValue
			}

			if valueHolder.IsDelete() {
				stateDelta.Delete(chaincodeID, key, previousValue)
			} else {
				stateDelta.Set(chaincodeID, key, valueHolder.Value, previousValue)
			}
		}
	}
}

func (stateDelta *StateDelta) GetUpdatedChaincodeIds(sorted bool) []string {
	updatedChaincodeIds := make([]string, len(stateDelta.ChaincodeStateDeltas))
	i := 0
	for k := range stateDelta.ChaincodeStateDeltas {
		updatedChaincodeIds[i] = k
		i++
	}
	if sorted {
		sort.Strings(updatedChaincodeIds)
	}
	return updatedChaincodeIds
}