package shape

import (
	"context"
	"fmt"
	"strings"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
)

const (
	Key        = "extract/dnd/spells/shape"
	ReasonCode = "invalid_spell_shape"
	policy     = "dnd.spells.validator.shape.v2"
)

type Options struct{}
type Validator struct{}

var _ contracts.TypedValidator[dnd.SpellList] = (*Validator)(nil)
var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)

func New(Options) *Validator      { return &Validator{} }
func (v *Validator) Name() string { return Key }
func (v *Validator) ExecutionClass() contracts.ExecutionClass {
	return contracts.ExecutionClassDeterministic
}
func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
	return []pipeline.CheckpointFingerprint{{Name: "policy", Value: policy}}
}
func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.SpellList]) (contracts.ValidationResult, error) {
	assessment := assess(req.Value)
	if len(assessment.issues) != 0 {
		return rejection(assessment.message(), assessment.corrections.Guidance("Correct every rejected spell cast and return the complete replacement list")), nil
	}
	return contracts.ValidationResult{Approved: true}, nil
}

func Validate(value dnd.SpellList) error {
	assessment := assess(value)
	if len(assessment.issues) == 0 {
		return nil
	}
	return fmt.Errorf("%s", assessment.message())
}

type validationAssessment struct {
	issues      []string
	corrections diagnostics.Corrections
}

func assess(value dnd.SpellList) validationAssessment {
	var assessment validationAssessment
	if value.SpellCasts == nil {
		assessment.issues = append(assessment.issues, "spell_casts must be present")
		assessment.corrections.Add("list", "Return a `spell_casts` array; use an empty array when the transcript establishes no spell casts.", "")
		return assessment
	}
	for index, spell := range value.SpellCasts {
		context := spellContext(spell)
		if strings.TrimSpace(spell.Caster) == "" {
			assessment.issues = append(assessment.issues, fmt.Sprintf("spell_casts[%d].caster must not be empty", index))
			assessment.corrections.Add("caster", "Provide the contextual caster name for every spell cast.", context)
		}
		if strings.TrimSpace(spell.Spell) == "" {
			assessment.issues = append(assessment.issues, fmt.Sprintf("spell_casts[%d].spell must not be empty", index))
			assessment.corrections.Add("spell", "Provide the transcript-supported spell name for every spell cast.", context)
		}
		if len(spell.SourceRefs) == 0 {
			assessment.issues = append(assessment.issues, fmt.Sprintf("spell_casts[%d].source_refs must not be empty", index))
			assessment.corrections.Add("source-refs", "Provide at least one transcript source range that directly supports every spell cast.", context)
		}
	}
	return assessment
}

func (assessment validationAssessment) message() string {
	return diagnostics.Aggregate("invalid spell shape", assessment.issues)
}

func spellContext(spell dnd.SpellCast) string {
	name := strings.TrimSpace(spell.Spell)
	if name == "" {
		name = "blank spell name"
	} else {
		name = "spell " + diagnostics.Quote(name)
	}
	caster := strings.TrimSpace(spell.Caster)
	if caster == "" {
		caster = "blank caster name"
	} else {
		caster = "caster " + diagnostics.Quote(caster)
	}
	return "Affected cast: " + name + " with " + caster + " " + diagnostics.SourceRange(spell.SourceRefs) + "."
}

func Spec() pipeline.ValidatorSpec {
	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
}
func Register(registry *pipeline.ValidatorRegistry) error {
	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.SpellListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.SpellList], error) {
		options, err := DecodeOptions(request.Options)
		if err != nil {
			return nil, err
		}
		return New(options), nil
	})
}
func DecodeOptions(options map[string]any) (Options, error) {
	if err := pipeline.RejectUnknownOptions(options); err != nil {
		return Options{}, err
	}
	return Options{}, nil
}
func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }
func rejection(message, guidance string) contracts.ValidationResult {
	return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCode, Message: message, CorrectionGuidance: guidance}
}