package proto

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

// Header is the decoded form of a 16-byte CA message header.
// All integer fields are stored in host byte order after decoding.
type Header struct {
	Command     uint16
	PayloadSize uint32 // actual payload size (resolved from extended form if needed)
	DataType    uint16
	DataCount   uint32 // actual element count (resolved from extended form if needed)
	Parameter1  uint32
	Parameter2  uint32
}

// HeaderSize is the wire size of a standard CA header.
const HeaderSize = 16

// Encode writes the header to buf (must be at least HeaderSize bytes).
// If PayloadSize > 0xFFFE or DataCount > 0xFFFF the extended encoding is used
// and the caller must prepend an extra 8 bytes; use EncodeExtended instead.
func (h Header) Encode(buf []byte) {
	binary.BigEndian.PutUint16(buf[0:], h.Command)
	binary.BigEndian.PutUint16(buf[2:], uint16(h.PayloadSize))
	binary.BigEndian.PutUint16(buf[4:], h.DataType)
	binary.BigEndian.PutUint16(buf[6:], uint16(h.DataCount))
	binary.BigEndian.PutUint32(buf[8:], h.Parameter1)
	binary.BigEndian.PutUint32(buf[12:], h.Parameter2)
}

// Bytes returns the 16-byte wire encoding of h.
func (h Header) Bytes() []byte {
	buf := make([]byte, HeaderSize)
	h.Encode(buf)
	return buf
}

// DecodeHeader reads exactly one CA header from r, handling the extended
// encoding (payload_size == 0xFFFF) transparently.
// Returns the decoded Header and the number of bytes read (16 or 24).
func DecodeHeader(r io.Reader) (Header, int, error) {
	var raw [HeaderSize]byte
	if _, err := io.ReadFull(r, raw[:]); err != nil {
		return Header{}, 0, fmt.Errorf("ca: read header: %w", err)
	}

	h := Header{
		Command:    binary.BigEndian.Uint16(raw[0:]),
		DataType:   binary.BigEndian.Uint16(raw[4:]),
		Parameter1: binary.BigEndian.Uint32(raw[8:]),
		Parameter2: binary.BigEndian.Uint32(raw[12:]),
	}

	rawPayload := binary.BigEndian.Uint16(raw[2:])
	rawCount := binary.BigEndian.Uint16(raw[6:])

	// Extended message: payload_size == 0xFFFF means real sizes are in the
	// next 8 bytes (parameter1 = real payload size, parameter2 = real count).
	if rawPayload == 0xFFFF && rawCount == 0x0000 {
		var ext [8]byte
		if _, err := io.ReadFull(r, ext[:]); err != nil {
			return Header{}, 16, fmt.Errorf("ca: read extended header: %w", err)
		}
		h.PayloadSize = binary.BigEndian.Uint32(ext[0:])
		h.DataCount = binary.BigEndian.Uint32(ext[4:])
		// Note: parameter1/2 in the base header are overwritten by the extended values.
		// In practice, the original parameter1/2 are still valid — the extended header
		// only carries sizes, not the original parameters.  We already decoded parameter1/2
		// above from the base header.
		return h, 24, nil
	}

	h.PayloadSize = uint32(rawPayload)
	h.DataCount = uint32(rawCount)
	return h, 16, nil
}

// PadTo8 returns n rounded up to the nearest multiple of 8.
// CA requires all message payloads to be padded to 8-byte boundaries.
func PadTo8(n int) int {
	return (n + 7) &^ 7
}

// PadBytes appends zero bytes to b until len(b) is a multiple of 8.
func PadBytes(b []byte) []byte {
	need := PadTo8(len(b)) - len(b)
	return append(b, make([]byte, need)...)
}

// BuildMessage assembles a complete CA message (header + payload).
// payload may be nil for zero-length messages.
func BuildMessage(h Header, payload []byte) []byte {
	h.PayloadSize = uint32(len(payload))
	msg := make([]byte, HeaderSize+len(payload))
	h.Encode(msg)
	copy(msg[HeaderSize:], payload)
	return msg
}

// BuildStringPayload encodes a string as a null-terminated, 8-byte padded payload.
func BuildStringPayload(s string) []byte {
	b := append([]byte(s), 0) // null terminator
	return PadBytes(b)
}