package core

import (
	"encoding/hex"
	"fmt"
	"math/big"
	"sync"
	"time"

	coreCommon "github.com/dexon-foundation/dexon-consensus/common"
	dexCore "github.com/dexon-foundation/dexon-consensus/core"
	coreCrypto "github.com/dexon-foundation/dexon-consensus/core/crypto"
	coreEcdsa "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa"
	coreTypes "github.com/dexon-foundation/dexon-consensus/core/types"
	dkgTypes "github.com/dexon-foundation/dexon-consensus/core/types/dkg"
	coreUtils "github.com/dexon-foundation/dexon-consensus/core/utils"
	"github.com/hashicorp/golang-lru/simplelru"

	"github.com/dexon-foundation/dexon/common"
	"github.com/dexon-foundation/dexon/core/state"
	vm "github.com/dexon-foundation/dexon/core/vm/evm"
	"github.com/dexon-foundation/dexon/crypto"
	"github.com/dexon-foundation/dexon/log"
)

const dkgCacheSize = 5

type GovernanceStateDB interface {
	State() (*state.StateDB, error)
	StateAt(height uint64) (*state.StateDB, error)
}

func NewGovernanceStateDB(bc *BlockChain) GovernanceStateDB {
	return &governanceStateDB{bc: bc}
}

type governanceStateDB struct {
	bc *BlockChain
}

func (g *governanceStateDB) State() (*state.StateDB, error) {
	return g.bc.State()
}

func (g *governanceStateDB) StateAt(height uint64) (*state.StateDB, error) {
	header := g.bc.GetHeaderByNumber(height)
	if header == nil {
		return nil, fmt.Errorf("header at %d not exists", height)
	}
	return g.bc.StateAt(header.Root)
}

type dkgCacheItem struct {
	Round               uint64
	Reset               uint64
	MasterPublicKeysLen uint64
	MasterPublicKeys    []*dkgTypes.MasterPublicKey
	ComplaintsLen       uint64
	Complaints          []*dkgTypes.Complaint
}

type Governance struct {
	db           GovernanceStateDB
	nodeSetCache *dexCore.NodeSetCache
	dkgCache     *simplelru.LRU
	dkgCacheMu   sync.RWMutex
}

func NewGovernance(db GovernanceStateDB) *Governance {
	cache, err := simplelru.NewLRU(dkgCacheSize, nil)
	if err != nil {
		log.Error("Failed to initialize DKG cache", "error", err)
		return nil
	}
	g := &Governance{
		db:       db,
		dkgCache: cache,
	}
	g.nodeSetCache = dexCore.NewNodeSetCache(g)
	return g
}

func (g *Governance) GetHeadState() *vm.GovernanceState {
	headState, err := g.db.State()
	if err != nil {
		log.Error("Governance head state not ready", "err", err)
		panic(err)
	}
	return &vm.GovernanceState{StateDB: headState}
}

func (g *Governance) getHelperAtRound(round uint64) *vm.GovernanceState {
	height := g.GetRoundHeight(round)

	// Sanity check
	if round != 0 && height == 0 {
		log.Error("Governance state incorrect", "round", round, "got height", height)
		panic("round != 0 but height == 0")
	}

	s, err := g.db.StateAt(height)
	if err != nil {
		log.Error("Governance state not ready", "round", round, "height", height, "err", err)
		panic(err)
	}
	return &vm.GovernanceState{StateDB: s}
}

func (g *Governance) GetStateForConfigAtRound(round uint64) *vm.GovernanceState {
	if round < dexCore.ConfigRoundShift {
		round = 0
	} else {
		round -= dexCore.ConfigRoundShift
	}
	return g.getHelperAtRound(round)
}

func (g *Governance) GetStateAtRound(round uint64) *vm.GovernanceState {
	height := g.GetRoundHeight(round)
	s, err := g.db.StateAt(height)
	if err != nil {
		log.Error("Governance state not ready", "round", round, "height", height, "err", err)
		panic(err)
	}
	return &vm.GovernanceState{StateDB: s}
}

func (g *Governance) GetStateForDKGAtRound(round uint64) *vm.GovernanceState {
	dkgRound := g.GetHeadState().DKGRound().Uint64()
	if round > dkgRound {
		return nil
	}
	if round == dkgRound {
		return g.GetHeadState()
	}
	return g.GetStateAtRound(round)
}

func (g *Governance) CRSRound() uint64 {
	return g.GetHeadState().CRSRound().Uint64()
}

// CRS returns the CRS for a given round.
func (g *Governance) CRS(round uint64) coreCommon.Hash {
	if round <= dexCore.DKGDelayRound {
		s := g.GetStateAtRound(0)
		crs := s.CRS()
		for i := uint64(0); i < round; i++ {
			crs = crypto.Keccak256Hash(crs[:])
		}
		return coreCommon.Hash(crs)
	}
	if round > g.CRSRound() {
		return coreCommon.Hash{}
	}
	var s *vm.GovernanceState
	if round == g.CRSRound() {
		s = g.GetHeadState()
	} else {
		s = g.GetStateAtRound(round)
	}
	return coreCommon.Hash(s.CRS())
}

func (g *Governance) Configuration(round uint64) *coreTypes.Config {
	configHelper := g.GetStateForConfigAtRound(round)
	c := configHelper.Configuration()
	return &coreTypes.Config{
		LambdaBA:         time.Duration(c.LambdaBA) * time.Millisecond,
		LambdaDKG:        time.Duration(c.LambdaDKG) * time.Millisecond,
		NotarySetSize:    c.NotarySetSize,
		RoundLength:      c.RoundLength,
		MinBlockInterval: time.Duration(c.MinBlockInterval) * time.Millisecond,
	}
}

