package packets

import (
	"encoding/binary"
	"unsafe"
)

type PacketWriter struct {
	data []byte
}

func NewPacketWriter() *PacketWriter {
	return &PacketWriter{
		data: make([]byte, 0, 512),
	}
}

func NewPacketWriterSize(size int) *PacketWriter {
	return &PacketWriter{
		data: make([]byte, 0, size),
	}
}

func (w *PacketWriter) Bytes() []byte {
	return w.data
}

func (w *PacketWriter) Len() int {
	return len(w.data)
}

func (w *PacketWriter) Reset() {
	w.data = w.data[:0]
}

func (w *PacketWriter) WriteBytes(data []byte) {
	w.data = append(w.data, data...)
}

func (w *PacketWriter) WriteUint8(val uint8) {
	w.data = append(w.data, val)
}

func (w *PacketWriter) WriteInt8(val int8) {
	w.WriteUint8(uint8(val))
}

func (w *PacketWriter) WriteUint16(val uint16) {
	b := make([]byte, 2)
	binary.LittleEndian.PutUint16(b, val)
	w.data = append(w.data, b...)
}

func (w *PacketWriter) WriteInt16(val int16) {
	w.WriteUint16(uint16(val))
}

func (w *PacketWriter) WriteUint32(val uint32) {
	b := make([]byte, 4)
	binary.LittleEndian.PutUint32(b, val)
	w.data = append(w.data, b...)
}

func (w *PacketWriter) WriteInt32(val int32) {
	w.WriteUint32(uint32(val))
}

func (w *PacketWriter) WriteUint64(val uint64) {
	b := make([]byte, 8)
	binary.LittleEndian.PutUint64(b, val)
	w.data = append(w.data, b...)
}

func (w *PacketWriter) WriteInt64(val int64) {
	w.WriteUint64(uint64(val))
}

func (w *PacketWriter) WriteFloat32(val float32) {
	bits := *(*uint32)(unsafe.Pointer(&val))
	w.WriteUint32(bits)
}

func (w *PacketWriter) WriteFloat64(val float64) {
	bits := *(*uint64)(unsafe.Pointer(&val))
	w.WriteUint64(bits)
}

func (w *PacketWriter) WriteString(s string) {
	w.WriteUint16(uint16(len(s)))
	w.data = append(w.data, []byte(s)...)
}

func (w *PacketWriter) WriteStringFixed(s string, length int) {
	data := make([]byte, length)
	copy(data, []byte(s))
	w.data = append(w.data, data...)
}

func (w *PacketWriter) WriteCString(s string) {
	w.data = append(w.data, []byte(s)...)
	w.data = append(w.data, 0)
}

func (w *PacketWriter) WriteEQ2String(s string) {
	w.WriteString(s)
}

func (w *PacketWriter) WritePackedInt(val uint32) {
	if val < 0xFF {
		w.WriteUint8(uint8(val))
	} else if val < 0xFFFF {
		w.WriteUint8(0xFF)
		w.WriteUint16(uint16(val))
	} else {
		w.WriteUint8(0xFF)
		w.WriteUint16(0xFFFF)
		w.WriteUint32(val)
	}
}

func (w *PacketWriter) WriteBool(val bool) {
	if val {
		w.WriteUint8(1)
	} else {
		w.WriteUint8(0)
	}
}

func (w *PacketWriter) WriteZeros(count int) {
	zeros := make([]byte, count)
	w.data = append(w.data, zeros...)
}

func (w *PacketWriter) SetUint16At(pos int, val uint16) {
	if pos+1 < len(w.data) {
		binary.LittleEndian.PutUint16(w.data[pos:], val)
	}
}

func (w *PacketWriter) SetUint32At(pos int, val uint32) {
	if pos+3 < len(w.data) {
		binary.LittleEndian.PutUint32(w.data[pos:], val)
	}
}