package types

import (
	"bytes"
	"encoding/gob"
	"fmt"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
)

const (
	// MessageBodyOffset is the message body offset.
	MessageBodyOffset = MessageHeaderSize
)

// Message is an interface that contains the message.
//
//nolint:interfacebloat
type Message interface {
	// Header gets the message header
	Header() Header
	// BaseMessage is the base message if the flag indicates the type is a base message
	BaseMessage() BaseMessage
	// Body gets the message body
	Body() []byte

	// OriginDomain returns the Slip-44 ID
	OriginDomain() uint32
	// Nonce is the count of all previous messages to the destination
	Nonce() uint32
	// DestinationDomain is the slip-44 id of the destination
	DestinationDomain() uint32
	// ToLeaf converts a leaf to a keccac256
	ToLeaf() (leaf [32]byte, err error)
	// OptimisticSeconds gets the optimistic seconds count
	OptimisticSeconds() uint32
}

// messageImpl implements a message. It is used for testutils. Real messages are emitted by the contract.
type messageImpl struct {
	header      Header
	baseMessage BaseMessage
	body        []byte
}

const headerOffset uint16 = 0

// NewMessageFromBaseMessage creates a generic message given a base message.
func NewMessageFromBaseMessage(header Header, baseMessage BaseMessage) (Message, error) {
	if header.Flag() != MessageFlagBase {
		return nil, fmt.Errorf("header flag is not base")
	}

	baseMessageBytes, err := EncodeBaseMessage(baseMessage)
	if err != nil {
		return nil, fmt.Errorf("could not encode base message: %w", err)
	}

	return &messageImpl{
		header:      header,
		baseMessage: baseMessage,
		body:        baseMessageBytes,
	}, nil
}

// NewMessageFromManagerMessage creates a generic message given a manager message.
func NewMessageFromManagerMessage(header Header, payload []byte) (Message, error) {
	if header.Flag() != MessageFlagManager {
		return nil, fmt.Errorf("header flag is not manager")
	}

	return &messageImpl{
		header:      header,
		baseMessage: nil,
		body:        payload,
	}, nil
}

// NewMessage creates a new message from fields passed in.
// TODO: Set up different initializers. One for BaseMessage and one for ManagerMessage.
func NewMessage(header Header, baseMessage BaseMessage, body []byte) Message {
	return &messageImpl{
		header:      header,
		baseMessage: baseMessage,
		body:        body,
	}
}

func (m messageImpl) Header() Header {
	return m.header
}

func (m messageImpl) OriginDomain() uint32 {
	return m.Header().OriginDomain()
}

func (m messageImpl) Nonce() uint32 {
	return m.Header().Nonce()
}

func (m messageImpl) DestinationDomain() uint32 {
	return m.Header().DestinationDomain()
}

func (m messageImpl) OptimisticSeconds() uint32 {
	return m.Header().OptimisticSeconds()
}

func (m messageImpl) BaseMessage() BaseMessage {
	return m.baseMessage
}

func (m messageImpl) Body() []byte {
	return m.body
}

// ToLeaf converts a message to an encoded leaf.
func (m messageImpl) ToLeaf() (leaf [32]byte, err error) {
	var toHash []byte
	if m.Header().Flag() == MessageFlagBase {
		leaf, err = m.BaseMessage().Leaf()
		if err != nil {
			return common.Hash{}, fmt.Errorf("could not get leaf: %w", err)
		}

		toHash = leaf[:]
	} else {
		toHash = crypto.Keccak256(m.Body())
	}

	headerLeaf, err := m.Header().Leaf()
	if err != nil {
		return common.Hash{}, fmt.Errorf("could not get header leaf: %w", err)
	}

	rawLeaf := crypto.Keccak256(headerLeaf[:], toHash)
	copy(leaf[:], rawLeaf)

	return leaf, nil
}

// CommittedMessage is the message that got committed.
type CommittedMessage interface {
	// Message is the fully detailed message that was committed
	Message() []byte
	// Leaf gets a leaf
	Leaf() [32]byte
	// Encode encodes a message
	Encode() ([]byte, error)
}

// NewCommittedMessage creates a new committed message.
func NewCommittedMessage(message []byte) CommittedMessage {
	return committedMessageImpl{
		message: message,
	}
}

// commitedMessageImpl contains the implementation of a committed message.
type committedMessageImpl struct {
	committedRoot common.Hash
	message       []byte
}

// CommittedMessageEncoder is used to export fields for struct encoding.
type CommittedMessageEncoder struct {
	CommittedRoot common.Hash
	Message       []byte
}

// DecodeCommittedMessage decodes a committed message into a struct.
func DecodeCommittedMessage(rawMessage []byte) (CommittedMessage, error) {
	dec := gob.NewDecoder(bytes.NewReader(rawMessage))

	var msg CommittedMessageEncoder
	err := dec.Decode(&msg)
	if err != nil {
		return nil, fmt.Errorf("could not decode message: %w", err)
	}

	decoded := committedMessageImpl{
		committedRoot: msg.CommittedRoot,
		message:       msg.Message,
	}

	return decoded, nil
}

// Encode encodes a committed message.
// Deprecated: will be removed.
func (c committedMessageImpl) Encode() ([]byte, error) {
	newCommittedMessage := CommittedMessageEncoder{
		CommittedRoot: c.committedRoot,
		Message:       c.message,
	}

	var res bytes.Buffer
	enc := gob.NewEncoder(&res)

	err := enc.Encode(newCommittedMessage)
	if err != nil {
		return nil, fmt.Errorf("could not encode %T: %w", newCommittedMessage, err)
	}
	return res.Bytes(), nil
}

// Leaf gets the leaf.
func (c committedMessageImpl) Leaf() (leaf [32]byte) {
	rawLeaf := crypto.Keccak256(c.message)
	copy(leaf[:], rawLeaf)

	return leaf
}

// Message gets the message.
func (c committedMessageImpl) Message() []byte {
	return c.message
}