package tests

import (
	"encoding/hex"
	"encoding/json"
	"math/rand"
	"strings"
	"testing"

	"github.com/nspcc-dev/neo-go/pkg/config"
	"github.com/nspcc-dev/neo-go/pkg/config/netmode"
	"github.com/nspcc-dev/neo-go/pkg/core"
	"github.com/nspcc-dev/neo-go/pkg/core/block"
	"github.com/nspcc-dev/neo-go/pkg/core/fee"
	"github.com/nspcc-dev/neo-go/pkg/core/native"
	"github.com/nspcc-dev/neo-go/pkg/core/state"
	"github.com/nspcc-dev/neo-go/pkg/core/storage"
	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm"
	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap/zaptest"
)

const validatorWIF = "KxyjQ8eUa4FHt3Gvioyt1Wz29cTUrE4eTqX3yFSk1YFCsPL8uNsY"

// CommitteeAcc is an account used to sign tx as a committee.
var CommitteeAcc *wallet.Account

func init() {
	CommitteeAcc, _ = wallet.NewAccountFromWIF(validatorWIF)
	pubs := keys.PublicKeys{CommitteeAcc.PrivateKey().PublicKey()}
	err := CommitteeAcc.ConvertMultisig(1, pubs)
	if err != nil {
		panic(err)
	}
}

var _nonce uint32

func nonce() uint32 {
	_nonce++
	return _nonce
}

// NewChain creates new blockchain instance with a single validator and
// setups cleanup functions.
func NewChain(t *testing.T) *core.Blockchain {
	protoCfg := config.ProtocolConfiguration{
		Magic:              netmode.UnitTestNet,
		P2PSigExtensions:   true,
		SecondsPerBlock:    1,
		StandbyCommittee:   []string{hex.EncodeToString(CommitteeAcc.PrivateKey().PublicKey().Bytes())},
		ValidatorsCount:    1,
		VerifyBlocks:       true,
		VerifyTransactions: true,
	}

	st := storage.NewMemoryStore()
	log := zaptest.NewLogger(t)
	bc, err := core.NewBlockchain(st, protoCfg, log)
	require.NoError(t, err)
	go bc.Run()
	t.Cleanup(bc.Close)
	return bc
}

// PrepareInvoke creates new invocation transaction.
// Signer can be either bool or *wallet.Account.
// In the first case `true` means sign by committee, `false` means sign by validators.
func PrepareInvoke(t *testing.T, bc *core.Blockchain, signer interface{},
	hash util.Uint160, method string, args ...interface{}) *transaction.Transaction {
	w := io.NewBufBinWriter()
	emit.AppCall(w.BinWriter, hash, method, callflag.All, args...)
	require.NoError(t, w.Err)

	script := w.Bytes()
	tx := transaction.New(script, 0)
	tx.Nonce = nonce()
	tx.ValidUntilBlock = bc.BlockHeight() + 1

	switch s := signer.(type) {
	case *wallet.Account:
		tx.Signers = append(tx.Signers, transaction.Signer{
			Account: s.Contract.ScriptHash(),
			Scopes:  transaction.Global,
		})
		require.NoError(t, addNetworkFee(bc, tx, s))
		require.NoError(t, addSystemFee(bc, tx))
		require.NoError(t, s.SignTx(netmode.UnitTestNet, tx))
	case []*wallet.Account:
		for _, acc := range s {
			tx.Signers = append(tx.Signers, transaction.Signer{
				Account: acc.Contract.ScriptHash(),
				Scopes:  transaction.Global,
			})
			require.NoError(t, addNetworkFee(bc, tx, acc))
		}
		require.NoError(t, addSystemFee(bc, tx))
		for _, acc := range s {
			require.NoError(t, acc.SignTx(netmode.UnitTestNet, tx))
		}
	default:
		panic("invalid signer")
	}

	return tx
}

// NewAccount creates new account and transfers 100.0 GAS to it.
func NewAccount(t *testing.T, bc *core.Blockchain) *wallet.Account {
	acc, err := wallet.NewAccount()
	require.NoError(t, err)

	tx := PrepareInvoke(t, bc, CommitteeAcc,
		bc.UtilityTokenHash(), "transfer",
		CommitteeAcc.Contract.ScriptHash(), acc.Contract.ScriptHash(), int64(100_0000_0000), nil)
	AddBlock(t, bc, tx)
	CheckHalt(t, bc, tx.Hash())
	return acc
}

// DeployContract compiles and deploys contract to bc.
// path should contain Go source files.
// data is an optional argument to `_deploy`.
func DeployContract(t *testing.T, bc *core.Blockchain, path string, data interface{}) util.Uint160 {
	tx, h := newDeployTx(t, bc, path, data)
	AddBlock(t, bc, tx)
	CheckHalt(t, bc, tx.Hash())
	return h
}

// CheckHalt checks that transaction persisted with HALT state.
func CheckHalt(t *testing.T, bc *core.Blockchain, h util.Uint256, stack ...stackitem.Item) *state.AppExecResult {
	aer, err := bc.GetAppExecResults(h, trigger.Application)
	require.NoError(t, err)
	require.Equal(t, vm.HaltState, aer[0].VMState, aer[0].FaultException)
	if len(stack) != 0 {
		require.Equal(t, stack, aer[0].Stack)
	}
	return &aer[0]
}

