package state

import (
	. "github.com/tendermint/tendermint/binary"
	. "github.com/tendermint/tendermint/blocks"
	. "github.com/tendermint/tendermint/common"
	. "github.com/tendermint/tendermint/config"
	db_ "github.com/tendermint/tendermint/db"

	"bytes"
	"testing"
	"time"
)

func randAccountDetail(id uint64, status byte) (*AccountDetail, *PrivAccount) {
	privAccount := GenPrivAccount()
	privAccount.Id = id
	account := privAccount.Account
	return &AccountDetail{
		Account:  account,
		Sequence: RandUInt(),
		Balance:  RandUInt64() + 1000, // At least 1000.
		Status:   status,
	}, privAccount
}

// The first numValidators accounts are validators.
func randGenesisState(numAccounts int, numValidators int) (*State, []*PrivAccount) {
	db := db_.NewMemDB()
	accountDetails := make([]*AccountDetail, numAccounts)
	privAccounts := make([]*PrivAccount, numAccounts)
	for i := 0; i < numAccounts; i++ {
		if i < numValidators {
			accountDetails[i], privAccounts[i] =
				randAccountDetail(uint64(i), AccountStatusBonded)
		} else {
			accountDetails[i], privAccounts[i] =
				randAccountDetail(uint64(i), AccountStatusNominal)
		}
	}
	s0 := GenesisState(db, time.Now(), accountDetails)
	s0.Save()
	return s0, privAccounts
}

func TestCopyState(t *testing.T) {
	// Generate a state
	s0, _ := randGenesisState(10, 5)
	s0Hash := s0.Hash()
	if len(s0Hash) == 0 {
		t.Error("Expected state hash")
	}

	// Check hash of copy
	s0Copy := s0.Copy()
	if !bytes.Equal(s0Hash, s0Copy.Hash()) {
		t.Error("Expected state copy hash to be the same")
	}

	// Mutate the original; hash should change.
	accDet := s0.GetAccountDetail(0)
	accDet.Balance += 1
	// The account balance shouldn't have changed yet.
	if s0.GetAccountDetail(0).Balance == accDet.Balance {
		t.Error("Account balance changed unexpectedly")
	}
	// Setting, however, should change the balance.
	s0.SetAccountDetail(accDet)
	if s0.GetAccountDetail(0).Balance != accDet.Balance {
		t.Error("Account balance wasn't set")
	}
	// How that the state changed, the hash should change too.
	if bytes.Equal(s0Hash, s0.Hash()) {
		t.Error("Expected state hash to have changed")
	}
	// The s0Copy shouldn't have changed though.
	if !bytes.Equal(s0Hash, s0Copy.Hash()) {
		t.Error("Expected state copy hash to have not changed")
	}
}

func TestGenesisSaveLoad(t *testing.T) {

	// Generate a state, save & load it.
	s0, _ := randGenesisState(10, 5)
	// Mutate the state to append one empty block.
	block := &Block{
		Header: &Header{
			Network:        Config.Network,
			Height:         1,
			Time:           s0.LastBlockTime.Add(time.Minute),
			Fees:           0,
			LastBlockHash:  s0.LastBlockHash,
			LastBlockParts: s0.LastBlockParts,
			StateHash:      nil,
		},
		Validation: &Validation{},
		Data: &Data{
			Txs: []Tx{},
		},
	}
	blockParts := NewPartSetFromData(BinaryBytes(block))
	// The second argument to AppendBlock() is false,
	// which sets Block.Header.StateHash.
	err := s0.Copy().AppendBlock(block, blockParts.Header(), false)
	if err != nil {
		t.Error("Error appending initial block:", err)
	}
	if len(block.Header.StateHash) == 0 {
		t.Error("Expected StateHash but got nothing.")
	}
	// Now append the block to s0.
	// This time we also check the StateHash (as computed above).
	err = s0.AppendBlock(block, blockParts.Header(), true)
	if err != nil {
		t.Error("Error appending initial block:", err)
	}

	// Save s0
	s0.Save()

	// Sanity check s0
	//s0.DB.(*db_.MemDB).Print()
	if s0.BondedValidators.TotalVotingPower() == 0 {
		t.Error("s0 BondedValidators TotalVotingPower should not be 0")
	}
	if s0.LastBlockHeight != 1 {
		t.Error("s0 LastBlockHeight should be 1, got", s0.LastBlockHeight)
	}

	// Load s1
	s1 := LoadState(s0.DB)

	// Compare height & blockHash
	if s0.LastBlockHeight != s1.LastBlockHeight {
		t.Error("LastBlockHeight mismatch")
	}
	if !bytes.Equal(s0.LastBlockHash, s1.LastBlockHash) {
		t.Error("LastBlockHash mismatch")
	}
	// Compare state merkle trees
	if s0.BondedValidators.Size() != s1.BondedValidators.Size() {
		t.Error("BondedValidators Size mismatch")
	}
	if s0.BondedValidators.TotalVotingPower() != s1.BondedValidators.TotalVotingPower() {
		t.Error("BondedValidators TotalVotingPower mismatch")
	}
	if bytes.Equal(s0.BondedValidators.Hash(), s1.BondedValidators.Hash()) {
		// The BondedValidators hash should have changed because
		// each AppendBlock() calls IncrementAccum(),
		// changing each validator's Accum.
		t.Error("BondedValidators hash should have changed")
	}
	if s0.UnbondingValidators.Size() != s1.UnbondingValidators.Size() {
		t.Error("UnbondingValidators Size mismatch")
	}
	if s0.UnbondingValidators.TotalVotingPower() != s1.UnbondingValidators.TotalVotingPower() {
		t.Error("UnbondingValidators TotalVotingPower mismatch")
	}
	if !bytes.Equal(s0.UnbondingValidators.Hash(), s1.UnbondingValidators.Hash()) {
		t.Error("UnbondingValidators hash mismatch")
	}
	if !bytes.Equal(s0.accountDetails.Hash(), s1.accountDetails.Hash()) {
		t.Error("AccountDetail mismatch")
	}
}

