package validators

import (
	"fmt"
	"strings"

	"gitea.maximumdirect.net/eric/audita/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/audita/internal/validators/confidence_threshold"
	"gitea.maximumdirect.net/eric/audita/internal/validators/editorial_review"
	"gitea.maximumdirect.net/eric/audita/internal/validators/meaning_reversal_review"
	validatormetadata "gitea.maximumdirect.net/eric/audita/internal/validators/metadata"
	"gitea.maximumdirect.net/eric/audita/internal/validators/no_effect"
	"gitea.maximumdirect.net/eric/audita/internal/validators/non_empty_corrected_text"
	"gitea.maximumdirect.net/eric/audita/internal/validators/original_text_presence"
	"gitea.maximumdirect.net/eric/audita/internal/validators/proposal_shape"
	"gitea.maximumdirect.net/eric/audita/internal/validators/protected_terms"
	"gitea.maximumdirect.net/eric/audita/internal/validators/spoken_form_plausibility"
)

const (
	KeyProposalShape         = validatormetadata.KeyProposalShape
	KeyConfidenceThreshold   = validatormetadata.KeyConfidenceThreshold
	KeyOriginalTextPresence  = validatormetadata.KeyOriginalTextPresence
	KeyNonEmptyCorrectedText = validatormetadata.KeyNonEmptyCorrectedText
	KeyNoEffect              = validatormetadata.KeyNoEffect
	KeyProtectedTerms        = validatormetadata.KeyProtectedTerms

	KeySpokenFormPlausibility = validatormetadata.KeySpokenFormPlausibility
	KeyMeaningReversalReview  = validatormetadata.KeyMeaningReversalReview
	KeyEditorialReview        = validatormetadata.KeyEditorialReview
)

type BuiltInValidatorDefinition struct {
	Key   string
	Build func() (contracts.Validator, error)
}

type Registry struct {
	definitions map[string]BuiltInValidatorDefinition
}

func NewBuiltInRegistry() *Registry {
	defs := []BuiltInValidatorDefinition{
		{Key: KeyProposalShape, Build: proposal_shape.New},
		{Key: KeyConfidenceThreshold, Build: confidence_threshold.New},
		{Key: KeyOriginalTextPresence, Build: original_text_presence.New},
		{Key: KeyNonEmptyCorrectedText, Build: non_empty_corrected_text.New},
		{Key: KeyNoEffect, Build: no_effect.New},
		{Key: KeyProtectedTerms, Build: protected_terms.New},
		{Key: KeySpokenFormPlausibility, Build: spoken_form_plausibility.New},
		{Key: KeyMeaningReversalReview, Build: meaning_reversal_review.New},
		{Key: KeyEditorialReview, Build: editorial_review.New},
	}

	m := make(map[string]BuiltInValidatorDefinition, len(defs))
	for _, def := range defs {
		m[def.Key] = def
	}
	return &Registry{definitions: m}
}

func (r *Registry) Lookup(key string) (BuiltInValidatorDefinition, bool) {
	if r == nil {
		return BuiltInValidatorDefinition{}, false
	}
	def, ok := r.definitions[strings.TrimSpace(key)]
	return def, ok
}

func (r *Registry) MustBuild(key string) (contracts.Validator, error) {
	if r == nil {
		return nil, fmt.Errorf("validator registry is nil")
	}
	def, ok := r.Lookup(key)
	if !ok {
		return nil, fmt.Errorf("unknown validator key %q", key)
	}
	v, err := def.Build()
	if err != nil {
		return nil, fmt.Errorf("build validator %q: %w", key, err)
	}
	if v == nil {
		return nil, fmt.Errorf("build validator %q: returned nil validator", key)
	}
	if v.Name() != def.Key {
		return nil, fmt.Errorf("validator key/name mismatch for %q: got %q", key, v.Name())
	}
	return v, nil
}

func (r *Registry) RegisteredKeys() []string {
	if r == nil {
		return nil
	}
	keys := make([]string, 0, len(r.definitions))
	for k := range r.definitions {
		keys = append(keys, k)
	}
	return keys
}