// Copyright 2019 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

// Contains a batch of utility type declarations used by the tests. As the node
// operates on unique types, a lot of them are needed to check various features.

package statediff

import (
	"fmt"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/core/state"
	"github.com/ethereum/go-ethereum/ethdb"
	"github.com/ethereum/go-ethereum/log"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/ethereum/go-ethereum/trie"
)

// Builder interface exposes the method for building a state diff between two blocks
type Builder interface {
	BuildStateDiff(oldStateRoot, newStateRoot common.Hash, blockNumber int64, blockHash common.Hash) (StateDiff, error)
}

type builder struct {
	chainDB    ethdb.Database
	config     Config
	blockChain *core.BlockChain
}

// NewBuilder is used to create a state diff builder
func NewBuilder(db ethdb.Database, blockChain *core.BlockChain, config Config) Builder {
	return &builder{
		chainDB:    db,
		config:     config,
		blockChain: blockChain,
	}
}

// BuildStateDiff builds a StateDiff object from two blocks
func (sdb *builder) BuildStateDiff(oldStateRoot, newStateRoot common.Hash, blockNumber int64, blockHash common.Hash) (StateDiff, error) {
	// Generate tries for old and new states
	stateCache := sdb.blockChain.StateCache()
	oldTrie, err := stateCache.OpenTrie(oldStateRoot)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error creating trie for oldStateRoot: %v", err)
	}
	newTrie, err := stateCache.OpenTrie(newStateRoot)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error creating trie for newStateRoot: %v", err)
	}

	// Find created accounts
	oldIt := oldTrie.NodeIterator([]byte{})
	newIt := newTrie.NodeIterator([]byte{})
	creations, err := sdb.collectDiffNodes(oldIt, newIt)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error collecting creation diff nodes: %v", err)
	}

	// Find deleted accounts
	oldIt = oldTrie.NodeIterator([]byte{})
	newIt = newTrie.NodeIterator([]byte{})
	deletions, err := sdb.collectDiffNodes(newIt, oldIt)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error collecting deletion diff nodes: %v", err)
	}

	// Find all the diffed keys
	createKeys := sortKeys(creations)
	deleteKeys := sortKeys(deletions)
	updatedKeys := findIntersection(createKeys, deleteKeys)

	// Build and return the statediff
	updatedAccounts, err := sdb.buildDiffIncremental(creations, deletions, updatedKeys)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error building diff for updated accounts: %v", err)
	}
	createdAccounts, err := sdb.buildDiffEventual(creations)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error building diff for created accounts: %v", err)
	}
	deletedAccounts, err := sdb.buildDiffEventual(deletions)
	if err != nil {
		return StateDiff{}, fmt.Errorf("error building diff for deleted accounts: %v", err)
	}

	return StateDiff{
		BlockNumber:     blockNumber,
		BlockHash:       blockHash,
		CreatedAccounts: createdAccounts,
		DeletedAccounts: deletedAccounts,
		UpdatedAccounts: updatedAccounts,
	}, nil
}

func (sdb *builder) collectDiffNodes(a, b trie.NodeIterator) (AccountsMap, error) {
	var diffAccounts = make(AccountsMap)
	it, _ := trie.NewDifferenceIterator(a, b)

	if sdb.config.PathsAndProofs {
		for {
			log.Debug("Current Path and Hash", "path", pathToStr(it), "hashold", it.Hash())
			if it.Leaf() {
				leafProof := make([][]byte, len(it.LeafProof()))
				copy(leafProof, it.LeafProof())
				leafPath := make([]byte, len(it.Path()))
				copy(leafPath, it.Path())
				leafKey := make([]byte, len(it.LeafKey()))
				copy(leafKey, it.LeafKey())
				leafKeyHash := common.BytesToHash(leafKey)
				leafValue := make([]byte, len(it.LeafBlob()))
				copy(leafValue, it.LeafBlob())
				// lookup account state
				var account state.Account
				if err := rlp.DecodeBytes(leafValue, &account); err != nil {
					return nil, fmt.Errorf("error looking up account via address: %s, error: %v", leafKeyHash.Hex(), err)
				}
				aw := accountWrapper{
					Account:  account,
					RawKey:   leafKey,
					RawValue: leafValue,
					Proof:    leafProof,
					Path:     leafPath,
				}
				// record account to diffs (creation if we are looking at new - old; deletion if old - new)
				log.Debug("Account lookup successful", "address", leafKeyHash, "account", account)
				diffAccounts[leafKeyHash] = aw
			}
			cont := it.Next(true)
			if !cont {
				break
			}
		}
	} else {
		for {
			log.Debug("Current Path and Hash", "path", pathToStr(it), "old hash", it.Hash())
			if it.Leaf() {
				leafKey := make([]byte, len(it.LeafKey()))
				copy(leafKey, it.LeafKey())
				leafKeyHash := common.BytesToHash(leafKey)
				leafValue := make([]byte, len(it.LeafBlob()))
				copy(leafValue, it.LeafBlob())
				// lookup account state
				var account state.Account
				if err := rlp.DecodeBytes(leafValue, &account); err != nil {
					return nil, fmt.Errorf("error looking up account via address: %s, error: %v", leafKeyHash.Hex(), err)
				}
				aw := accountWrapper{
					Account:  account,
					RawKey:   leafKey,
					RawValue: leafValue,
					Proof:    nil,
					Path:     nil,
				}
				// record account to diffs (creation if we are looking at new - old; deletion if old - new)
				log.Debug("Account lookup successful", "address", leafKeyHash, "account", account)
				diffAccounts[leafKeyHash] = aw
			}
			cont := it.Next(true)
			if !cont {
				break
			}
		}
	}

	return diffAccounts, nil
}

