package core

import (
	"io"
	"time"
)

type Success struct{}

func (s Success) Wrap() (PayloadType, []any) {
	return PayloadSuccess, []any{}
}

type Error struct {
	ErrorType ErrorType
}

func (e Error) Wrap() (PayloadType, []any) {
	return PayloadError, []any{e.ErrorType}
}

func DecodeError(buf io.Reader) (Error, error) {
	var (
		errorData uint8
		e         Error
	)

	err := decodeNumeric(buf, &errorData)
	if err != nil {
		return e, err
	}

	e.ErrorType = ErrorType(errorData)
	return e, nil
}

type Handshake struct {
	Major, Minor uint8
}

func (h Handshake) Wrap() (PayloadType, []any) {
	return PayloadHandshake, []any{
		h.Major, h.Minor,
	}
}

func DecodeHandshake(buf io.Reader) (Handshake, error) {
	var h Handshake

	err := decodeNumeric(buf, &h.Major)
	if err != nil {
		return h, err
	}

	err = decodeNumeric(buf, &h.Minor)
	if err != nil {
		return h, err
	}

	return h, nil
}

type Auth struct {
	Name string
	Pass string
}

func (a Auth) Wrap() (PayloadType, []any) {
	return PayloadAuth, []any{
		a.Name, a.Pass,
	}
}

func DecodeAuth(buf io.Reader) (Auth, error) {
	var a Auth
	err := decodeString(buf, &a.Name)
	if err != nil {
		return a, err
	}

	err = decodeString(buf, &a.Pass)
	if err != nil {
		return a, err
	}

	return a, nil
}

type Message struct {
	Source    string
	Target    string
	Timestamp time.Time
	Content   string
}

func (m Message) Wrap() (PayloadType, []any) {
	return PayloadMessage, []any{
		m.Source,
		m.Target,
		m.Timestamp,
		m.Content,
	}
}

func DecodeMessage(buf io.Reader) (Message, error) {
	var m Message

	err := decodeString(buf, &m.Source)
	if err != nil {
		return m, err
	}

	err = decodeString(buf, &m.Target)
	if err != nil {
		return m, err
	}

	err = decodeTime(buf, &m.Timestamp)
	if err != nil {
		return m, err
	}

	err = decodeString(buf, &m.Content)
	if err != nil {
		return m, err
	}

	return m, nil
}

type Test struct {
	Num1  uint8
	Time1 time.Time
	Str1  string
	Num2  uint16
	Bin1  []byte
	Num3  uint32
	Str2  string
	Num4  uint64
}

func (h Test) Wrap() (PayloadType, []any) {
	return PayloadTest, []any{
		h.Num1,
		h.Time1,
		h.Str1,
		h.Num2,
		h.Bin1,
		h.Num3,
		h.Str2,
		h.Num4,
	}
}

func DecodeTest(buf io.Reader) (Test, error) {
	var t Test

	err := decodeNumeric(buf, &t.Num1)
	if err != nil {
		return t, err
	}

	err = decodeTime(buf, &t.Time1)
	if err != nil {
		return t, err
	}

	err = decodeString(buf, &t.Str1)
	if err != nil {
		return t, err
	}

	err = decodeNumeric(buf, &t.Num2)
	if err != nil {
		return t, err
	}

	err = decodeBin(buf, &t.Bin1)
	if err != nil {
		return t, err
	}

	err = decodeNumeric(buf, &t.Num3)
	if err != nil {
		return t, err
	}

	err = decodeString(buf, &t.Str2)
	if err != nil {
		return t, err
	}

	err = decodeNumeric(buf, &t.Num4)
	if err != nil {
		return t, err
	}

	return t, nil
}