package pipeline

import (
	"fmt"
	"reflect"
	"strings"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)

type LegacyRawNormalizerConstructor func() (contracts.LegacyRawNormalizer, error)
type LegacyRawNormalizerBuilder func(BuildRequest) (contracts.LegacyRawNormalizer, error)

type NormalizerRegistry struct {
	legacyBuilders   map[string]LegacyRawNormalizerBuilder
	legacyValidators map[string]OptionValidator
	legacySpecs      map[string]ModuleSpec
	typedEntries     map[artifactVariantKey]typedNormalizerEntry
}

type typedNormalizerEntry struct {
	spec            ModuleSpec
	valueType       reflect.Type
	validateOptions OptionValidator
	builder         func(BuildRequest) (any, error)
}

func NewNormalizerRegistry() *NormalizerRegistry {
	return &NormalizerRegistry{
		legacyBuilders:   make(map[string]LegacyRawNormalizerBuilder),
		legacyValidators: make(map[string]OptionValidator),
		legacySpecs:      make(map[string]ModuleSpec),
		typedEntries:     make(map[artifactVariantKey]typedNormalizerEntry),
	}
}

func (r *NormalizerRegistry) RegisterLegacyRaw(key string, constructor LegacyRawNormalizerConstructor) error {
	return r.RegisterLegacyRawWithSpec(defaultModuleSpec(key, StageNormalize), constructor)
}

func (r *NormalizerRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawNormalizerConstructor) error {
	if constructor == nil {
		return fmt.Errorf("normalizer constructor for %q must not be nil", strings.TrimSpace(spec.Key))
	}
	return r.RegisterLegacyRawBuilderWithSpec(spec, allowLegacyOptions, func(BuildRequest) (contracts.LegacyRawNormalizer, error) {
		return constructor()
	})
}

func (r *NormalizerRegistry) RegisterLegacyRawBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder LegacyRawNormalizerBuilder) error {
	if r == nil {
		return fmt.Errorf("normalizer registry must not be nil")
	}
	normalizedSpec := normalizeModuleSpec(spec)
	if err := validateModuleSpec("normalizer", StageNormalize, normalizedSpec); err != nil {
		return err
	}
	if normalizedSpec.ArtifactKind != "" {
		return fmt.Errorf("legacy raw normalizer %q must not declare an artifact kind", normalizedSpec.Key)
	}
	if validateOptions == nil {
		return fmt.Errorf("normalizer option validator for %q must not be nil", normalizedSpec.Key)
	}
	if builder == nil {
		return fmt.Errorf("normalizer builder for %q must not be nil", normalizedSpec.Key)
	}
	if _, ok := r.legacyBuilders[normalizedSpec.Key]; ok {
		return fmt.Errorf("legacy raw normalizer %q is already registered", normalizedSpec.Key)
	}
	if r.legacyBuilders == nil {
		r.legacyBuilders = make(map[string]LegacyRawNormalizerBuilder)
	}
	if r.legacyValidators == nil {
		r.legacyValidators = make(map[string]OptionValidator)
	}
	if r.legacySpecs == nil {
		r.legacySpecs = make(map[string]ModuleSpec)
	}
	r.legacyBuilders[normalizedSpec.Key] = builder
	r.legacyValidators[normalizedSpec.Key] = validateOptions
	r.legacySpecs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
	return nil
}

func RegisterNormalizer[T any](registry *NormalizerRegistry, spec ModuleSpec, constructor func() (contracts.Normalizer[T], error)) error {
	if constructor == nil {
		return fmt.Errorf("normalizer constructor for %q must not be nil", strings.TrimSpace(spec.Key))
	}
	return RegisterNormalizerBuilder(registry, spec, allowLegacyOptions, func(BuildRequest) (contracts.Normalizer[T], error) {
		return constructor()
	})
}

