package wayland

import (
	"encoding/binary"
	"testing"
)

func TestPad4(t *testing.T) {
	cases := []struct {
		in   int
		want int
	}{
		{0, 0},
		{1, 4},
		{2, 4},
		{3, 4},
		{4, 4},
		{5, 8},
		{13, 16},
		{14, 16},
	}
	for _, tc := range cases {
		if got := pad4(tc.in); got != tc.want {
			t.Errorf("pad4(%d) = %d, want %d", tc.in, got, tc.want)
		}
	}
}

func TestEncodeDecodeString(t *testing.T) {
	s := "wl_compositor"
	enc := encodeString(s)

	strLen := binary.LittleEndian.Uint32(enc[:4])
	if strLen != 14 {
		t.Fatalf("strLen = %d, want 14", strLen)
	}

	if len(enc) != 20 {
		t.Fatalf("total encoded len = %d, want 20", len(enc))
	}

	if enc[17] != 0 {
		t.Errorf("expected NUL at byte 17, got %d", enc[17])
	}
	if enc[18] != 0 || enc[19] != 0 {
		t.Errorf("padding bytes non-zero: %d, %d", enc[18], enc[19])
	}

	dec, nextOff, err := decodeString(enc, 0)
	if err != nil {
		t.Fatalf("decodeString failed: %v", err)
	}
	if dec != s {
		t.Errorf("decoded %q != want %q", dec, s)
	}
	if nextOff != len(enc) {
		t.Errorf("nextOff %d != %d", nextOff, len(enc))
	}
}

func TestDecodeStringEdgeCases(t *testing.T) {
	// 1. Empty data
	if _, _, err := decodeString(nil, 0); err == nil {
		t.Error("expected error on empty data")
	}

	// 2. strLen == 0
	var buf0 [4]byte
	binary.LittleEndian.PutUint32(buf0[:], 0)
	s, off, err := decodeString(buf0[:], 0)
	if err != nil || s != "" || off != 4 {
		t.Errorf("strLen=0: got (%q, %d, %v), want empty", s, off, err)
	}

	// 3. strLen == 1 (just NUL)
	buf1 := []byte{1, 0, 0, 0, 0, 0, 0, 0}
	s1, off1, err1 := decodeString(buf1, 0)
	if err1 != nil || s1 != "" || off1 != 8 {
		t.Errorf("strLen=1: got (%q, %d, %v), want empty", s1, off1, err1)
	}

	// 4. Truncated payload
	bufTrunc := []byte{10, 0, 0, 0, 'a', 'b', 'c'}
	if _, _, err := decodeString(bufTrunc, 0); err == nil {
		t.Error("expected error on truncated payload")
	}
}