package npcoccurrences

import (
	"bytes"
	"encoding/json"
	"errors"
	"os"
	"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/framework/pipeline"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
)

func validList() dnd.NPCOccurrenceList {
	return dnd.NPCOccurrenceList{Occurrences: []dnd.NPCOccurrence{
		{
			NPCID: "npc:test-mira", Name: "Mira Thorn", Kind: dnd.NPCOccurrenceKindDialogue,
			SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}},
		},
		{
			NPCID: "npc:test-guard", Name: "Hooded Guard", Kind: dnd.NPCOccurrenceKindCombatOpponent,
			SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}},
		},
	}}
}

func TestCodecMatchesMaintainedDurableFixture(t *testing.T) {
	raw, err := os.ReadFile("testdata/dnd_npc_occurrences.v1.json")
	if err != nil {
		t.Fatal(err)
	}
	codec := New()
	value, err := codec.Decode(raw)
	if err != nil {
		t.Fatalf("Decode() error = %v", err)
	}
	if want := validList(); !reflect.DeepEqual(value, want) {
		t.Fatalf("Decode() = %#v, want %#v", value, want)
	}
	encoded, err := codec.Encode(value)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}
	var compact bytes.Buffer
	if err := json.Compact(&compact, raw); err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(encoded, compact.Bytes()) {
		t.Fatalf("Encode() = %s, want %s", encoded, compact.Bytes())
	}
}

func TestCodecOwnsDurableSchemaAndRegistersExactType(t *testing.T) {
	codec := New()
	schema := codec.Schema()
	if codec.Kind() != dnd.NPCOccurrenceListKind || codec.MediaType() != MediaType {
		t.Fatalf("codec identity = %q/%q", codec.Kind(), codec.MediaType())
	}
	if schema.ID != SchemaID || schema.Name != SchemaName || schema.Version != SchemaVersion || !json.Valid(schema.JSONSchema) {
		t.Fatalf("schema = %#v", schema)
	}
	registry := pipeline.NewArtifactCodecRegistry()
	if err := pipeline.RegisterArtifactCodec(registry, codec); err != nil {
		t.Fatal(err)
	}
	spec, ok := registry.Spec(dnd.NPCOccurrenceListKind)
	if !ok || spec.SchemaDigest != contracts.DigestArtifactSchema(schema) {
		t.Fatalf("registered spec = %#v, %t", spec, ok)
	}
	if _, err := registry.Encode(dnd.NPCOccurrenceListKind, dnd.NPCRegistry{}); err == nil {
		t.Fatal("Encode() error = nil, want exact type rejection")
	} else {
		var typeErr *pipeline.ArtifactCodecTypeError
		if !errors.As(err, &typeErr) {
			t.Fatalf("Encode() error = %T, want ArtifactCodecTypeError", err)
		}
	}
}

func TestCodecSupportsEmptyListAndPreservesCollectionPresenceInCandidates(t *testing.T) {
	codec := New()
	empty := dnd.NPCOccurrenceList{Occurrences: []dnd.NPCOccurrence{}}
	content, err := codec.Encode(empty)
	if err != nil || string(content) != `{"occurrences":[]}` {
		t.Fatalf("Encode() = %s, %v", content, err)
	}
	for _, candidate := range []dnd.NPCOccurrenceList{
		{},
		empty,
		{Occurrences: []dnd.NPCOccurrence{{NPCID: "npc:test", Name: " ", Kind: "unsupported", SourceRefs: nil}}},
		{Occurrences: []dnd.NPCOccurrence{{NPCID: "npc:test", Name: " ", Kind: "unsupported", SourceRefs: []source.SourceRef{}}}},
		{Occurrences: []dnd.NPCOccurrence{{NPCID: "npc:test", Name: " ", Kind: "unsupported", SourceRefs: []source.SourceRef{{StartUnitID: 0, EndUnitID: -1}}}}},
	} {
		content, err := codec.EncodeCandidate(candidate)
		if err != nil || !json.Valid(content) {
			t.Fatalf("EncodeCandidate() = %s, %v", content, err)
		}
		decoded, err := codec.DecodeCandidate(content)
		if err != nil || !reflect.DeepEqual(decoded, candidate) {
			t.Fatalf("DecodeCandidate() = %#v, %v; want %#v", decoded, err, candidate)
		}
	}
}

func TestCodecCandidateDecodeOwnsValues(t *testing.T) {
	codec := New()
	input := validList()
	content, err := codec.EncodeCandidate(input)
	if err != nil {
		t.Fatal(err)
	}
	first, err := codec.DecodeCandidate(content)
	if err != nil {
		t.Fatal(err)
	}
	second, err := codec.DecodeCandidate(content)
	if err != nil {
		t.Fatal(err)
	}
	nameOffset := bytes.Index(content, []byte("Mira Thorn"))
	if nameOffset < 0 {
		t.Fatal("candidate JSON does not contain NPC name")
	}
	content[nameOffset] = 'X'
	if first.Occurrences[0].Name != "Mira Thorn" {
		t.Fatal("DecodeCandidate() retained input bytes")
	}
	first.Occurrences[0].Name = "changed"
	first.Occurrences[0].SourceRefs[0].SourceID = "changed"
	if input.Occurrences[0].Name != "Mira Thorn" || input.Occurrences[0].SourceRefs[0].SourceID != "session-alpha" {
		t.Fatal("DecodeCandidate() retained input values")
	}
	if second.Occurrences[0].Name != "Mira Thorn" || second.Occurrences[0].SourceRefs[0].SourceID != "session-alpha" {
		t.Fatal("DecodeCandidate() returned aliased values")
	}
}

