package main

import (
	"encoding/binary"
	"encoding/json"
	"fmt"
	"io"
)

const (
	RemoteGetState      = uint16(0x01)
	RemoteHandleMessage = uint16(0x02)
	ResponseBody        = uint16(0x03)
)

type CartPacket struct {
	Version     uint16
	MessageType uint16
	Id          CartId
	DataLength  uint16
}

type Packet struct {
	Version     uint16
	MessageType uint16
	DataLength  uint16
}

func SendCartPacket(conn io.Writer, id CartId, messageType uint16, datafn func(w io.Writer) error) error {
	data, err := GetData(datafn)
	if err != nil {
		return err
	}
	if conn == nil {
		return fmt.Errorf("no connection to send to")
	}
	binary.Write(conn, binary.LittleEndian, CartPacket{
		Version:     2,
		MessageType: messageType,
		Id:          id,
		DataLength:  uint16(len(data)),
	})
	_, err = conn.Write(data)
	return err
}

func SendPacket(conn io.Writer, messageType uint16, datafn func(w io.Writer) error) error {
	data, err := GetData(datafn)
	if err != nil {
		return err
	}
	binary.Write(conn, binary.LittleEndian, Packet{
		Version:     1,
		MessageType: messageType,
		DataLength:  uint16(len(data)),
	})
	_, err = conn.Write(data)
	return err
}

func SendRawResponse(conn io.Writer, data []byte) error {
	binary.Write(conn, binary.LittleEndian, Packet{
		Version:     1,
		MessageType: ResponseBody,
		DataLength:  uint16(len(data)),
	})
	_, err := conn.Write(data)
	return err
}

func SendProxyResponse(conn io.Writer, data any) error {
	return SendPacket(conn, ResponseBody, func(w io.Writer) error {
		data, err := json.Marshal(data)
		if err != nil {
			return err
		}
		w.Write(data)
		return nil
	})
}

func ReceivePacket(conn io.Reader) (uint16, []byte, error) {
	var packet Packet
	err := binary.Read(conn, binary.LittleEndian, &packet)
	if err != nil {
		return packet.MessageType, nil, err
	}
	data := make([]byte, packet.DataLength)
	_, err = conn.Read(data)
	return packet.MessageType, data, err
}