package units

import (
	"fmt"
	"strings"
)

type Factory interface {
	System() string
	New() Converter
}

type StaticFactory struct {
	UnitSystem string
	Converter  Converter
}

func (f StaticFactory) System() string {
	return f.UnitSystem
}

func (f StaticFactory) New() Converter {
	return f.Converter
}

type Registry struct {
	factories map[string]Factory
}

func NewRegistry() *Registry {
	return &Registry{factories: map[string]Factory{}}
}

func (r *Registry) Register(factory Factory) error {
	if r == nil {
		return fmt.Errorf("register unit factory: registry is nil")
	}
	if factory == nil {
		return fmt.Errorf("register unit factory: factory is nil")
	}
	system := normalize(factory.System())
	if system == "" {
		return fmt.Errorf("register unit factory: unit system is empty")
	}
	if _, exists := r.factories[system]; exists {
		return fmt.Errorf("register unit factory: system %q already registered", system)
	}
	if factory.New() == nil {
		return fmt.Errorf("register unit factory: factory returned nil converter for %q", system)
	}
	r.factories[system] = factory
	return nil
}

func (r *Registry) Resolve(system string) (Converter, error) {
	if r == nil {
		return nil, fmt.Errorf("resolve unit converter: registry is nil")
	}
	key := normalize(system)
	factory, ok := r.factories[key]
	if !ok {
		return nil, fmt.Errorf("resolve unit converter: unsupported unit system %q", system)
	}
	converter := factory.New()
	if converter == nil {
		return nil, fmt.Errorf("resolve unit converter: factory for %q returned nil converter", key)
	}
	return converter, nil
}

func normalize(system string) string {
	return strings.ToLower(strings.TrimSpace(system))
}