package types

import (
	"context"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/synapsecns/sanguine/ethergo/signer/signer"
)

const (
	stateOffsetRoot        = 0
	stateOffsetOrigin      = 32
	stateOffsetNonce       = 36
	stateOffsetBlockNumber = 40
	stateOffsetTimestamp   = 45
	stateOffsetGasData     = 50
	stateSize              = 62
)

// State is the state interface.
type State interface {
	Encoder
	// Root is the root of the Origin Merkle Tree.
	Root() [32]byte
	// Origin is the domain where Origin is located.
	Origin() uint32
	// Nonce is the amount of sent messages.
	Nonce() uint32
	// BlockNumber is the block of the last sent message.
	BlockNumber() *big.Int
	// Timestamp is the unix time of the last sent message.
	Timestamp() *big.Int
	// GasData is the gas data from the chain's gas oracle.
	GasData() GasData

	// Hash returns the hash of the state.
	Hash() ([32]byte, error)
	// SubLeaves returns the left and right sub-leaves of the state.
	SubLeaves() (leftLeaf, rightLeaf [32]byte, err error)
	// SignState returns the signature of the state payload signed by the signer.
	SignState(ctx context.Context, signer signer.Signer) (signer.Signature, []byte, common.Hash, error)
}

type state struct {
	root        [32]byte
	origin      uint32
	nonce       uint32
	blockNumber *big.Int
	timestamp   *big.Int
	gasData     GasData
}

// NewState creates a new state.
func NewState(root [32]byte, origin uint32, nonce uint32, blockNumber *big.Int, timestamp *big.Int, gasData GasData) State {
	return &state{
		root:        root,
		origin:      origin,
		nonce:       nonce,
		blockNumber: blockNumber,
		timestamp:   timestamp,
		gasData:     gasData,
	}
}

func (s state) Root() [32]byte {
	return s.root
}

func (s state) Origin() uint32 {
	return s.origin
}

func (s state) Nonce() uint32 {
	return s.nonce
}

func (s state) BlockNumber() *big.Int {
	return s.blockNumber
}

func (s state) Timestamp() *big.Int {
	return s.timestamp
}

func (s state) GasData() GasData {
	return s.gasData
}

func (s state) Hash() ([32]byte, error) {
	leftLeaf, rightLeaf, err := s.SubLeaves()
	if err != nil {
		return [32]byte{}, err
	}

	concatLeafs := append(leftLeaf[:], rightLeaf[:]...)

	return crypto.Keccak256Hash(concatLeafs), nil
}

func (s state) SubLeaves() (leftLeaf, rightLeaf [32]byte, err error) {
	encodedState, err := s.Encode()
	if err != nil {
		return
	}

	leftLeaf = crypto.Keccak256Hash(encodedState[stateOffsetRoot:stateOffsetNonce])
	rightLeaf = crypto.Keccak256Hash(encodedState[stateOffsetNonce:stateSize])
	return
}

func (s state) SignState(ctx context.Context, signer signer.Signer) (signer.Signature, []byte, common.Hash, error) {
	return signEncoder(ctx, signer, s, StateInvalidSalt)
}

var _ State = state{}