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
	ConnType     ConnType
}

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

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
	}

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

	return h, nil
}

type UserAuth struct {
	Addr string
	Pass string
}

func (a UserAuth) Wrap() (PayloadType, []any) {
	return PayloadUserAuth, []any{
		a.Addr, a.Pass,
	}
}

func DecodeUserAuth(buf io.Reader) (UserAuth, error) {
	var a UserAuth
	err := decodeString(buf, &a.Addr)
	if err != nil {
		return a, err
	}

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

	return a, nil
}

type ServerAuth struct {
	Name string
}

func (a ServerAuth) Wrap() (PayloadType, []any) {
	return PayloadServerAuth, []any{
		a.Name,
	}
}

func DecodeServerAuth(buf io.Reader) (ServerAuth, error) {
	var a ServerAuth
	err := decodeString(buf, &a.Name)
	return a, err
}

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 Usermode struct {
	UserAddr    string
	ChannelName string
	Mode        UsermodeType
}

func (u Usermode) Wrap() (PayloadType, []any) {
	return PayloadUsermode, []any{
		u.UserAddr,
		u.ChannelName,
		uint8(u.Mode),
	}
}

func DecodeUsermode(buf io.Reader) (Usermode, error) {
	var u Usermode

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

	err = decodeString(buf, &u.ChannelName)
	if err != nil {
		return u, err
	}

	err = decodeNumeric(buf, &u.Mode)
	if err != nil {
		return u, err
	}

	return u, nil
}

type History struct {
	Channel string
	Since   time.Time
	Count   int64
	Offset  int64
}

func (h History) Wrap() (PayloadType, []any) {
	return PayloadHistory, []any{
		h.Channel,
		h.Since,
		h.Count,
		h.Offset,
	}
}

func DecodeHistory(buf io.Reader) (History, error) {
	var h History
	err := decodeString(buf, &h.Channel)
	if err != nil {
		return h, err
	}

	err = decodeTime(buf, &h.Since)
	if err != nil {
		return h, err
	}

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

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

	return h, 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
}