package packets

import (
	"eq2emu/internal/common"
	"eq2emu/internal/packets/parser"
	"testing"
)

func TestPacketBuilderSimpleFields(t *testing.T) {
	// Create a simple packet definition for testing
	def := parser.NewPacketDef(5)

	// Add some basic fields
	def.Fields["field1"] = parser.FieldDesc{
		Type: common.TypeInt8,
	}
	def.Fields["field2"] = parser.FieldDesc{
		Type: common.TypeString8,
	}
	def.Fields["field3"] = parser.FieldDesc{
		Type: common.TypeInt32,
	}

	// Set field order
	def.Orders[1] = []string{"field1", "field2", "field3"}

	// Create test data
	data := map[string]any{
		"field1": uint8(42),
		"field2": "hello",
		"field3": uint32(12345),
	}

	// Build packet
	builder := NewPacketBuilder(def, 1, 0)
	packetData, err := builder.Build(data)
	if err != nil {
		t.Errorf("Failed to build simple packet: %v", err)
		return
	}

	expectedMinLength := 1 + 1 + 5 + 4 // uint8 + string8(len+data) + uint32
	if len(packetData) < expectedMinLength {
		t.Errorf("Built packet too short: got %d bytes, expected at least %d", len(packetData), expectedMinLength)
		return
	}

	t.Logf("Successfully built simple packet (%d bytes)", len(packetData))

	// Verify the first byte is correct
	if packetData[0] != 42 {
		t.Errorf("First field incorrect: got %d, expected 42", packetData[0])
	}
}

func TestPacketBuilderOptionalFields(t *testing.T) {
	// Create a packet definition with optional fields
	def := parser.NewPacketDef(3)

	def.Fields["required"] = parser.FieldDesc{
		Type: common.TypeInt8,
	}
	def.Fields["optional"] = parser.FieldDesc{
		Type:     common.TypeInt8,
		Optional: true,
	}

	def.Orders[1] = []string{"required", "optional"}

	// Test with only required field
	data := map[string]any{
		"required": uint8(123),
	}

	builder := NewPacketBuilder(def, 1, 0)
	packetData, err := builder.Build(data)
	if err != nil {
		t.Errorf("Failed to build packet with optional fields: %v", err)
		return
	}

	expectedLength := 2 // required + optional default
	if len(packetData) != expectedLength {
		t.Errorf("Built packet wrong length: got %d bytes, expected %d", len(packetData), expectedLength)
		return
	}

	t.Logf("Successfully built packet with optional fields (%d bytes)", len(packetData))
}

func TestPacketBuilderMissingRequiredField(t *testing.T) {
	// Create a packet definition
	def := parser.NewPacketDef(2)

	def.Fields["required"] = parser.FieldDesc{
		Type: common.TypeInt8,
	}
	def.Fields["also_required"] = parser.FieldDesc{
		Type: common.TypeInt16,
	}

	def.Orders[1] = []string{"required", "also_required"}

	// Test with missing required field
	data := map[string]any{
		"required": uint8(123),
		// missing "also_required"
	}

	builder := NewPacketBuilder(def, 1, 0)
	_, err := builder.Build(data)
	if err == nil {
		t.Error("Expected error for missing required field, but got none")
		return
	}

	t.Logf("Correctly detected missing required field: %v", err)
}

func TestPacketBuilderStringTypes(t *testing.T) {
	// Test different string types
	def := parser.NewPacketDef(3)

	def.Fields["str8"] = parser.FieldDesc{
		Type: common.TypeString8,
	}
	def.Fields["str16"] = parser.FieldDesc{
		Type: common.TypeString16,
	}
	def.Fields["str32"] = parser.FieldDesc{
		Type: common.TypeString32,
	}

	def.Orders[1] = []string{"str8", "str16", "str32"}

	data := map[string]any{
		"str8":  "test8",
		"str16": "test16",
		"str32": "test32",
	}

	builder := NewPacketBuilder(def, 1, 0)
	packetData, err := builder.Build(data)
	if err != nil {
		t.Errorf("Failed to build packet with strings: %v", err)
		return
	}

	// Verify we have some data
	if len(packetData) < 20 { // rough estimate
		t.Errorf("Built packet too short for string data: %d bytes", len(packetData))
		return
	}

	t.Logf("Successfully built packet with strings (%d bytes)", len(packetData))
}

func TestBuildPacketConvenienceFunction(t *testing.T) {
	// Test the convenience function
	data := map[string]any{
		"username": "testuser",
		"password": "testpass",
	}

	// This should fail since we don't have a "TestPacket" defined
	_, err := BuildPacket("NonExistentPacket", data, 1, 0)
	if err == nil {
		t.Error("Expected error for non-existent packet, but got none")
		return
	}

	t.Logf("Correctly detected non-existent packet: %v", err)
}