// Package locationregistry normalizes merged D&D location-registry candidates conservatively.
package locationregistry

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"

	"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/framework/semanticreconcile"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/identity"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
)

const (
	Key                 = "dnd/location-registry"
	PromptID            = "dnd.location_registry.normalize"
	PromptVersion       = "v1"
	normalizationPolicy = "dnd.location_registry.normalize.v4"
	NormalizationPolicy = normalizationPolicy

	ReasonCodeLocationFieldsNormalized                = "location_fields_normalized"
	ReasonCodeLocationIDRecomputed                    = "location_id_recomputed"
	ReasonCodeSourceReferencesNormalized              = "source_references_normalized"
	ReasonCodeDuplicateLocationCollapsed              = "duplicate_location_collapsed"
	ReasonCodeLocationSemanticProposalInvalid         = "location_semantic_proposal_invalid"
	ReasonCodeLocationSemanticReconciliationExhausted = "location_semantic_reconciliation_exhausted"
)

var requiredCapabilities = []string{"merged"}
var providedCapabilities = []string{"normalized"}

var _ contracts.Normalizer[dnd.LocationRegistry] = (*Normalizer)(nil)
var _ contracts.ManifestMetadataProvider = (*Normalizer)(nil)
var _ pipeline.CheckpointFingerprintProvider = (*Normalizer)(nil)

type Options struct{}

type Normalizer struct {
	engine *semanticreconcile.Engine
}

func New(llmClient contracts.StructuredLLMClient, _ Options) (*Normalizer, error) {
	if llmClient == nil {
		return nil, normalizerErrorf("LLM client must not be nil")
	}
	promptSHA, err := promptAssetMetadata()
	if err != nil {
		return nil, normalizerErrorf("load prompt metadata: %w", err)
	}
	engine, err := semanticreconcile.NewEngine(llmClient, semanticreconcile.PromptSpec{
		ID: PromptID, Version: PromptVersion, SHA256: promptSHA,
	}, semanticreconcile.DefaultLimits())
	if err != nil {
		return nil, normalizerErrorf("construct semantic reconciliation engine: %w", err)
	}
	return &Normalizer{engine: engine}, nil
}

func (n *Normalizer) Key() string                               { return Key }
func (n *Normalizer) ReferenceSlots() []contracts.ReferenceSlot { return nil }

func (n *Normalizer) ManifestMetadata() map[string]any {
	if n == nil || n.engine == nil {
		return nil
	}
	metadata := n.engine.ManifestMetadata()
	metadata["identity_policy"] = identity.Policy
	metadata["normalization_policy"] = normalizationPolicy
	return metadata
}

func (n *Normalizer) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
	if n == nil || n.engine == nil {
		return nil
	}
	fingerprints := n.engine.CheckpointFingerprints()
	return append(fingerprints,
		pipeline.CheckpointFingerprint{Name: "identity_policy", Value: identity.Policy},
		pipeline.CheckpointFingerprint{Name: "normalization_policy", Value: normalizationPolicy},
	)
}

func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalizeRequest[dnd.LocationRegistry]) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	if n == nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("normalizer must not be nil")
	}
	if n.engine == nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("semantic reconciliation engine must not be nil")
	}
	if ctx == nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("context must not be nil")
	}
	if err := ctx.Err(); err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("context error before normalize: %w", err)
	}
	if req.Source == nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("source document must not be nil")
	}

	order := shared.NewSourceRefOrder(req.Source)
	records, findings := preprocessRecords(req.MergeOutput.Value, order)
	deterministic := recordList(records)
	if len(records) < 2 {
		return normalizationResult(deterministic, findings, nil)
	}

	candidates, envelopes, err := reconciliationInputs(records)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("prepare semantic reconciliation inputs: %w", err)
	}
	reconciliation, err := n.engine.Reconcile(ctx, semanticreconcile.Request{
		StageName: Key, Source: req.Source, Candidates: candidates,
		ProfileID: req.LLMProfile, SessionID: req.SessionID, StructuredOutputRepairAttempts: req.StructuredOutputRepairAttempts, Correction: req.Correction,
	})
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("reconcile semantic duplicates: %w", err)
	}

	switch reconciliation.Disposition() {
	case semanticreconcile.SkippedInsufficientCandidates:
		return normalizationResult(deterministic, findings, nil)
	case semanticreconcile.SkippedLimitExceeded:
		return fallbackResult(deterministic, findings, semanticFallbackFinding(-1, "the candidate set exceeded the configured semantic-reconciliation limits"))
	case semanticreconcile.RetryableInvalidStructuredOutput:
		return n.invalidStructuredResult(deterministic, findings)
	case semanticreconcile.Complete, semanticreconcile.RetryableDiscardedProposalGroups:
	default:
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("unknown semantic reconciliation disposition %d", reconciliation.Disposition())
	}

	applied, semanticFindings, err := applyReconciliationPlan(reconciliation.Plan(), records, envelopes, order)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("apply semantic reconciliation plan: %w", err)
	}
	findings = append(findings, semanticFindings...)
	if reconciliation.Disposition() == semanticreconcile.Complete {
		return normalizationResult(recordList(applied), findings, reconciliation.ModelCandidate())
	}
	return retryResult(recordList(applied), findings, reconciliation)
}

