package decoder

import (
	"testing"

	"github.com/AFASystems/presence/internal/pkg/model"
)

func newParserRegistry() *model.ParserRegistry {
	return &model.ParserRegistry{ParserList: make(map[string]model.BeaconParser)}
}

func TestParserRegistry_AddParser(t *testing.T) {
	registry := newParserRegistry()
	config := model.Config{
		Name:    "test-parser",
		Min:     4,
		Max:     20,
		Pattern: []string{"0x02", "0x01"},
		Configs: map[string]model.ParserConfig{},
	}

	registry.Register("test-parser", config)

	if len(registry.ParserList) != 1 {
		t.Errorf("Expected 1 parser in registry, got %d", len(registry.ParserList))
	}
	if _, exists := registry.ParserList["test-parser"]; !exists {
		t.Error("Parser 'test-parser' should exist in registry")
	}
}

func TestParserRegistry_RemoveParser(t *testing.T) {
	registry := newParserRegistry()
	config := model.Config{Name: "test-parser", Min: 2, Max: 10, Pattern: []string{"0x02"}}
	registry.Register("test-parser", config)

	registry.Unregister("test-parser")

	if len(registry.ParserList) != 0 {
		t.Errorf("Expected 0 parsers in registry, got %d", len(registry.ParserList))
	}
	if _, exists := registry.ParserList["test-parser"]; exists {
		t.Error("Parser 'test-parser' should not exist in registry")
	}
}

func TestParserRegistry_UpdateParser(t *testing.T) {
	registry := newParserRegistry()
	config1 := model.Config{Name: "test-parser", Min: 2, Max: 10, Pattern: []string{"0x02"}}
	config2 := model.Config{Name: "test-parser", Min: 5, Max: 15, Pattern: []string{"0x03"}}

	registry.Register("test-parser", config1)
	registry.Register("test-parser", config2)

	if len(registry.ParserList) != 1 {
		t.Errorf("Expected 1 parser in registry, got %d", len(registry.ParserList))
	}
	if _, exists := registry.ParserList["test-parser"]; !exists {
		t.Error("Parser 'test-parser' should exist in registry")
	}
}

func TestParserRegistry_MultipleParsers(t *testing.T) {
	registry := newParserRegistry()
	parsers := []model.Config{
		{Name: "parser-1", Min: 2, Max: 10, Pattern: []string{"0x02"}},
		{Name: "parser-2", Min: 3, Max: 15, Pattern: []string{"0x03"}},
		{Name: "parser-3", Min: 4, Max: 20, Pattern: []string{"0x04"}},
	}

	for _, p := range parsers {
		registry.Register(p.Name, p)
	}

	if len(registry.ParserList) != 3 {
		t.Errorf("Expected 3 parsers in registry, got %d", len(registry.ParserList))
	}
	for _, p := range parsers {
		if _, exists := registry.ParserList[p.Name]; !exists {
			t.Errorf("Parser '%s' should exist in registry", p.Name)
		}
	}
}

func TestParserRegistry_RemoveNonExistent(t *testing.T) {
	registry := newParserRegistry()
	registry.Unregister("non-existent")

	if len(registry.ParserList) != 0 {
		t.Errorf("Expected 0 parsers, got %d", len(registry.ParserList))
	}
}

func TestParserRegistry_EmptyRegistry(t *testing.T) {
	registry := newParserRegistry()

	if len(registry.ParserList) != 0 {
		t.Errorf("Expected empty registry, got %d parsers", len(registry.ParserList))
	}
	registry.Unregister("anything")
}