package registry

import (
	"bytes"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"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 TestResolverValidatesStaticAndOperationReferences(t *testing.T) {
	placeholder, err := NewResolver(referenceSet())
	if err != nil || placeholder.Seeded().Bound() {
		t.Fatalf("generated placeholder = %#v, %v; want unbound seed", placeholder, err)
	}

	valid := listReferenceSet(t, registryFixture())
	validContent := valid.Slots[ReferenceSlot].Items[0].Content
	invalidSets := []contracts.ReferenceSet{
		referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: []byte(`{"npcs":[`)}),
		referenceSet(contracts.ReferenceItem{MediaType: "text/plain", Content: validContent}),
		referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: make([]byte, MaxBytes+1)}),
		referenceSet(
			contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: validContent},
			contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: validContent},
		),
	}
	for index, references := range invalidSets {
		if _, err := NewResolver(references); err == nil {
			t.Fatalf("NewResolver(invalid %d) error = nil", index)
		}
		if _, err := placeholder.Resolve(references); err == nil {
			t.Fatalf("Resolve(invalid %d) error = nil", index)
		}
	}

	staticContent := append([]byte(nil), validContent...)
	staticReferences := referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: staticContent})
	seeded, err := NewResolver(staticReferences)
	if err != nil {
		t.Fatal(err)
	}
	staticContent[0] = '['
	delete(staticReferences.Slots, ReferenceSlot)
	if seeded.Seeded().Count() != 2 || seeded.Seeded().CanonicalBytes()[0] != '{' {
		t.Fatalf("seeded registry retained construction references: %#v", seeded.Seeded())
	}
}

func TestResolverCachesEquivalentRegistriesConcurrentlyAndIgnoresCallerDigest(t *testing.T) {
	resolver, err := NewResolver(referenceSet())
	if err != nil {
		t.Fatal(err)
	}
	content := listReferenceSet(t, registryFixture()).Slots[ReferenceSlot].Items[0].Content
	references := referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: content})
	first, err := resolver.Resolve(references)
	if err != nil {
		t.Fatal(err)
	}
	second, err := resolver.Resolve(references)
	if err != nil || second != first {
		t.Fatalf("raw reuse = %p / %p, %v", first, second, err)
	}
	spaced := append([]byte("\n "), content...)
	spaced = append(spaced, '\n')
	equivalent, err := resolver.Resolve(referenceSet(contracts.ReferenceItem{MediaType: "APPLICATION/JSON; charset=utf-8", Content: spaced}))
	if err != nil || equivalent != first {
		t.Fatalf("semantic reuse = %p / %p, %v", first, equivalent, err)
	}

	const callers = 24
	var group sync.WaitGroup
	errors := make(chan error, callers)
	for range callers {
		group.Add(1)
		go func() {
			defer group.Done()
			resolved, err := resolver.Resolve(references)
			if err != nil || resolved != first {
				errors <- fmt.Errorf("resolved %p, want %p: %w", resolved, first, err)
			}
		}()
	}
	group.Wait()
	close(errors)
	for err := range errors {
		t.Error(err)
	}

	sharedDigest := "sha256:" + strings.Repeat("0", 64)
	firstItem := contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: content, Digest: sharedDigest}
	otherList := registryFixture()
	otherList.NPCs[0].Name = "The Greencloak"
	otherList.NPCs[0].ID = identity.DeriveID(otherList.NPCs[0].Name)
	otherContent := listReferenceSet(t, otherList).Slots[ReferenceSlot].Items[0].Content
	otherItem := contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: otherContent, Digest: sharedDigest}
	byDigestFirst, err := resolver.Resolve(referenceSet(firstItem))
	if err != nil {
		t.Fatal(err)
	}
	byDigestOther, err := resolver.Resolve(referenceSet(otherItem))
	if err != nil || byDigestFirst == byDigestOther || byDigestFirst.Digest() == byDigestOther.Digest() {
		t.Fatalf("caller digest aliased different registries: %p / %p, %v", byDigestFirst, byDigestOther, err)
	}

	content[0] = '['
	if npc, ok := first.Lookup("Mira Thorn"); !ok || npc.Name != "Mira Thorn" {
		t.Fatalf("resolved registry retained operation bytes: %#v, %t", npc, ok)
	}
	if fallback, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || fallback != resolver.Seeded() || fallback.Bound() {
		t.Fatalf("fallback = %#v, %v; want unbound seed", fallback, err)
	}
}

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(items ...contracts.ReferenceItem) contracts.ReferenceSet {
	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: items}}}
}

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)
	}
}