package state

import (
	"bytes"
	"sort"

	acm "github.com/tendermint/tendermint/account"
	. "github.com/tendermint/tendermint/common"
	dbm "github.com/tendermint/tendermint/db"
	"github.com/tendermint/tendermint/merkle"
	"github.com/tendermint/tendermint/types"
	"github.com/tendermint/tendermint/wire"
)

func makeStorage(db dbm.DB, root []byte) merkle.Tree {
	storage := merkle.NewIAVLTree(
		wire.BasicCodec,
		wire.BasicCodec,
		1024,
		db,
	)
	storage.Load(root)
	return storage
}

// The blockcache helps prevent unnecessary IAVLTree updates and garbage generation.
type BlockCache struct {
	db       dbm.DB
	backend  *State
	accounts map[string]accountInfo
	storages map[Tuple256]storageInfo
	names    map[string]nameInfo
}

func NewBlockCache(backend *State) *BlockCache {
	return &BlockCache{
		db:       backend.DB,
		backend:  backend,
		accounts: make(map[string]accountInfo),
		storages: make(map[Tuple256]storageInfo),
		names:    make(map[string]nameInfo),
	}
}

func (cache *BlockCache) State() *State {
	return cache.backend
}

//-------------------------------------
// BlockCache.account

func (cache *BlockCache) GetAccount(addr []byte) *acm.Account {
	acc, _, removed, _ := cache.accounts[string(addr)].unpack()
	if removed {
		return nil
	} else if acc != nil {
		return acc
	} else {
		acc = cache.backend.GetAccount(addr)
		cache.accounts[string(addr)] = accountInfo{acc, nil, false, false}
		return acc
	}
}

func (cache *BlockCache) UpdateAccount(acc *acm.Account) {
	addr := acc.Address
	_, storage, removed, _ := cache.accounts[string(addr)].unpack()
	if removed {
		PanicSanity("UpdateAccount on a removed account")
	}
	cache.accounts[string(addr)] = accountInfo{acc, storage, false, true}
}

func (cache *BlockCache) RemoveAccount(addr []byte) {
	_, _, removed, _ := cache.accounts[string(addr)].unpack()
	if removed {
		PanicSanity("RemoveAccount on a removed account")
	}
	cache.accounts[string(addr)] = accountInfo{nil, nil, true, false}
}

// BlockCache.account
//-------------------------------------
// BlockCache.storage

func (cache *BlockCache) GetStorage(addr Word256, key Word256) (value Word256) {
	// Check cache
	info, ok := cache.storages[Tuple256{addr, key}]
	if ok {
		return info.value
	}

	// Get or load storage
	acc, storage, removed, dirty := cache.accounts[string(addr.Postfix(20))].unpack()
	if removed {
		PanicSanity("GetStorage() on removed account")
	}
	if acc != nil && storage == nil {
		storage = makeStorage(cache.db, acc.StorageRoot)
		cache.accounts[string(addr.Postfix(20))] = accountInfo{acc, storage, false, dirty}
	} else if acc == nil {
		return Zero256
	}

	// Load and set cache
	_, val_ := storage.Get(key.Bytes())
	value = Zero256
	if val_ != nil {
		value = LeftPadWord256(val_.([]byte))
	}
	cache.storages[Tuple256{addr, key}] = storageInfo{value, false}
	return value
}

// NOTE: Set value to zero to removed from the trie.
func (cache *BlockCache) SetStorage(addr Word256, key Word256, value Word256) {
	_, _, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
	if removed {
		PanicSanity("SetStorage() on a removed account")
	}
	cache.storages[Tuple256{addr, key}] = storageInfo{value, true}
}

// BlockCache.storage
//-------------------------------------
// BlockCache.names

func (cache *BlockCache) GetNameRegEntry(name string) *types.NameRegEntry {
	entry, removed, _ := cache.names[name].unpack()
	if removed {
		return nil
	} else if entry != nil {
		return entry
	} else {
		entry = cache.backend.GetNameRegEntry(name)
		cache.names[name] = nameInfo{entry, false, false}
		return entry
	}
}

func (cache *BlockCache) UpdateNameRegEntry(entry *types.NameRegEntry) {
	name := entry.Name
	cache.names[name] = nameInfo{entry, false, true}
}

