package core

import (
	"io"
	"time"
)

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 Ping struct{}

func (p Ping) Wrap() (PayloadType, []any) {
	return PayloadPing, []any{}
}

type Pong struct {
	Timestamp time.Time
}

func (p Pong) Wrap() (PayloadType, []any) {
	return PayloadPong, []any{
		p.Timestamp,
	}
}

func DecodePong(buf io.Reader) (Pong, error) {
	var p Pong
	err := decodeTime(buf, &p.Timestamp)
	if err != nil {
		return p, err
	}

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