package balance

import (
	"fmt"

	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
)

// TransferXArgs groups the arguments
// of "transferX" invocation call.
type TransferXArgs struct {
	amount int64 // amount in GASe-12

	sender []byte // sender's wallet script hash

	recipient []byte // recipient's wallet script hash

	details []byte // transfer details

	client.InvokePrmOptional
}

// SetAmount sets amount of funds to transfer
// in GASe-12.
func (t *TransferXArgs) SetAmount(v int64) {
	t.amount = v
}

// SetSender sets wallet script hash
// of the sender of funds in a binary format.
func (t *TransferXArgs) SetSender(v []byte) {
	t.sender = v
}

// SetRecipient sets wallet script hash
// of the recipient of funds in a binary format.
func (t *TransferXArgs) SetRecipient(v []byte) {
	t.recipient = v
}

// SetDetails sets details of the money transaction
// in a binary format.
func (t *TransferXArgs) SetDetails(v []byte) {
	t.details = v
}

// TransferX directly invokes the call of "transferX" method
// of NeoFS Balance contract.
func (c *Client) TransferX(args TransferXArgs) error {
	prm := client.InvokePrm{}

	prm.SetMethod(transferXMethod)
	prm.SetArgs(args.sender, args.recipient, args.amount, args.details)
	prm.InvokePrmOptional = args.InvokePrmOptional

	err := c.client.Invoke(prm)
	if err != nil {
		return fmt.Errorf("could not invoke method (%s): %w", transferXMethod, err)
	}

	return nil
}

// MintPrm groups parameters of Mint operation.
type MintPrm struct {
	to     []byte
	amount int64
	id     []byte

	client.InvokePrmOptional
}

// SetTo sets receiver of the transfer.
func (m *MintPrm) SetTo(to []byte) {
	m.to = to
}

// SetAmount sets amount of the transfer.
func (m *MintPrm) SetAmount(amount int64) {
	m.amount = amount
}

// SetID sets ID.
func (m *MintPrm) SetID(id []byte) {
	m.id = id
}

// Mint invokes `mint` method of the balance contract.
func (c *Client) Mint(args MintPrm) error {
	prm := client.InvokePrm{}

	prm.SetMethod(mintMethod)
	prm.SetArgs(args.to, args.amount, args.id)
	prm.InvokePrmOptional = args.InvokePrmOptional

	return c.client.Invoke(prm)
}

// BurnPrm groups parameters of Burn operation.
type BurnPrm struct {
	to     []byte
	amount int64
	id     []byte

	client.InvokePrmOptional
}

// SetTo sets receiver.
func (b *BurnPrm) SetTo(to []byte) {
	b.to = to
}

// SetAmount sets amount.
func (b *BurnPrm) SetAmount(amount int64) {
	b.amount = amount
}

// SetID sets ID.
func (b *BurnPrm) SetID(id []byte) {
	b.id = id
}

// Burn invokes `burn` method of the balance contract.
func (c *Client) Burn(args BurnPrm) error {
	prm := client.InvokePrm{}

	prm.SetMethod(burnMethod)
	prm.SetArgs(args.to, args.amount, args.id)
	prm.InvokePrmOptional = args.InvokePrmOptional

	return c.client.Invoke(prm)
}

// LockPrm groups parameters of Lock operation.
type LockPrm struct {
	id       []byte
	user     []byte
	lock     []byte
	amount   int64
	dueEpoch int64

	client.InvokePrmOptional
}

// SetID sets ID.
func (l *LockPrm) SetID(id []byte) {
	l.id = id
}

// SetUser set user.
func (l *LockPrm) SetUser(user []byte) {
	l.user = user
}

// SetLock sets lock.
func (l *LockPrm) SetLock(lock []byte) {
	l.lock = lock
}

// SetAmount sets amount.
func (l *LockPrm) SetAmount(amount int64) {
	l.amount = amount
}

// SetDueEpoch sets end of the lock.
func (l *LockPrm) SetDueEpoch(dueEpoch int64) {
	l.dueEpoch = dueEpoch
}

// Lock invokes `lock` method of the balance contract.
func (c *Client) Lock(args LockPrm) error {
	prm := client.InvokePrm{}

	prm.SetMethod(lockMethod)
	prm.SetArgs(args.id, args.user, args.lock, args.amount, args.dueEpoch)
	prm.InvokePrmOptional = args.InvokePrmOptional

	return c.client.Invoke(prm)
}