func (n *Normalizer) invalidStructuredResult(value dnd.LocationRegistry, findings []diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	return retryResultWithFallback(value, findings, nil, "", "semantic proposal requires retry: invalid structured output", semanticFallbackFinding(-1, "the final model response did not satisfy the structured-output contract"))
}

func retryResult(value dnd.LocationRegistry, findings []diagnostics.Finding, reconciliation semanticreconcile.Result) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	issues := reconciliation.Issues()
	correctionDetails, err := reconciliation.CorrectionDetails()
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("build semantic correction details: %w", err)
	}
	correctionGuidance, err := reconciliation.CorrectionGuidance()
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("build semantic correction guidance: %w", err)
	}
	return retryResultWithFallback(value, findings, reconciliation.ModelCandidate(), correctionGuidance, diagnostics.Aggregate("semantic proposal requires retry", semanticreconcile.IssueDetails(issues)), semanticFallbackFinding(reconciliation.DiscardedGroupCount(), correctionDetails...))
}

func semanticFallbackFinding(discarded int, details ...string) diagnostics.Finding {
	message := "semantic reconciliation could not be completed; all affected candidates were preserved separately"
	if discarded >= 0 {
		message = fmt.Sprintf("%d proposal group(s) omitted from the final semantic proposal; all affected candidates were preserved separately", discarded)
	}
	if len(details) > 0 {
		message = diagnostics.Aggregate(message, details)
	}
	return diagnostics.Finding{Scope: "locations", ReasonCode: ReasonCodeLocationSemanticReconciliationExhausted, Message: message}
}

func normalizationResult(value dnd.LocationRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	diagnosticGroups, err := diagnostics.Collect(findings, contracts.DiagnosticDispositionObservation, contracts.DiagnosticCategoryNormalization)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect normalization diagnostics: %w", err)
	}
	return contracts.TypedNormalizeResult[dnd.LocationRegistry]{Value: value, Diagnostics: diagnosticGroups, ModelCandidate: candidate}, nil
}

func fallbackResult(value dnd.LocationRegistry, findings []diagnostics.Finding, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	result, err := normalizationResult(value, findings, nil)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, err
	}
	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
	}
	result.Diagnostics = append(result.Diagnostics, fallbackGroups...)
	return result, nil
}

func retryResultWithFallback(value dnd.LocationRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate, correctionGuidance, message string, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
	result, err := normalizationResult(value, findings, candidate)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, err
	}
	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
	if err != nil {
		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
	}
	result.Retry = &contracts.NormalizeRetry{ReasonCode: ReasonCodeLocationSemanticProposalInvalid, Message: message, CorrectionGuidance: correctionGuidance, FallbackDiagnostics: fallbackGroups}
	return result, nil
}

type normalizedRecord struct {
	location     dnd.Location
	inputIndexes []int
	earliest     int
}

func preprocessRecords(input dnd.LocationRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding) {
	if input.Locations == nil {
		return nil, nil
	}
	records := make([]normalizedRecord, len(input.Locations))
	findings := make([]diagnostics.Finding, 0)
	for index, inputLocation := range input.Locations {
		location, fieldsChanged, refsChanged := normalizeRecord(inputLocation, order)
		records[index] = normalizedRecord{location: location, inputIndexes: []int{index}, earliest: index}
		if fieldsChanged {
			findings = append(findings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeLocationFieldsNormalized, Message: fmt.Sprintf("input index %d: location name normalized for %s", index, diagnostics.Quote(inputLocation.Name))})
		}
		if refsChanged {
			findings = append(findings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputLocation.SourceRefs), len(location.SourceRefs))})
		}
		if inputLocation.ID != location.ID {
			findings = append(findings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeLocationIDRecomputed, Message: fmt.Sprintf("input index %d: location ID recomputed from %s", index, diagnostics.Quote(location.Name))})
		}
	}
	groups := exactDuplicateGroups(records)
	output := make([]normalizedRecord, 0, len(groups))
	for _, members := range groups {
		retained := cloneRecord(records[members[0]])
		for _, member := range members[1:] {
			retained.inputIndexes = append(retained.inputIndexes, records[member].inputIndexes...)
		}
		retained.inputIndexes = sortedUniqueIndexes(retained.inputIndexes)
		output = append(output, retained)
		if len(members) > 1 {
			findings = append(findings, duplicateFinding(retained.earliest, memberInputIndexes(records, members[1:])))
		}
	}
	return output, findings
}

func normalizeRecord(input dnd.Location, order shared.SourceRefOrder) (dnd.Location, bool, bool) {
	output := cloneLocation(input)
	output.Name = identity.NormalizeDisplay(input.Name)
	output.SourceRefs = order.Canonicalize(input.SourceRefs)
	output.ID = identity.DeriveID(output.Name, output.SourceRefs)
	return output, input.Name != output.Name, !reflect.DeepEqual(input.SourceRefs, output.SourceRefs)
}