func TestCodecRejectsInvalidDurableRangesWhileCandidatesPreserveThem(t *testing.T) {
	codec := New()
	for _, test := range []struct {
		name   string
		mutate func(*dnd.NPCOccurrenceList)
		want   string
	}{
		{name: "nonpositive start", mutate: func(value *dnd.NPCOccurrenceList) { value.Occurrences[0].SourceRefs[0].StartUnitID = 0 }, want: "start_unit_id"},
		{name: "nonpositive end", mutate: func(value *dnd.NPCOccurrenceList) { value.Occurrences[0].SourceRefs[0].EndUnitID = 0 }, want: "end_unit_id"},
		{name: "reversed", mutate: func(value *dnd.NPCOccurrenceList) {
			value.Occurrences[0].SourceRefs[0].StartUnitID = 2
			value.Occurrences[0].SourceRefs[0].EndUnitID = 1
		}, want: "must not exceed"},
	} {
		t.Run(test.name, func(t *testing.T) {
			candidate := validList()
			test.mutate(&candidate)
			content, err := codec.EncodeCandidate(candidate)
			if err != nil {
				t.Fatalf("EncodeCandidate() error = %v", err)
			}
			decoded, err := codec.DecodeCandidate(content)
			if err != nil || !reflect.DeepEqual(decoded, candidate) {
				t.Fatalf("DecodeCandidate() = %#v, %v; want %#v", decoded, err, candidate)
			}
			if _, err := codec.Encode(candidate); err == nil || !strings.Contains(err.Error(), test.want) {
				t.Fatalf("Encode() error = %v, want %q", err, test.want)
			}
			if _, err := codec.Decode(content); err == nil || !strings.Contains(err.Error(), test.want) {
				t.Fatalf("Decode() error = %v, want %q", err, test.want)
			}
		})
	}
}

func TestCodecStrictlyRejectsMalformedUnknownAndTrailingJSON(t *testing.T) {
	validJSON := `{"occurrences":[{"npc_id":"npc:test-mira","name":"Mira Thorn","kind":"dialogue","source_refs":[{"source_id":"session","start_unit_id":1,"end_unit_id":1}]}]}`
	for _, test := range []struct{ name, raw, want string }{
		{"malformed", `{`, "decode dnd npc occurrence list"},
		{"unknown top-level", `{"occurrences":[],"unexpected":true}`, "unknown field"},
		{"unknown occurrence field", strings.Replace(validJSON, `"kind":"dialogue"`, `"kind":"dialogue","unexpected":true`, 1), "unknown field"},
		{"unknown source reference field", strings.Replace(validJSON, `"end_unit_id":1`, `"end_unit_id":1,"unexpected":true`, 1), "unknown field"},
		{"trailing", `{"occurrences":[]} {}`, "multiple JSON values"},
	} {
		t.Run(test.name, func(t *testing.T) {
			if _, err := New().Decode([]byte(test.raw)); err == nil || !strings.Contains(err.Error(), test.want) {
				t.Fatalf("Decode() error = %v, want %q", err, test.want)
			}
		})
	}
}

func TestCodecRejectsRequiredShapeEnumAndReferenceBoundaries(t *testing.T) {
	tests := []struct {
		name  string
		value dnd.NPCOccurrenceList
		want  string
	}{
		{"nil occurrences", dnd.NPCOccurrenceList{}, "occurrences must be present"},
		{"blank NPC ID", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].NPCID = " " }), "npc_id must not be empty"},
		{"blank name", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].Name = " " }), "name must not be empty"},
		{"unsupported kind", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].Kind = "unsupported" }), "kind must be supported"},
		{"nil source refs", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].SourceRefs = nil }), "source_refs must contain"},
		{"empty source ID", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].SourceRefs[0].SourceID = " " }), "source_id must not be empty"},
		{"non-positive start", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].SourceRefs[0].StartUnitID = 0 }), "start_unit_id must be positive"},
		{"non-positive end", mutate(validList(), func(v *dnd.NPCOccurrenceList) { v.Occurrences[0].SourceRefs[0].EndUnitID = 0 }), "end_unit_id must be positive"},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			if _, err := New().Encode(test.value); err == nil || !strings.Contains(err.Error(), test.want) {
				t.Fatalf("Encode() error = %v, want %q", err, test.want)
			}
		})
	}
}

func TestCodecAcceptsEveryOccurrenceKind(t *testing.T) {
	for _, kind := range []dnd.NPCOccurrenceKind{
		dnd.NPCOccurrenceKindMentioned,
		dnd.NPCOccurrenceKindNoncombatPresence,
		dnd.NPCOccurrenceKindDialogue,
		dnd.NPCOccurrenceKindCombatAlly,
		dnd.NPCOccurrenceKindCombatOpponent,
		dnd.NPCOccurrenceKindOther,
	} {
		value := validList()
		value.Occurrences[0].Kind = kind
		if _, err := New().Encode(value); err != nil {
			t.Fatalf("Encode(%q) error = %v", kind, err)
		}
	}
}

func TestCodecSchemaAndMetadataAreDefensive(t *testing.T) {
	codec := New()
	first := codec.Schema()
	first.JSONSchema[0] = '['
	if second := codec.Schema(); !json.Valid(second.JSONSchema) || second.JSONSchema[0] == '[' {
		t.Fatal("Schema() returned shared bytes")
	}
	metadata := codec.Metadata(validList())
	metadata["other"] = true
	if next := codec.Metadata(validList()); len(next) != 1 || next["occurrence_count"] != 2 {
		t.Fatalf("Metadata() = %#v", next)
	}
}

func mutate(value dnd.NPCOccurrenceList, change func(*dnd.NPCOccurrenceList)) dnd.NPCOccurrenceList {
	change(&value)
	return value
}