func RegisterNormalizerBuilder[T any](registry *NormalizerRegistry, spec ModuleSpec, validateOptions OptionValidator, builder func(BuildRequest) (contracts.Normalizer[T], error)) error {
	if registry == nil {
		return fmt.Errorf("normalizer registry must not be nil")
	}
	normalizedSpec := normalizeModuleSpec(spec)
	if err := validateModuleSpec("normalizer", StageNormalize, normalizedSpec); err != nil {
		return err
	}
	if normalizedSpec.ArtifactKind == "" {
		return fmt.Errorf("typed normalizer %q artifact kind must not be empty", normalizedSpec.Key)
	}
	if validateOptions == nil {
		return fmt.Errorf("normalizer option validator for %q must not be nil", normalizedSpec.Key)
	}
	if builder == nil {
		return fmt.Errorf("normalizer builder for %q must not be nil", normalizedSpec.Key)
	}
	key := artifactVariantKey{module: normalizedSpec.Key, kind: normalizedSpec.ArtifactKind}
	if _, ok := registry.typedEntries[key]; ok {
		return fmt.Errorf("normalizer %q variant for artifact kind %q is already registered", key.module, key.kind)
	}
	if registry.typedEntries == nil {
		registry.typedEntries = make(map[artifactVariantKey]typedNormalizerEntry)
	}
	registry.typedEntries[key] = typedNormalizerEntry{
		spec:            cloneModuleSpec(normalizedSpec),
		valueType:       reflect.TypeFor[T](),
		validateOptions: validateOptions,
		builder: func(request BuildRequest) (any, error) {
			return builder(cloneBuildRequest(request))
		},
	}
	return nil
}

func (r *NormalizerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawNormalizer, error) {
	return r.BuildLegacyRawWithRequest(key, BuildRequest{})
}

func (r *NormalizerRegistry) BuildLegacyRawWithRequest(key string, request BuildRequest) (contracts.LegacyRawNormalizer, error) {
	if r == nil {
		return nil, fmt.Errorf("normalizer registry must not be nil")
	}
	normalizedKey := strings.TrimSpace(key)
	if normalizedKey == "" {
		return nil, fmt.Errorf("normalizer key must not be empty")
	}
	builder, ok := r.legacyBuilders[normalizedKey]
	if !ok {
		return nil, fmt.Errorf("legacy raw normalizer %q is not registered", normalizedKey)
	}
	normalizer, err := builder(cloneBuildRequest(request))
	if err != nil {
		return nil, fmt.Errorf("build normalizer %q: %w", normalizedKey, err)
	}
	if normalizer == nil {
		return nil, fmt.Errorf("normalizer %q constructor returned nil", normalizedKey)
	}
	if normalizer.Key() != normalizedKey {
		return nil, fmt.Errorf("normalizer %q returned key %q", normalizedKey, normalizer.Key())
	}
	return normalizer, nil
}

func (r *NormalizerRegistry) validateOptions(key string, kind contracts.ArtifactKind, options map[string]any) error {
	if r == nil {
		return fmt.Errorf("normalizer registry must not be nil")
	}
	normalizedKey := strings.TrimSpace(key)
	if kind != "" {
		entry, ok := r.typedEntry(normalizedKey, kind)
		if !ok {
			return fmt.Errorf("normalizer %q variant for artifact kind %q is not registered", normalizedKey, kind)
		}
		return validateRegisteredOptions(entry.validateOptions, options)
	}
	validator, ok := r.legacyValidators[normalizedKey]
	if !ok {
		return fmt.Errorf("legacy raw normalizer %q is not registered", normalizedKey)
	}
	return validateRegisteredOptions(validator, options)
}

func (r *NormalizerRegistry) Spec(key string) (ModuleSpec, bool) {
	if r == nil {
		return ModuleSpec{}, false
	}
	spec, ok := r.legacySpecs[strings.TrimSpace(key)]
	if !ok {
		return ModuleSpec{}, false
	}
	return cloneModuleSpec(spec), true
}

func (r *NormalizerRegistry) typedEntry(key string, kind contracts.ArtifactKind) (typedNormalizerEntry, bool) {
	if r == nil {
		return typedNormalizerEntry{}, false
	}
	entry, ok := r.typedEntries[artifactVariantKey{module: strings.TrimSpace(key), kind: normalizeArtifactKind(kind)}]
	return entry, ok
}

func (r *NormalizerRegistry) registeredKinds(key string) []contracts.ArtifactKind {
	if r == nil {
		return nil
	}
	module := strings.TrimSpace(key)
	kinds := make([]contracts.ArtifactKind, 0)
	for variant := range r.typedEntries {
		if variant.module == module {
			kinds = append(kinds, variant.kind)
		}
	}
	sortArtifactKinds(kinds)
	return kinds
}

func (r *NormalizerRegistry) RegisteredKeys() []string {
	if r == nil {
		return nil
	}
	keys := make(map[string]struct{}, len(r.legacySpecs)+len(r.typedEntries))
	for key := range r.legacySpecs {
		keys[key] = struct{}{}
	}
	for key := range r.typedEntries {
		keys[key.module] = struct{}{}
	}
	return sortedRegistryKeys(keys)
}