func exactDuplicateGroups(records []normalizedRecord) [][]int {
	groups := make([][]int, 0, len(records))
	groupPositions := make(map[string][]int, len(records))
	for index, record := range records {
		key := exactDuplicateKey(record.location)
		comparisonName := identity.ComparisonKey(record.location.Name)
		matched := false
		for _, groupIndex := range groupPositions[key] {
			first := records[groups[groupIndex][0]]
			if identity.ComparisonKey(first.location.Name) == comparisonName && reflect.DeepEqual(first.location.SourceRefs, record.location.SourceRefs) {
				groups[groupIndex] = append(groups[groupIndex], index)
				matched = true
				break
			}
		}
		if matched {
			continue
		}
		groupPositions[key] = append(groupPositions[key], len(groups))
		groups = append(groups, []int{index})
	}
	return groups
}

type duplicateKey struct {
	ComparisonName string             `json:"comparison_name"`
	SourceRefs     []source.SourceRef `json:"source_refs"`
}

func exactDuplicateKey(location dnd.Location) string {
	encoded, err := json.Marshal(duplicateKey{
		ComparisonName: identity.ComparisonKey(location.Name),
		SourceRefs:     location.SourceRefs,
	})
	if err != nil {
		panic("encode location duplicate key")
	}
	return string(encoded)
}

func cloneLocation(input dnd.Location) dnd.Location {
	input.SourceRefs = cloneSourceRefs(input.SourceRefs)
	return input
}
func cloneRecord(input normalizedRecord) normalizedRecord {
	input.location = cloneLocation(input.location)
	input.inputIndexes = append([]int(nil), input.inputIndexes...)
	return input
}
func cloneSourceRefs(input []source.SourceRef) []source.SourceRef {
	if input == nil {
		return nil
	}
	return append([]source.SourceRef(nil), input...)
}

func sortedUniqueIndexes(indexes []int) []int {
	if len(indexes) == 0 {
		return nil
	}
	out := append([]int(nil), indexes...)
	sort.Ints(out)
	write := 1
	for _, index := range out[1:] {
		if index != out[write-1] {
			out[write] = index
			write++
		}
	}
	return out[:write]
}
func memberInputIndexes(records []normalizedRecord, members []int) []int {
	indexes := make([]int, 0, len(members))
	for _, member := range members {
		indexes = append(indexes, records[member].inputIndexes...)
	}
	return sortedUniqueIndexes(indexes)
}
func recordValues(records []normalizedRecord) []dnd.Location {
	if records == nil {
		return nil
	}
	values := make([]dnd.Location, len(records))
	for index, record := range records {
		values[index] = cloneLocation(record.location)
	}
	return values
}
func recordList(records []normalizedRecord) dnd.LocationRegistry {
	if records == nil {
		return dnd.LocationRegistry{}
	}
	return dnd.LocationRegistry{Locations: recordValues(records)}
}

func duplicateFinding(retainedIndex int, removed []int) diagnostics.Finding {
	const maxDisplayedIndices = 20
	displayed := removed
	if len(displayed) > maxDisplayedIndices {
		displayed = displayed[:maxDisplayedIndices]
	}
	indices := make([]string, len(displayed))
	for index, removedIndex := range displayed {
		indices[index] = strconv.Itoa(removedIndex)
	}
	message := fmt.Sprintf("retained input index %d; removed input indices [%s]", retainedIndex, strings.Join(indices, ", "))
	if omitted := len(removed) - len(displayed); omitted > 0 {
		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
	}
	return diagnostics.Finding{Scope: locationScope(retainedIndex), ReasonCode: ReasonCodeDuplicateLocationCollapsed, Message: message}
}
func locationScope(index int) string { return fmt.Sprintf("locations[%d]", index) }

func ModuleSpec() pipeline.ModuleSpec {
	return pipeline.ModuleSpec{Key: Key, Stage: pipeline.StageNormalize, ExecutionClass: contracts.ExecutionClassLLMBacked, CorrectionProtocol: contracts.CorrectionProtocolSingleResponseV1, Requires: append([]string(nil), requiredCapabilities...), Provides: append([]string(nil), providedCapabilities...), ArtifactKind: dnd.LocationRegistryKind}
}
func Register(registry *pipeline.NormalizerRegistry) error {
	return pipeline.RegisterNormalizerBuilder(registry, ModuleSpec(), validateOptions, func(request pipeline.BuildRequest) (contracts.Normalizer[dnd.LocationRegistry], error) {
		options, err := DecodeOptions(request.Options)
		if err != nil {
			return nil, err
		}
		return New(request.Dependencies.LLM, options)
	})
}
func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }
func DecodeOptions(options map[string]any) (Options, error) {
	if err := pipeline.RejectUnknownOptions(options); err != nil {
		return Options{}, normalizerErrorf("%w", err)
	}
	return Options{}, nil
}
func normalizerErrorf(format string, args ...any) error {
	return fmt.Errorf("dnd location registry normalizer: "+format, args...)
}
