package state

import (
	"crypto/elliptic"
	"errors"
	"fmt"
	"math/big"

	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/encoding/bigint"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)

// NEP17Balance represents the balance state of a NEP-17-token.
type NEP17Balance struct {
	Balance big.Int
}

// NEOBalance represents the balance state of a NEO-token.
type NEOBalance struct {
	NEP17Balance
	BalanceHeight uint32
	VoteTo        *keys.PublicKey
}

// NEP17BalanceFromBytes converts the serialized NEP17Balance to a structure.
func NEP17BalanceFromBytes(b []byte) (*NEP17Balance, error) {
	if len(b) < 4 {
		if len(b) == 0 {
			return new(NEP17Balance), nil
		}
		return nil, errors.New("invalid format")
	}
	if b[0] != byte(stackitem.StructT) {
		return nil, errors.New("not a struct")
	}
	if b[1] != 1 {
		return nil, errors.New("invalid item count")
	}
	if st := stackitem.Type(b[2]); st != stackitem.IntegerT {
		return nil, fmt.Errorf("invalid balance: %s", st)
	}
	if int(b[3]) != len(b[4:]) {
		return nil, errors.New("invalid balance format")
	}
	return &NEP17Balance{Balance: *bigint.FromBytes(b[4:])}, nil
}

// Bytes returns serialized NEP17Balance.
func (s *NEP17Balance) Bytes(buf []byte) []byte {
	if cap(buf) < 4+bigint.MaxBytesLen {
		buf = make([]byte, 4, 4+bigint.MaxBytesLen)
	} else {
		buf = buf[:4]
	}
	buf[0] = byte(stackitem.StructT)
	buf[1] = 1
	buf[2] = byte(stackitem.IntegerT)

	data := bigint.ToPreallocatedBytes(&s.Balance, buf[4:])
	buf[3] = byte(len(data)) // max is 33, so we are ok here
	buf = append(buf, data...)
	return buf
}

func balanceFromBytes(b []byte, item stackitem.Convertible) error {
	if len(b) == 0 {
		return nil
	}
	return stackitem.DeserializeConvertible(b, item)
}

func balanceToBytes(item stackitem.Convertible) []byte {
	data, err := stackitem.SerializeConvertible(item)
	if err != nil {
		panic(err)
	}
	return data
}

// ToStackItem implements stackitem.Convertible. It never returns an error.
func (s *NEP17Balance) ToStackItem() (stackitem.Item, error) {
	return stackitem.NewStruct([]stackitem.Item{stackitem.NewBigInteger(&s.Balance)}), nil
}

// FromStackItem implements stackitem.Convertible.
func (s *NEP17Balance) FromStackItem(item stackitem.Item) error {
	items, ok := item.Value().([]stackitem.Item)
	if !ok {
		return errors.New("not a struct")
	}
	if len(items) < 1 {
		return errors.New("no balance value")
	}
	balance, err := items[0].TryInteger()
	if err != nil {
		return fmt.Errorf("invalid balance: %w", err)
	}
	s.Balance = *balance
	return nil
}

// NEOBalanceFromBytes converts the serialized NEOBalance to a structure.
func NEOBalanceFromBytes(b []byte) (*NEOBalance, error) {
	balance := new(NEOBalance)
	err := balanceFromBytes(b, balance)
	if err != nil {
		return nil, err
	}
	return balance, nil
}

// Bytes returns a serialized NEOBalance.
func (s *NEOBalance) Bytes() []byte {
	return balanceToBytes(s)
}

// ToStackItem implements stackitem.Convertible interface. It never returns an error.
func (s *NEOBalance) ToStackItem() (stackitem.Item, error) {
	var voteItem stackitem.Item

	if s.VoteTo != nil {
		voteItem = stackitem.NewByteArray(s.VoteTo.Bytes())
	} else {
		voteItem = stackitem.Null{}
	}
	return stackitem.NewStruct([]stackitem.Item{
		stackitem.NewBigInteger(&s.Balance),
		stackitem.NewBigInteger(big.NewInt(int64(s.BalanceHeight))),
		voteItem,
	}), nil
}

// FromStackItem converts stackitem.Item to NEOBalance.
func (s *NEOBalance) FromStackItem(item stackitem.Item) error {
	structItem, ok := item.Value().([]stackitem.Item)
	if !ok || len(structItem) < 3 {
		return errors.New("invalid stackitem length")
	}
	balance, err := structItem[0].TryInteger()
	if err != nil {
		return fmt.Errorf("invalid balance stackitem: %w", err)
	}
	s.Balance = *balance
	h, err := structItem[1].TryInteger()
	if err != nil {
		return fmt.Errorf("invalid heigh stackitem")
	}
	s.BalanceHeight = uint32(h.Int64())
	if _, ok := structItem[2].(stackitem.Null); ok {
		s.VoteTo = nil
		return nil
	}
	bs, err := structItem[2].TryBytes()
	if err != nil {
		return fmt.Errorf("invalid public key stackitem: %w", err)
	}
	pub, err := keys.NewPublicKeyFromBytes(bs, elliptic.P256())
	if err != nil {
		return fmt.Errorf("invalid public key bytes: %w", err)
	}
	s.VoteTo = pub
	return nil
}