package statediff

import (
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/state"
	// "github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/trie"

	plugeth "github.com/openrelayxyz/plugeth-utils/core"
	// plugeth_trie "github.com/openrelayxyz/plugeth-utils/restricted/trie"

	"github.com/cerc-io/plugeth-statediff/adapt"
)

// Exposes a minimal interface for state access for diff building
type StateView interface {
	OpenTrie(root common.Hash) (StateTrie, error)
	ContractCode(codeHash common.Hash) ([]byte, error)
}

// StateTrie is an interface exposing only the necessary methods from state.Trie
type StateTrie interface {
	GetKey([]byte) []byte
	// GetAccount(common.Address) (*types.StateAccount, error)
	// Hash() common.Hash
	NodeIterator([]byte) trie.NodeIterator
	// Prove(key []byte, fromLevel uint, proofDb KeyValueWriter) error
}

// exposes a StateView from a combination of plugeth's core Backend and cached contract code
type plugethStateView struct {
	b    plugeth.Backend
	code map[common.Hash][]byte
}

var _ StateView = &plugethStateView{}

func (p *plugethStateView) OpenTrie(root common.Hash) (StateTrie, error) {
	t, err := p.b.GetTrie(plugeth.Hash(root))
	if err != nil {
		return nil, err
	}
	return adaptTrie{t}, nil
}

func (p *plugethStateView) ContractCode(hash common.Hash) ([]byte, error) {
	return p.code[hash], nil
}

// adapts a state.Database to StateView - used in tests
type stateDatabaseView struct {
	db state.Database
}

var _ StateView = stateDatabaseView{}

func StateDatabaseView(db state.Database) StateView {
	return stateDatabaseView{db}
}

func (a stateDatabaseView) OpenTrie(root common.Hash) (StateTrie, error) {
	// return adaptTrie{a.db.OpenTrie(common.Hash(root))}
	return a.db.OpenTrie(common.Hash(root))
}

func (a stateDatabaseView) ContractCode(hash common.Hash) ([]byte, error) {
	return a.db.ContractCode(common.Hash{}, hash)
}

// adapts geth Trie to plugeth
type adaptTrie struct {
	plugeth.Trie
}

var _ StateTrie = adaptTrie{}

// func (a adaptTrie) GetAccount(addr *types.StateAccount) (*plugeth.StateAccount, error) {
// 	return adapt.StateAccount(a.Trie.GetAccount(addr))
// }

func (a adaptTrie) NodeIterator(start []byte) trie.NodeIterator {
	return adapt.NodeIterator(a.Trie.NodeIterator(start))
}