func (g *Governance) GetRoundHeight(round uint64) uint64 {
	return g.GetHeadState().RoundHeight(big.NewInt(int64(round))).Uint64()
}

// NodeSet returns the current node set.
func (g *Governance) NodeSet(round uint64) []coreCrypto.PublicKey {
	s := g.GetStateForConfigAtRound(round)
	var pks []coreCrypto.PublicKey

	for _, n := range s.QualifiedNodes() {
		pk, err := coreEcdsa.NewPublicKeyFromByteSlice(n.PublicKey)
		if err != nil {
			panic(err)
		}
		pks = append(pks, pk)
	}
	return pks
}

func (g *Governance) PurgeNotarySet(round uint64) {
	g.nodeSetCache.Purge(round)
}

func (g *Governance) NotarySet(round uint64) (map[string]struct{}, error) {
	notarySet, err := g.nodeSetCache.GetNotarySet(round)
	if err != nil {
		return nil, err
	}

	r := make(map[string]struct{}, len(notarySet))
	for id := range notarySet {
		if key, exists := g.nodeSetCache.GetPublicKey(id); exists {
			r[hex.EncodeToString(key.Bytes())] = struct{}{}
		}
	}
	return r, nil
}

func (g *Governance) DKGSetNodeKeyAddresses(round uint64) (map[common.Address]struct{}, error) {
	config := g.Configuration(round)

	mpks := g.DKGMasterPublicKeys(round)
	complaints := g.DKGComplaints(round)
	threshold := coreUtils.GetDKGThreshold(&coreTypes.Config{
		NotarySetSize: config.NotarySetSize})

	_, ids, err := dkgTypes.CalcQualifyNodes(mpks, complaints, threshold)
	if err != nil {
		return nil, err
	}

	r := make(map[common.Address]struct{})
	for id := range ids {
		r[vm.IdToAddress(id)] = struct{}{}
	}
	return r, nil
}

func (g *Governance) getOrUpdateDKGCache(round uint64) *dkgCacheItem {
	s := g.GetStateForDKGAtRound(round)
	if s == nil {
		log.Error("Failed to get DKG state", "round", round)
		return nil
	}
	reset := s.DKGResetCount(new(big.Int).SetUint64(round))
	mpksLen := s.LenDKGMasterPublicKeys().Uint64()
	compsLen := s.LenDKGComplaints().Uint64()

	var cache *dkgCacheItem

	g.dkgCacheMu.RLock()
	if v, ok := g.dkgCache.Get(round); ok {
		cache = v.(*dkgCacheItem)
	}
	g.dkgCacheMu.RUnlock()

	if cache != nil && cache.Reset == reset.Uint64() &&
		cache.MasterPublicKeysLen == mpksLen &&
		cache.ComplaintsLen == compsLen {
		return cache
	}

	g.dkgCacheMu.Lock()
	defer g.dkgCacheMu.Unlock()

	cache = &dkgCacheItem{
		Round: round,
		Reset: reset.Uint64(),
	}

	if cache == nil || cache.MasterPublicKeysLen != mpksLen {
		cache.MasterPublicKeys = s.DKGMasterPublicKeyItems()
		cache.MasterPublicKeysLen = uint64(len(cache.MasterPublicKeys))
	}

	if cache == nil || cache.ComplaintsLen != compsLen {
		cache.Complaints = s.DKGComplaintItems()
		cache.ComplaintsLen = uint64(len(cache.Complaints))
	}

	g.dkgCache.Add(round, cache)
	return cache
}

func (g *Governance) DKGComplaints(round uint64) []*dkgTypes.Complaint {
	cache := g.getOrUpdateDKGCache(round)
	return cache.Complaints
}

func (g *Governance) DKGMasterPublicKeys(round uint64) []*dkgTypes.MasterPublicKey {
	cache := g.getOrUpdateDKGCache(round)
	return cache.MasterPublicKeys
}

func (g *Governance) IsDKGMPKReady(round uint64) bool {
	s := g.GetStateForDKGAtRound(round)
	if s == nil {
		return false
	}
	config := g.Configuration(round)
	threshold := 2*uint64(config.NotarySetSize)/3 + 1
	count := s.DKGMPKReadysCount().Uint64()
	return count >= threshold
}

func (g *Governance) IsDKGFinal(round uint64) bool {
	s := g.GetStateForDKGAtRound(round)
	if s == nil {
		return false
	}
	config := g.Configuration(round)
	threshold := 2*uint64(config.NotarySetSize)/3 + 1
	count := s.DKGFinalizedsCount().Uint64()
	return count >= threshold
}

func (g *Governance) IsDKGSuccess(round uint64) bool {
	s := g.GetStateForDKGAtRound(round)
	if s == nil {
		return false
	}
	return s.DKGSuccessesCount().Uint64() >=
		uint64(coreUtils.GetDKGValidThreshold(g.Configuration(round)))
}

func (g *Governance) MinGasPrice(round uint64) *big.Int {
	return g.GetStateForConfigAtRound(round).MinGasPrice()
}

func (g *Governance) DKGResetCount(round uint64) uint64 {
	return g.GetHeadState().DKGResetCount(big.NewInt(int64(round))).Uint64()
}