func (sdb *builder) buildDiffEventual(accounts AccountsMap) (AccountDiffsMap, error) {
	accountDiffs := make(AccountDiffsMap)
	for _, val := range accounts {
		storageDiffs, err := sdb.buildStorageDiffsEventual(val.Account.Root)
		if err != nil {
			return nil, fmt.Errorf("failed building eventual storage diffs for address: %s, error: %v", common.BytesToHash(val.RawKey), err)
		}
		accountDiffs[common.BytesToHash(val.RawKey)] = AccountDiff{
			Key:     val.RawKey,
			Value:   val.RawValue,
			Proof:   val.Proof,
			Path:    val.Path,
			Storage: storageDiffs,
		}
	}

	return accountDiffs, nil
}

func (sdb *builder) buildDiffIncremental(creations AccountsMap, deletions AccountsMap, updatedKeys []string) (AccountDiffsMap, error) {
	updatedAccounts := make(AccountDiffsMap)
	for _, val := range updatedKeys {
		createdAcc := creations[common.HexToHash(val)]
		deletedAcc := deletions[common.HexToHash(val)]
		oldSR := deletedAcc.Account.Root
		newSR := createdAcc.Account.Root
		storageDiffs, err := sdb.buildStorageDiffsIncremental(oldSR, newSR)
		if err != nil {
			log.Error("Failed building storage diffs", "Address", val, "error", err)
			return nil, err
		}
		updatedAccounts[common.HexToHash(val)] = AccountDiff{
			Key:     createdAcc.RawKey,
			Value:   createdAcc.RawValue,
			Proof:   createdAcc.Proof,
			Path:    createdAcc.Path,
			Storage: storageDiffs,
		}
		delete(creations, common.HexToHash(val))
		delete(deletions, common.HexToHash(val))
	}

	return updatedAccounts, nil
}

func (sdb *builder) buildStorageDiffsEventual(sr common.Hash) ([]StorageDiff, error) {
	log.Debug("Storage Root For Eventual Diff", "root", sr.Hex())
	stateCache := sdb.blockChain.StateCache()
	sTrie, err := stateCache.OpenTrie(sr)
	if err != nil {
		log.Info("error in build storage diff eventual", "error", err)
		return nil, err
	}
	it := sTrie.NodeIterator(make([]byte, 0))
	storageDiffs := sdb.buildStorageDiffsFromTrie(it)
	return storageDiffs, nil
}

func (sdb *builder) buildStorageDiffsIncremental(oldSR common.Hash, newSR common.Hash) ([]StorageDiff, error) {
	log.Debug("Storage Roots for Incremental Diff", "old", oldSR.Hex(), "new", newSR.Hex())
	stateCache := sdb.blockChain.StateCache()

	oldTrie, err := stateCache.OpenTrie(oldSR)
	if err != nil {
		return nil, err
	}
	newTrie, err := stateCache.OpenTrie(newSR)
	if err != nil {
		return nil, err
	}

	oldIt := oldTrie.NodeIterator(make([]byte, 0))
	newIt := newTrie.NodeIterator(make([]byte, 0))
	it, _ := trie.NewDifferenceIterator(oldIt, newIt)
	storageDiffs := sdb.buildStorageDiffsFromTrie(it)

	return storageDiffs, nil
}

func (sdb *builder) buildStorageDiffsFromTrie(it trie.NodeIterator) []StorageDiff {
	storageDiffs := make([]StorageDiff, 0)
	if sdb.config.PathsAndProofs {
		for {
			log.Debug("Iterating over state at path ", "path", pathToStr(it))
			if it.Leaf() {
				log.Debug("Found leaf in storage", "path", pathToStr(it))
				leafProof := make([][]byte, len(it.LeafProof()))
				copy(leafProof, it.LeafProof())
				leafPath := make([]byte, len(it.Path()))
				copy(leafPath, it.Path())
				leafKey := make([]byte, len(it.LeafKey()))
				copy(leafKey, it.LeafKey())
				leafValue := make([]byte, len(it.LeafBlob()))
				copy(leafValue, it.LeafBlob())
				storageDiffs = append(storageDiffs, StorageDiff{
					Key:   leafKey,
					Value: leafValue,
					Path:  leafPath,
					Proof: leafProof,
				})
			}
			cont := it.Next(true)
			if !cont {
				break
			}
		}
	} else {
		for {
			log.Debug("Iterating over state at path ", "path", pathToStr(it))
			if it.Leaf() {
				log.Debug("Found leaf in storage", "path", pathToStr(it))
				leafKey := make([]byte, len(it.LeafKey()))
				copy(leafKey, it.LeafKey())
				leafValue := make([]byte, len(it.LeafBlob()))
				copy(leafValue, it.LeafBlob())
				storageDiffs = append(storageDiffs, StorageDiff{
					Key:   leafKey,
					Value: leafValue,
					Path:  nil,
					Proof: nil,
				})
			}
			cont := it.Next(true)
			if !cont {
				break
			}
		}
	}

	return storageDiffs
}

func (sdb *builder) addressByPath(path []byte) (*common.Address, error) {
	log.Debug("Looking up address from path", "path", hexutil.Encode(append([]byte("secure-key-"), path...)))
	addrBytes, err := sdb.chainDB.Get(append([]byte("secure-key-"), hexToKeyBytes(path)...))
	if err != nil {
		log.Error("Error looking up address via path", "path", hexutil.Encode(append([]byte("secure-key-"), path...)), "error", err)
		return nil, err
	}
	addr := common.BytesToAddress(addrBytes)
	log.Debug("Address found", "Address", addr)
	return &addr, nil
}