package mapping

import (
	"regexp"
	"testing"

	"git.noodles.cam/claude-skills/marketplace/cli/internal/issue"
)

var hexColor = regexp.MustCompile(`^#[0-9a-f]{6}$`)

// The canonical set is the domain's, and every member of it must have a color
// here. A type added over in the taxonomy that arrived as grey would look like
// a label somebody created by hand.
func TestEveryCanonicalLabelHasAColor(t *testing.T) {
	for _, name := range issue.CanonicalLabels() {
		color := LabelColor(name)
		switch {
		case color == DefaultColor:
			t.Errorf("%s has no color of its own", name)
		case !hexColor.MatchString(color):
			t.Errorf("%s = %q, want #rrggbb in lower case", name, color)
		}
	}
	// And the other direction: a color left behind after a label was retired
	// paints nothing and is a lie about what the taxonomy holds.
	if len(labelColors) != len(issue.CanonicalLabels()) {
		t.Errorf("%d colors for %d canonical labels — one of the two lists moved without the other",
			len(labelColors), len(issue.CanonicalLabels()))
	}
	// Anything outside the set is project-specific and nobody here can guess
	// what it means.
	if got := LabelColor("tech/sql"); got != DefaultColor {
		t.Errorf("LabelColor(tech/sql) = %q, want the default", got)
	}
}

func TestLabelSpecs(t *testing.T) {
	cases := []struct {
		name        string
		description string
		exclusive   bool
	}{
		{"type/bug", "Something behaves incorrectly in existing code", true},
		{"type/draft", "Idea captured for later; not ready for work", true},
		{"severity/critical", "", true},
		// Exclusivity is a property of the namespace, not of the members the
		// taxonomy happens to know.
		{"type/spike", "", true},
		{"tech/sql", "", false},
		{"comp/appclick", "", false},
	}
	names := make([]string, len(cases))
	for i, c := range cases {
		names[i] = c.name
	}

	specs := LabelSpecs(names)
	if len(specs) != len(cases) {
		t.Fatalf("%d specs for %d names", len(specs), len(cases))
	}
	for i, c := range cases {
		got := specs[i]
		// The order is the taxonomy's: a bootstrap prints its plan in it, and
		// two identical runs must not look like different ones.
		if got.Name != c.name {
			t.Fatalf("spec %d is %s, want %s", i, got.Name, c.name)
		}
		if got.Description != c.description {
			t.Errorf("%s description = %q, want %q", c.name, got.Description, c.description)
		}
		if got.Exclusive != c.exclusive {
			t.Errorf("%s exclusive = %v, want %v", c.name, got.Exclusive, c.exclusive)
		}
		if got.Color != LabelColor(c.name) {
			t.Errorf("%s color = %q", c.name, got.Color)
		}
	}
}

func TestCanonicalLabelSpecsAreTheDomainsList(t *testing.T) {
	specs := CanonicalLabelSpecs()
	want := issue.CanonicalLabels()
	if len(specs) != len(want) {
		t.Fatalf("%d specs, want %d", len(specs), len(want))
	}
	for i, name := range want {
		if specs[i].Name != name {
			t.Errorf("spec %d = %s, want %s", i, specs[i].Name, name)
		}
		if !specs[i].Exclusive {
			t.Errorf("%s must be exclusive — the canonical set IS the exclusive namespaces", name)
		}
	}
}