// CheckFault checks that transaction persisted with FAULT state.
// Raised exception is also checked to contain s as a substring.
func CheckFault(t *testing.T, bc *core.Blockchain, h util.Uint256, s string) {
	aer, err := bc.GetAppExecResults(h, trigger.Application)
	require.NoError(t, err)
	require.Equal(t, vm.FaultState, aer[0].VMState)
	require.True(t, strings.Contains(aer[0].FaultException, s),
		"expected: %s, got: %s", s, aer[0].FaultException)
}

// newDeployTx returns new deployment tx for contract.
func newDeployTx(t *testing.T, bc *core.Blockchain, ctrPath string, data interface{}) (*transaction.Transaction, util.Uint160) {
	c, err := ContractInfo(CommitteeAcc.Contract.ScriptHash(), ctrPath)
	require.NoError(t, err)

	rawManifest, err := json.Marshal(c.Manifest)
	require.NoError(t, err)

	neb, err := c.NEF.Bytes()
	require.NoError(t, err)

	buf := io.NewBufBinWriter()
	emit.AppCall(buf.BinWriter, bc.ManagementContractHash(), "deploy", callflag.All, neb, rawManifest, data)
	require.NoError(t, buf.Err)

	tx := transaction.New(buf.Bytes(), 100*native.GASFactor)
	tx.Nonce = nonce()
	tx.ValidUntilBlock = bc.BlockHeight() + 1
	tx.Signers = []transaction.Signer{{
		Account: CommitteeAcc.Contract.ScriptHash(),
		Scopes:  transaction.Global,
	}}
	require.NoError(t, addNetworkFee(bc, tx, CommitteeAcc))
	require.NoError(t, CommitteeAcc.SignTx(netmode.UnitTestNet, tx))
	return tx, c.Hash
}

func addSystemFee(bc *core.Blockchain, tx *transaction.Transaction) error {
	v, _ := TestInvoke(bc, tx) // ignore error to support failing transactions
	tx.SystemFee = v.GasConsumed()
	return nil
}

func addNetworkFee(bc *core.Blockchain, tx *transaction.Transaction, sender *wallet.Account) error {
	size := io.GetVarSize(tx)
	netFee, sizeDelta := fee.Calculate(bc.GetBaseExecFee(), sender.Contract.Script)
	tx.NetworkFee += netFee
	size += sizeDelta
	for _, cosigner := range tx.Signers {
		contract := bc.GetContractState(cosigner.Account)
		if contract != nil {
			netFee, sizeDelta = fee.Calculate(bc.GetBaseExecFee(), contract.NEF.Script)
			tx.NetworkFee += netFee
			size += sizeDelta
		}
	}
	tx.NetworkFee += int64(size) * bc.FeePerByte()
	return nil
}

// AddBlock creates a new block from provided transactions and adds it on bc.
func AddBlock(t *testing.T, bc *core.Blockchain, txs ...*transaction.Transaction) *block.Block {
	return addCustomBlock(t, bc, nil, txs...)
}

func addCustomBlock(t *testing.T, bc *core.Blockchain, blockFunc func(*block.Block), txs ...*transaction.Transaction) *block.Block {
	lastBlock, err := bc.GetBlock(bc.GetHeaderHash(int(bc.BlockHeight())))
	require.NoError(t, err)
	b := &block.Block{
		Header: block.Header{
			NextConsensus: CommitteeAcc.Contract.ScriptHash(),
			Script: transaction.Witness{
				VerificationScript: CommitteeAcc.Contract.Script,
			},
			Timestamp: lastBlock.Timestamp + 1,
		},
		Transactions: txs,
	}
	b.PrevHash = lastBlock.Hash()
	b.Index = bc.BlockHeight() + 1
	b.RebuildMerkleRoot()
	if blockFunc != nil {
		blockFunc(b)
	}

	sign := CommitteeAcc.PrivateKey().SignHashable(uint32(netmode.UnitTestNet), b)
	b.Script.InvocationScript = append([]byte{byte(opcode.PUSHDATA1), 64}, sign...)
	require.NoError(t, bc.AddBlock(b))

	return b
}

// AddBlockCheckHalt is a convenient wrapper over AddBlock and CheckHalt.
func AddBlockCheckHalt(t *testing.T, bc *core.Blockchain, txs ...*transaction.Transaction) *block.Block {
	b := AddBlock(t, bc, txs...)
	for _, tx := range txs {
		CheckHalt(t, bc, tx.Hash())
	}
	return b
}

// CheckTestInvoke executes transaction without persisting it's state and
// compares the result with the expected.
func CheckTestInvoke(t *testing.T, bc *core.Blockchain, tx *transaction.Transaction, expected interface{}) {
	v, err := TestInvoke(bc, tx)
	require.NoError(t, err)
	require.Equal(t, 1, v.Estack().Len())
	require.Equal(t, stackitem.Make(expected), v.Estack().Pop().Item())
}

// TestInvoke creates a test VM with dummy block and executes transaction in it.
func TestInvoke(bc *core.Blockchain, tx *transaction.Transaction) (*vm.VM, error) {
	lastBlock, err := bc.GetBlock(bc.GetHeaderHash(int(bc.BlockHeight())))
	if err != nil {
		return nil, err
	}
	b := &block.Block{Header: block.Header{
		Index:     bc.BlockHeight() + 1,
		Timestamp: lastBlock.Timestamp + 1,
	}}
	v := bc.GetTestVM(trigger.Application, tx, b)
	v.LoadWithFlags(tx.Script, callflag.All)
	err = v.Run()
	return v, err
}

func randomBytes(n int) []byte {
	a := make([]byte, n)
	rand.Read(a)
	return a
}