package pipeline

import (
	"fmt"
	"strings"

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

type NormalizerConstructor func() (contracts.Normalizer, error)

type NormalizerRegistry struct {
	constructors map[string]NormalizerConstructor
	specs        map[string]ModuleSpec
}

func NewNormalizerRegistry() *NormalizerRegistry {
	return &NormalizerRegistry{
		constructors: make(map[string]NormalizerConstructor),
		specs:        make(map[string]ModuleSpec),
	}
}

func (r *NormalizerRegistry) Register(key string, constructor NormalizerConstructor) error {
	return r.RegisterWithSpec(defaultModuleSpec(key, StageNormalize), constructor)
}

func (r *NormalizerRegistry) RegisterWithSpec(spec ModuleSpec, constructor NormalizerConstructor) 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 constructor == nil {
		return fmt.Errorf("normalizer constructor for %q must not be nil", normalizedSpec.Key)
	}
	if _, ok := r.constructors[normalizedSpec.Key]; ok {
		return fmt.Errorf("normalizer %q is already registered", normalizedSpec.Key)
	}

	if r.constructors == nil {
		r.constructors = make(map[string]NormalizerConstructor)
	}
	if r.specs == nil {
		r.specs = make(map[string]ModuleSpec)
	}
	r.constructors[normalizedSpec.Key] = constructor
	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
	return nil
}

func (r *NormalizerRegistry) Build(key string) (contracts.Normalizer, 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")
	}

	constructor, ok := r.constructors[normalizedKey]
	if !ok {
		return nil, fmt.Errorf("normalizer %q is not registered", normalizedKey)
	}

	normalizer, err := constructor()
	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) Spec(key string) (ModuleSpec, bool) {
	if r == nil {
		return ModuleSpec{}, false
	}

	spec, ok := r.specs[strings.TrimSpace(key)]
	if !ok {
		return ModuleSpec{}, false
	}
	return cloneModuleSpec(spec), true
}

func (r *NormalizerRegistry) RegisteredKeys() []string {
	if r == nil {
		return nil
	}

	return sortedRegistryKeys(r.constructors)
}