package parser

import (
	"testing"
)

// Hilfsfunktion zum Berechnen der Checksumme
func calcChecksum(msgType byte, length byte, payload []byte) byte {
	cs := msgType ^ length
	for _, b := range payload {
		cs ^= b
	}
	return cs
}

func TestParser_ParseBytes(t *testing.T) {
	tests := []struct {
		name           string
		input          []byte
		expectErr      bool
		expectMessages []ParsedMessage
	}{
		{
			name: "valid single message",
			input: func() []byte {
				msgType := byte(0x01)
				payload := []byte{0x10, 0x20}
				length := byte(len(payload))
				cs := calcChecksum(msgType, length, payload)
				return []byte{0xAA, msgType, length, payload[0], payload[1], cs}
			}(),
			expectErr: false,
			expectMessages: []ParsedMessage{
				{typeByte: 0x01, payloadBytes: []byte{0x10, 0x20}},
			},
		},
		{
			name: "invalid checksum",
			input: []byte{
				0xAA, 0x02, 0x01, 0x33, 0x00, // falsche Checksumme (letztes Byte)
			},
			expectErr:      true,
			expectMessages: nil,
		},
		{
			name: "no start byte",
			input: []byte{
				0x01, 0x02, 0x03,
			},
			expectErr:      false,
			expectMessages: nil,
		},
		{
			name: "multiple valid messages",
			input: func() []byte {
				payload1 := []byte{0x11}
				payload2 := []byte{0x22, 0x23}
				cs1 := calcChecksum(0x01, 1, payload1)
				cs2 := calcChecksum(0x02, 2, payload2)
				return append(
					[]byte{0xAA, 0x01, 0x01, payload1[0], cs1,
						0xAA, 0x02, 0x02, payload2[0], payload2[1], cs2},
				)
			}(),
			expectErr: false,
			expectMessages: []ParsedMessage{
				{typeByte: 0x01, payloadBytes: []byte{0x11}},
				{typeByte: 0x02, payloadBytes: []byte{0x22, 0x23}},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			parser := NewParser(ParserConfig{StartByte: 0xAA})
			n, err := parser.ParseBytes(tt.input)

			if tt.expectErr && err == nil {
				t.Errorf("expected error, got none")
			}
			if !tt.expectErr && err != nil {
				t.Errorf("unexpected error: %v", err)
			}
			if !tt.expectErr && n != len(tt.input) {
				t.Errorf("expected to read %d bytes, read %d", len(tt.input), n)
			}

			for i, expected := range tt.expectMessages {
				if !parser.IsMessageAvailable() {
					t.Errorf("expected message %d to be available", i)
					break
				}
				msgtype, msgpayload, err := parser.GetNextMessage()
				if err != nil {
					t.Errorf("unexpected error when getting message: %v", err)
				}
				if msgtype != expected.typeByte {
					t.Errorf("message %d: expected type 0x%02X, got 0x%02X", i, expected.typeByte, msgtype)
				}
				if !equalBytes(msgpayload, expected.payloadBytes) {
					t.Errorf("message %d: expected payload %v, got %v", i, expected.payloadBytes, msgpayload)
				}
			}
		})
	}
}

func equalBytes(a, b []byte) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}