func TestTxSequence(t *testing.T) {

	state, privAccounts := randGenesisState(3, 1)
	acc1 := state.GetAccountDetail(1) // Non-validator

	// Try executing a SendTx with various sequence numbers.
	stxProto := SendTx{
		BaseTx: BaseTx{
			Sequence: acc1.Sequence + 1,
			Fee:      0},
		To:     2,
		Amount: 1,
	}

	// Test a variety of sequence numbers for the tx.
	// The tx should only pass when i == 1.
	for i := -1; i < 3; i++ {
		stxCopy := stxProto
		stx := &stxCopy
		stx.Sequence = uint(int(acc1.Sequence) + i)
		privAccounts[1].Sign(stx)
		stateCopy := state.Copy()
		err := stateCopy.ExecTx(stx)
		if i >= 1 {
			// Sequence is good.
			if err != nil {
				t.Errorf("Expected good sequence to pass")
			}
			// Check accDet.Sequence.
			newAcc1 := stateCopy.GetAccountDetail(1)
			if newAcc1.Sequence != stx.Sequence {
				t.Errorf("Expected account sequence to change")
			}
		} else {
			// Sequence is bad.
			if err == nil {
				t.Errorf("Expected bad sequence to fail")
			}
			// Check accDet.Sequence. (shouldn't have changed)
			newAcc1 := stateCopy.GetAccountDetail(1)
			if newAcc1.Sequence != acc1.Sequence {
				t.Errorf("Expected account sequence to not change")
			}
		}
	}
}

func TestTxs(t *testing.T) {

	state, privAccounts := randGenesisState(3, 1)

	acc0 := state.GetAccountDetail(0) // Validator
	acc1 := state.GetAccountDetail(1) // Non-validator
	acc2 := state.GetAccountDetail(2) // Non-validator

	// SendTx.
	{
		state := state.Copy()
		stx := &SendTx{
			BaseTx: BaseTx{
				Sequence: acc1.Sequence + 1,
				Fee:      0},
			To:     2,
			Amount: 1,
		}
		privAccounts[1].Sign(stx)
		err := state.ExecTx(stx)
		if err != nil {
			t.Errorf("Got error in executing send transaction, %v", err)
		}
		newAcc1 := state.GetAccountDetail(1)
		if acc1.Balance-1 != newAcc1.Balance {
			t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
				acc1.Balance-1, newAcc1.Balance)
		}
		newAcc2 := state.GetAccountDetail(2)
		if acc2.Balance+1 != newAcc2.Balance {
			t.Errorf("Unexpected newAcc2 balance. Expected %v, got %v",
				acc2.Balance+1, newAcc2.Balance)
		}
	}

	// TODO: test overflows.

	// SendTx should fail for bonded validators.
	{
		state := state.Copy()
		stx := &SendTx{
			BaseTx: BaseTx{
				Sequence: acc0.Sequence + 1,
				Fee:      0},
			To:     2,
			Amount: 1,
		}
		privAccounts[0].Sign(stx)
		err := state.ExecTx(stx)
		if err == nil {
			t.Errorf("Expected error, SendTx should fail for bonded validators")
		}
	}

	// TODO: test for unbonding validators.

	// BondTx.
	{
		state := state.Copy()
		btx := &BondTx{
			BaseTx: BaseTx{
				Sequence: acc1.Sequence + 1,
				Fee:      0},
		}
		privAccounts[1].Sign(btx)
		err := state.ExecTx(btx)
		if err != nil {
			t.Errorf("Got error in executing bond transaction, %v", err)
		}
		newAcc1 := state.GetAccountDetail(1)
		if acc1.Balance != newAcc1.Balance {
			t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
				acc1.Balance, newAcc1.Balance)
		}
		if newAcc1.Status != AccountStatusBonded {
			t.Errorf("Unexpected newAcc1 status.")
		}
		_, acc1Val := state.BondedValidators.GetById(acc1.Id)
		if acc1Val == nil {
			t.Errorf("acc1Val not present")
		}
		if acc1Val.BondHeight != state.LastBlockHeight {
			t.Errorf("Unexpected bond height. Expected %v, got %v",
				state.LastBlockHeight, acc1Val.BondHeight)
		}
		if acc1Val.VotingPower != acc1.Balance {
			t.Errorf("Unexpected voting power. Expected %v, got %v",
				acc1Val.VotingPower, acc1.Balance)
		}
		if acc1Val.Accum != 0 {
			t.Errorf("Unexpected accum. Expected 0, got %v",
				acc1Val.Accum)
		}
	}

	// TODO UnbondTx.
	// TODO NameTx.

}