func (cache *BlockCache) RemoveNameRegEntry(name string) {
	_, removed, _ := cache.names[name].unpack()
	if removed {
		PanicSanity("RemoveNameRegEntry on a removed entry")
	}
	cache.names[name] = nameInfo{nil, true, false}
}

// BlockCache.names
//-------------------------------------

// CONTRACT the updates are in deterministic order.
func (cache *BlockCache) Sync() {

	// Determine order for storage updates
	// The address comes first so it'll be grouped.
	storageKeys := make([]Tuple256, 0, len(cache.storages))
	for keyTuple := range cache.storages {
		storageKeys = append(storageKeys, keyTuple)
	}
	Tuple256Slice(storageKeys).Sort()

	// Update storage for all account/key.
	// Later we'll iterate over all the users and save storage + update storage root.
	var (
		curAddr       Word256
		curAcc        *acm.Account
		curAccRemoved bool
		curStorage    merkle.Tree
	)
	for _, storageKey := range storageKeys {
		addr, key := Tuple256Split(storageKey)
		if addr != curAddr || curAcc == nil {
			acc, storage, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
			if !removed && storage == nil {
				storage = makeStorage(cache.db, acc.StorageRoot)
			}
			curAddr = addr
			curAcc = acc
			curAccRemoved = removed
			curStorage = storage
		}
		if curAccRemoved {
			continue
		}
		value, dirty := cache.storages[storageKey].unpack()
		if !dirty {
			continue
		}
		if value.IsZero() {
			curStorage.Remove(key.Bytes())
		} else {
			curStorage.Set(key.Bytes(), value.Bytes())
			cache.accounts[string(addr.Postfix(20))] = accountInfo{curAcc, curStorage, false, true}
		}
	}

	// Determine order for accounts
	addrStrs := []string{}
	for addrStr := range cache.accounts {
		addrStrs = append(addrStrs, addrStr)
	}
	sort.Strings(addrStrs)

	// Update or delete accounts.
	for _, addrStr := range addrStrs {
		acc, storage, removed, dirty := cache.accounts[addrStr].unpack()
		if removed {
			removed := cache.backend.RemoveAccount([]byte(addrStr))
			if !removed {
				PanicCrisis(Fmt("Could not remove account to be removed: %X", acc.Address))
			}
		} else {
			if acc == nil {
				continue
			}
			if storage != nil {
				newStorageRoot := storage.Save()
				if !bytes.Equal(newStorageRoot, acc.StorageRoot) {
					acc.StorageRoot = newStorageRoot
					dirty = true
				}
			}
			if dirty {
				cache.backend.UpdateAccount(acc)
			}
		}
	}

	// Determine order for names
	// note names may be of any length less than some limit
	nameStrs := []string{}
	for nameStr := range cache.names {
		nameStrs = append(nameStrs, nameStr)
	}
	sort.Strings(nameStrs)

	// Update or delete names.
	for _, nameStr := range nameStrs {
		entry, removed, dirty := cache.names[nameStr].unpack()
		if removed {
			removed := cache.backend.RemoveNameRegEntry(nameStr)
			if !removed {
				PanicCrisis(Fmt("Could not remove namereg entry to be removed: %s", nameStr))
			}
		} else {
			if entry == nil {
				continue
			}
			if dirty {
				cache.backend.UpdateNameRegEntry(entry)
			}
		}
	}

}

//-----------------------------------------------------------------------------

type accountInfo struct {
	account *acm.Account
	storage merkle.Tree
	removed bool
	dirty   bool
}

func (accInfo accountInfo) unpack() (*acm.Account, merkle.Tree, bool, bool) {
	return accInfo.account, accInfo.storage, accInfo.removed, accInfo.dirty
}

type storageInfo struct {
	value Word256
	dirty bool
}

func (stjInfo storageInfo) unpack() (Word256, bool) {
	return stjInfo.value, stjInfo.dirty
}

type nameInfo struct {
	name    *types.NameRegEntry
	removed bool
	dirty   bool
}

func (nInfo nameInfo) unpack() (*types.NameRegEntry, bool, bool) {
	return nInfo.name, nInfo.removed, nInfo.dirty
}