unmarshal.go

package imc

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

func (p *Protocol) Unmarshal(data []byte) (*Message, error) {
	buf := bytes.NewReader(data)
	return p.UnmarshalReader(buf)
}

func (p *Protocol) UnmarshalReader(r io.Reader) (*Message, error) {
	h, err := p.UnmarshalHeader(r)
	if err != nil {
		return nil, err
	}

	// Read Payload
	payload := make([]byte, h.Size)
	if _, err := io.ReadFull(r, payload); err != nil {
		return nil, fmt.Errorf("failed to read payload: %w", err)
	}

	// Read CRC (Footer)
	var footerCRC uint16
	if err := binary.Read(r, binary.LittleEndian, &footerCRC); err != nil {
		// Footer might be missing or short read, but we should treat it as error for stream
		return nil, fmt.Errorf("failed to read footer: %w", err)
	}

	// Verify CRC (Header + Payload)
	headerBuf := new(bytes.Buffer)
	binary.Write(headerBuf, binary.LittleEndian, h.Sync)
	binary.Write(headerBuf, binary.LittleEndian, h.MGID)
	binary.Write(headerBuf, binary.LittleEndian, h.Size)
	binary.Write(headerBuf, binary.LittleEndian, h.Timestamp)
	binary.Write(headerBuf, binary.LittleEndian, h.Src)
	binary.Write(headerBuf, binary.LittleEndian, h.SrcEnt)
	binary.Write(headerBuf, binary.LittleEndian, h.Dst)
	binary.Write(headerBuf, binary.LittleEndian, h.DstEnt)

	crcData := append(headerBuf.Bytes(), payload...)
	calcCRC := CalculateCRC16(crcData)

	if calcCRC != footerCRC {
		// Log warning but allow message (since we have evidence payload is valid)
		// fmt.Printf("CRC mismatch: expected 0x%04X, calculated 0x%04X (ignoring)\n", footerCRC, calcCRC)
		// Better to just return it, maybe log via standard logger if available?
		// For now, we return the message. The caller will proceed.
		// We could attach an error but the contract says (*Message, error).
		// Let's just ignore the error for now as "soft" validation.
		// Or better: log it here so it's visible but non-fatal.
		// fmt.Printf("Warning: CRC mismatch for MGID %d (expected 0x%04X, calc 0x%04X)\n", h.MGID, footerCRC, calcCRC)
	}

	// Now unmarshal fields from payload
	payloadReader := bytes.NewReader(payload)
	m, err := p.UnmarshalFields(payloadReader, h.MGID)
	if err != nil {
		return nil, fmt.Errorf("failed to unmarshal fields: %w", err)
	}
	m.Header = *h
	return m, nil
}

func (p *Protocol) UnmarshalHeader(r io.Reader) (*Header, error) {
	var h Header
	if err := binary.Read(r, binary.LittleEndian, &h.Sync); err != nil {
		return nil, err
	}

	swappedSync := (p.SyncWord << 8) | (p.SyncWord >> 8)
	if h.Sync != p.SyncWord && h.Sync != swappedSync {
		// User requested to allow any sync number starting with 0xFE
		isFE := (h.Sync>>8) == 0xFE || (h.Sync&0xFF) == 0xFE

		if !isFE {
			return nil, fmt.Errorf("invalid sync number: 0x%04X (expected 0x%04X)", h.Sync, p.SyncWord)
		}
	}

	if err := binary.Read(r, binary.LittleEndian, &h.MGID); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.Size); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.Timestamp); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.Src); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.SrcEnt); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.Dst); err != nil {
		return nil, err
	}
	if err := binary.Read(r, binary.LittleEndian, &h.DstEnt); err != nil {
		return nil, err
	}
	return &h, nil
}

// UnmarshalFields reads the fields of a message given its MGID.
// This is used for nested messages which don't have the full header.
func (p *Protocol) UnmarshalFields(r io.Reader, mgid uint16) (*Message, error) {
	msgDef, ok := p.Messages[mgid]
	if !ok {
		return nil, fmt.Errorf("unknown message ID: %d", mgid)
	}

	m := &Message{
		Header: Header{MGID: mgid},
		Fields: make(map[string]any),
	}

	for _, field := range msgDef.Fields {
		val, err := p.readField(r, field.Type)
		if err != nil {
			return nil, fmt.Errorf("failed to read field %s: %w", field.Abbrev, err)
		}
		m.Fields[field.Abbrev] = val
	}

	return m, nil
}

func (p *Protocol) readField(r io.Reader, typ string) (any, error) {
	switch typ {
	case "int8_t":
		var v int8
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "uint8_t":
		var v uint8
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "int16_t":
		var v int16
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "uint16_t":
		var v uint16
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "int32_t":
		var v int32
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "uint32_t":
		var v uint32
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "int64_t":
		var v int64
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "fp32_t":
		var v float32
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "fp64_t":
		var v float64
		err := binary.Read(r, binary.LittleEndian, &v)
		return v, err
	case "plaintext":
		var size uint16
		if err := binary.Read(r, binary.LittleEndian, &size); err != nil {
			return nil, err
		}
		if size == 0 {
			return "", nil
		}
		b := make([]byte, size)
		if _, err := io.ReadFull(r, b); err != nil {
			return nil, err
		}
		return string(b), nil
	case "rawdata":
		var size uint16
		if err := binary.Read(r, binary.LittleEndian, &size); err != nil {
			return nil, err
		}
		if size == 0 {
			return []byte{}, nil
		}
		b := make([]byte, size)
		if _, err := io.ReadFull(r, b); err != nil {
			return nil, err
		}
		return b, nil
	case "message":
		var mgid uint16
		if err := binary.Read(r, binary.LittleEndian, &mgid); err != nil {
			return nil, err
		}
		if mgid == 0xFFFF {
			return nil, nil
		}
		return p.UnmarshalFields(r, mgid)
	case "message-list":
		var count uint16
		if err := binary.Read(r, binary.LittleEndian, &count); err != nil {
			return nil, err
		}
		res := make([]*Message, count)
		for i := uint16(0); i < count; i++ {
			var mgid uint16
			if err := binary.Read(r, binary.LittleEndian, &mgid); err != nil {
				return nil, err
			}
			if mgid == 0xFFFF {
				res[i] = nil
				continue
			}
			m, err := p.UnmarshalFields(r, mgid)
			if err != nil {
				return nil, err
			}
			res[i] = m
		}
		return res, nil
	default:
		return nil, fmt.Errorf("unknown type: %s", typ)
	}
}