package registry

import (
	"bytes"
	"reflect"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
)

func TestResolveUnboundRegistryHasExactEmptyProjection(t *testing.T) {
	registry, err := Resolve(contracts.ReferenceSet{})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	input := registry.PromptInput()
	if registry.Bound() || registry.Digest() != "" || registry.Count() != 0 || string(input.Content) != emptyPrompt {
		t.Fatalf("registry = %#v input = %#v, want unbound empty registry", registry, input)
	}
	if registry.ProjectionDigest() == "" || input.Digest != registry.ProjectionDigest() || input.OriginURI != "" {
		t.Fatalf("projection digest/input = %q/%#v", registry.ProjectionDigest(), input)
	}
}

func TestResolveKeepsDurableProvenanceAndProjectsOnlyOrderedNames(t *testing.T) {
	list := registryFixture()
	registry := resolveList(t, list)
	if !registry.Bound() || registry.Digest() == "" || registry.Count() != 2 {
		t.Fatalf("registry identity = bound %t digest %q count %d", registry.Bound(), registry.Digest(), registry.Count())
	}
	if got := string(registry.PromptInput().Content); got != `{"npcs":[{"name":"Mira Thorn"},{"name":"Captain Vale"}]}` {
		t.Fatalf("prompt projection = %s", got)
	}
	for _, forbidden := range []string{"npc:sha256:", "source_refs", "source_id", "session-alpha"} {
		if strings.Contains(string(registry.PromptInput().Content), forbidden) {
			t.Fatalf("projection leaked %q: %s", forbidden, registry.PromptInput().Content)
		}
	}
	if registry.PromptInput().Digest != registry.ProjectionDigest() || registry.Digest() == registry.ProjectionDigest() {
		t.Fatalf("full/projection digests = %q/%q", registry.Digest(), registry.ProjectionDigest())
	}
}

func TestNameProjectionDigestTracksOnlyNamesAndOrder(t *testing.T) {
	base := registryFixture()
	evidenceChanged := registryFixture()
	evidenceChanged.NPCs[0].ID = "different application id"
	evidenceChanged.NPCs[0].SourceRefs = []source.SourceRef{{SourceID: "other", StartUnitID: 40, EndUnitID: 41}}
	baseBytes, err := nameProjection(base)
	if err != nil {
		t.Fatal(err)
	}
	changedBytes, err := nameProjection(evidenceChanged)
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(baseBytes, changedBytes) || semanticDigest(baseBytes) != semanticDigest(changedBytes) {
		t.Fatalf("equivalent name projections differ: %s / %s", baseBytes, changedBytes)
	}

	nameChanged := registryFixture()
	nameChanged.NPCs[0].Name = "The Greencloak"
	nameBytes, _ := nameProjection(nameChanged)
	orderChanged := registryFixture()
	orderChanged.NPCs[0], orderChanged.NPCs[1] = orderChanged.NPCs[1], orderChanged.NPCs[0]
	orderBytes, _ := nameProjection(orderChanged)
	if bytes.Equal(baseBytes, nameBytes) || bytes.Equal(baseBytes, orderBytes) {
		t.Fatalf("name/order changes did not change projection: %s %s %s", baseBytes, nameBytes, orderBytes)
	}
}

func TestRegistryLookupAndAccessorsAreImmutable(t *testing.T) {
	registry := resolveList(t, registryFixture())
	if npc, ok := registry.Lookup("  mIRA\u2003thorn "); !ok || npc.Name != "Mira Thorn" {
		t.Fatalf("Lookup() = %#v, %t", npc, ok)
	}
	if _, ok := registry.Lookup("The Greencloak"); ok {
		t.Fatal("Lookup() accepted a non-canonical name")
	}

	npcs := registry.NPCs()
	npcs[0].Name = "changed"
	npcs[0].SourceRefs[0].SourceID = "changed"
	content := registry.CanonicalBytes()
	content[0] = '['
	input := registry.PromptInput()
	input.Content[0] = '['
	if next := registry.NPCs()[0]; next.Name != "Mira Thorn" || next.SourceRefs[0].SourceID != "session-alpha" {
		t.Fatalf("registry mutated through accessor: %#v", next)
	}
	if registry.CanonicalBytes()[0] != '{' || registry.PromptInput().Content[0] != '{' {
		t.Fatal("registry bytes mutated through accessor")
	}
}

func TestResolveRejectsMalformedOrUnsupportedRegistryInput(t *testing.T) {
	for _, item := range []contracts.ReferenceItem{
		{MediaType: "application/json", Content: []byte(`{"npcs":[`)},
		{MediaType: "text/plain", Content: []byte(`{"npcs":[]}`)},
	} {
		_, err := Resolve(referenceSet(item))
		if err == nil {
			t.Fatalf("Resolve(%s) error = nil", item.Content)
		}
	}
}

func TestResolverReusesEquivalentCanonicalRegistries(t *testing.T) {
	set := listReferenceSet(t, registryFixture())
	resolver, err := NewResolver(set)
	if err != nil {
		t.Fatal(err)
	}
	resolved, err := resolver.Resolve(set)
	if err != nil || resolved != resolver.Seeded() {
		t.Fatalf("Resolve() = %p, %v; seeded %p", resolved, err, resolver.Seeded())
	}
}

func registryFixture() dnd.NPCList {
	return dnd.NPCList{NPCs: []dnd.NPC{
		{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}}},
		{ID: identity.DeriveID("Captain Vale"), Name: "Captain Vale", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}}},
	}}
}

func resolveList(t *testing.T, list dnd.NPCList) *Registry {
	t.Helper()
	registry, err := Resolve(listReferenceSet(t, list))
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	return registry
}

func listReferenceSet(t *testing.T, list dnd.NPCList) contracts.ReferenceSet {
	t.Helper()
	content, err := npccodec.New().Encode(list)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}
	return referenceSet(contracts.ReferenceItem{SlotName: ReferenceSlot, MediaType: npccodec.MediaType, Content: content})
}

func referenceSet(item contracts.ReferenceItem) contracts.ReferenceSet {
	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: []contracts.ReferenceItem{item}}}}
}

func TestProjectionIsStableForEquivalentNormalizedRegistries(t *testing.T) {
	first := resolveList(t, registryFixture())
	secondList := registryFixture()
	secondList.NPCs[0].SourceRefs = append(secondList.NPCs[0].SourceRefs, source.SourceRef{SourceID: "session-beta", StartUnitID: 8, EndUnitID: 8})
	second := resolveList(t, secondList)
	if !reflect.DeepEqual(first.PromptInput().Content, second.PromptInput().Content) || first.ProjectionDigest() != second.ProjectionDigest() || first.Digest() == second.Digest() {
		t.Fatalf("projection/full identity mismatch: %#v %#v", first, second)
	}
}