package morph

import (
	"fmt"
	"math/big"

	morphUtil "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/util"
	"github.com/nspcc-dev/neo-go/pkg/core/native"
	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/gas"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/neo"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"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/wallet"
)

const (
	gasInitialTotalSupply = 30000000 * native.GASFactor
	// initialAlphabetGASAmount represents the amount of GAS given to each alphabet node.
	initialAlphabetGASAmount = 10_000 * native.GASFactor
	// initialProxyGASAmount represents the amount of GAS given to a proxy contract.
	initialProxyGASAmount = 50_000 * native.GASFactor
)

func transferFunds(c *morphUtil.InitializeContext) error {
	ok, err := transferFundsFinished(c)
	if ok || err != nil {
		if err == nil {
			c.Command.Println("Stage 1: already performed.")
		}
		return err
	}

	var transfers []transferTarget
	for _, acc := range c.Accounts {
		to := acc.Contract.ScriptHash()
		transfers = append(transfers,
			transferTarget{
				Token:   gas.Hash,
				Address: to,
				Amount:  initialAlphabetGASAmount,
			},
		)
	}

	// It is convenient to have all funds at the committee account.
	transfers = append(transfers,
		transferTarget{
			Token:   gas.Hash,
			Address: c.CommitteeAcc.Contract.ScriptHash(),
			Amount:  (gasInitialTotalSupply - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2,
		},
		transferTarget{
			Token:   neo.Hash,
			Address: c.CommitteeAcc.Contract.ScriptHash(),
			Amount:  native.NEOTotalSupply,
		},
	)

	tx, err := createNEP17MultiTransferTx(c.Client, c.ConsensusAcc, transfers)
	if err != nil {
		return fmt.Errorf("can't create transfer transaction: %w", err)
	}

	if err := c.MultiSignAndSend(tx, morphUtil.ConsensusAccountName); err != nil {
		return fmt.Errorf("can't send transfer transaction: %w", err)
	}

	return c.AwaitTx()
}

func transferFundsFinished(c *morphUtil.InitializeContext) (bool, error) {
	acc := c.Accounts[0]

	r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash)
	res, err := r.BalanceOf(acc.Contract.ScriptHash())
	return res.Cmp(big.NewInt(initialAlphabetGASAmount/2)) == 1, err
}

func transferGASToProxy(c *morphUtil.InitializeContext) error {
	proxyCs := c.GetContract(morphUtil.ProxyContract)

	r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash)
	bal, err := r.BalanceOf(proxyCs.Hash)
	if err != nil || bal.Sign() > 0 {
		return err
	}

	tx, err := createNEP17MultiTransferTx(c.Client, c.CommitteeAcc, []transferTarget{{
		Token:   gas.Hash,
		Address: proxyCs.Hash,
		Amount:  initialProxyGASAmount,
	}})
	if err != nil {
		return err
	}

	if err := c.MultiSignAndSend(tx, morphUtil.CommitteeAccountName); err != nil {
		return err
	}

	return c.AwaitTx()
}

type transferTarget struct {
	Token   util.Uint160
	Address util.Uint160
	Amount  int64
	Data    any
}

func createNEP17MultiTransferTx(c morphUtil.Client, acc *wallet.Account, recipients []transferTarget) (*transaction.Transaction, error) {
	from := acc.Contract.ScriptHash()

	w := io.NewBufBinWriter()
	for i := range recipients {
		emit.AppCall(w.BinWriter, recipients[i].Token, "transfer", callflag.All,
			from, recipients[i].Address, recipients[i].Amount, recipients[i].Data)
		emit.Opcodes(w.BinWriter, opcode.ASSERT)
	}
	if w.Err != nil {
		return nil, fmt.Errorf("failed to create transfer script: %w", w.Err)
	}

	signers := []actor.SignerAccount{{
		Signer: transaction.Signer{
			Account: acc.Contract.ScriptHash(),
			Scopes:  transaction.CalledByEntry,
		},
		Account: acc,
	}}

	act, err := actor.New(c, signers)
	if err != nil {
		return nil, fmt.Errorf("can't create actor: %w", err)
	}
	return act.MakeRun(w.Bytes())
}