// Package consumers contains small, maintained application shapes that exercise
// ConfigKit without making consumer domain policy part of the library API.
package consumers

import (
	"math"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	configkit "gitea.maximumdirect.net/eric/ConfigKit"
)

// Artifact is a Narratio-shaped generated output declaration.
type Artifact struct {
	Output  string        `yaml:"output"`
	Timeout time.Duration `yaml:"timeout"`
}

// NarratioConfig demonstrates application defaults, partial imports, and
// application-owned model-profile and artifact semantics.
type NarratioConfig struct {
	PollInterval time.Duration       `yaml:"poll_interval"`
	Timeout      time.Duration       `yaml:"timeout"`
	ModelProfile string              `yaml:"model_profile"`
	Artifacts    map[string]Artifact `yaml:"artifacts"`
}

// LoadNarratio loads the maintained import fixture with Narratio-shaped rules.
func LoadNarratio(path string) (*configkit.Result[NarratioConfig], error) {
	return LoadNarratioOverlay(path, "")
}

// LoadNarratioOverlay selects a ConfigKit configuration overlay independently
// from the application's ModelProfile field.
func LoadNarratioOverlay(path, overlay string) (*configkit.Result[NarratioConfig], error) {
	return configkit.Load(configkit.File(path), configkit.Options[NarratioConfig]{
		Imports: true, Overlay: overlay,
		Definition: configkit.Definition[NarratioConfig]{
			Defaults: func() NarratioConfig { return NarratioConfig{PollInterval: time.Minute} },
			Resolve:  resolveNarratio,
			Validate: validateNarratio,
		},
	})
}

func resolveNarratio(configuration *NarratioConfig, resolution *configkit.Resolution) error {
	configkit.Default(resolution, configkit.Keys("timeout"), &configuration.Timeout,
		configuration.PollInterval/10, "derived from poll interval", configkit.Keys("poll_interval"))
	for name, artifact := range configuration.Artifacts {
		path := configkit.Keys("artifacts", name)
		configkit.Default(resolution, path.Key("timeout"), &artifact.Timeout,
			configuration.Timeout, "inherited pipeline timeout", configkit.Keys("timeout"))
		configkit.Normalize(resolution, path.Key("output"), &artifact.Output,
			strings.TrimSpace(artifact.Output), "trimmed artifact output")
		configuration.Artifacts[name] = artifact
	}
	return nil
}

func validateNarratio(configuration *NarratioConfig, validation *configkit.Validation) {
	if configuration.PollInterval <= 0 {
		validation.Error(configkit.Keys("poll_interval"), "must be positive")
	}
	if configuration.Timeout <= 0 {
		validation.Error(configkit.Keys("timeout"), "must be positive")
	}
	for name, artifact := range configuration.Artifacts {
		path := configkit.Keys("artifacts", name)
		if artifact.Output == "" {
			validation.Error(path.Key("output"), "must be nonempty")
		}
		if artifact.Timeout <= 0 {
			validation.Error(path.Key("timeout"), "must be positive")
		}
	}
}

// ObjectBinding is a Notarius-shaped canonical object binding. Options remain
// dynamic because the application catalog selects their schema at runtime.
type ObjectBinding struct {
	Object  string         `yaml:"object"`
	Options map[string]any `yaml:"options"`
}

// NotariusConfig demonstrates string-backed versions and dynamic catalog options.
type NotariusConfig struct {
	Version  string          `yaml:"version"`
	Bindings []ObjectBinding `yaml:"bindings"`
}

// LoadNotarius loads a Notarius-shaped configuration.
func LoadNotarius(path string) (*configkit.Result[NotariusConfig], error) {
	return configkit.Load(configkit.File(path), configkit.Options[NotariusConfig]{
		Definition: configkit.Definition[NotariusConfig]{
			Version:  &configkit.VersionRule{Path: configkit.Keys("version"), Check: requireVersion("4")},
			Validate: validateNotarius,
		},
	})
}

func requireVersion(expected string) func(configkit.Version, *configkit.Validation) error {
	return func(version configkit.Version, validation *configkit.Validation) error {
		if !version.Present || version.Null || version.Text != expected {
			validation.Error(configkit.Keys("version"), "unsupported configuration version")
		}
		return nil
	}
}

func validateNotarius(configuration *NotariusConfig, validation *configkit.Validation) {
	for index, binding := range configuration.Bindings {
		path := configkit.Keys("bindings").Index(index)
		if binding.Object != "summary" && binding.Object != "registry" {
			validation.Error(path.Key("object"), "unsupported object binding")
		}
		for key, value := range binding.Options {
			optionPath := path.Key("options").Key(key)
			switch key {
			case "window_units":
				units, ok := value.(int64)
				if !ok || units < 1 {
					validation.Error(optionPath, "must be a positive integer")
				}
			case "format":
				if _, ok := value.(string); !ok {
					validation.Error(optionPath, "must be a string")
				}
			default:
				validation.Error(optionPath, "unsupported object option")
			}
		}
	}
}

// NotariusWindow converts ConfigKit's portable dynamic integer only at the
// application runtime boundary.
func NotariusWindow(configuration NotariusConfig, binding int) (int, bool) {
	if binding < 0 || binding >= len(configuration.Bindings) {
		return 0, false
	}
	value, ok := configuration.Bindings[binding].Options["window_units"].(int64)
	if !ok || value < 1 || (strconv.IntSize == 32 && value > math.MaxInt32) {
		return 0, false
	}
	return int(value), true
}

// NotariusPathConfig demonstrates application-owned interpretation of a
// path-valued configuration field. ConfigKit supplies provenance; this example
// selects its own relative-path bases.
type NotariusPathConfig struct {
	Reference string `yaml:"reference"`
	Sensitive string `yaml:"sensitive"`
}

// LoadNotariusPaths loads the path-bearing Notarius-shaped example. InvocationDir
// is the application-supplied base for relative CLI overrides; it is never read
// from the process working directory.
func LoadNotariusPaths(path, invocationDir string, overrides ...configkit.Override) (*configkit.Result[NotariusPathConfig], error) {
	return configkit.Load(configkit.File(path), configkit.Options[NotariusPathConfig]{
		Imports: true, Overrides: overrides,
		Definition: configkit.Definition[NotariusPathConfig]{
			Defaults: func() NotariusPathConfig { return NotariusPathConfig{Reference: "defaults/reference.txt"} },
			Resolve: func(configuration *NotariusPathConfig, resolution *configkit.Resolution) error {
				resolveNotariusReference(configuration, resolution, invocationDir)
				return nil
			},
			Secret: func(path configkit.Path) bool { return path.String() == "/sensitive" },
		},
	})
}

func resolveNotariusReference(configuration *NotariusPathConfig, resolution *configkit.Resolution, invocationDir string) {
	path := configkit.Keys("reference")
	if configuration.Reference == "" || filepath.IsAbs(configuration.Reference) {
		return
	}
	info, found := resolution.InputInfo(path)
	if !found {
		resolution.Warning(path, "relative reference has no entry provenance")
		return
	}

	base := ""
	if info.Origin.Layer == configkit.LayerCLI {
		base = invocationDir
		if base == "" {
			resolution.Warning(path, "relative CLI reference has no invocation directory")
			return
		}
	} else {
		sourceID := "source-1" // ConfigKit's primary-source identity convention.
		if info.Origin.Layer != configkit.LayerDefault {
			if len(info.Origin.Locations) != 1 {
				resolution.Warning(path, "relative reference has no unambiguous declaring source")
				return
			}
			sourceID = info.Origin.Locations[0].SourceID
		}
		source, exists := resolution.Source(sourceID)
		if !exists || source.Path == "" {
			resolution.Warning(path, "relative reference has no declaring file")
			return
		}
		base = filepath.Dir(source.Path)
	}
	configkit.Normalize(resolution, path, &configuration.Reference,
		filepath.Join(base, configuration.Reference), "resolved relative reference from entry source")
}

// ModuleOptions is a WeatherReporter-shaped union of known module option fields.
type ModuleOptions struct {
	WindowUnits *int     `yaml:"window_units"`
	Sections    []string `yaml:"sections"`
}

// ModuleSpec uses the canonical object form instead of a string shorthand.
type ModuleSpec struct {
	Module  string        `yaml:"module"`
	Options ModuleOptions `yaml:"options"`
}

// ReportConfig keeps report-specific lists application-owned.
type ReportConfig struct {
	Modules       []ModuleSpec `yaml:"modules"`
	PathTemplates []string     `yaml:"path_templates"`
}

// WeatherConfig demonstrates simple defaults, reports, module options, and an
// optional typed secret reference.
type WeatherConfig struct {
	Units   string                  `yaml:"units"`
	Reports map[string]ReportConfig `yaml:"reports"`
	Token   *configkit.Secret       `yaml:"token"`
}

// LoadWeather loads a WeatherReporter-shaped source and explicit CLI records.
func LoadWeather(source configkit.Source, overrides ...configkit.Override) (*configkit.Result[WeatherConfig], error) {
	return configkit.Load(source, configkit.Options[WeatherConfig]{
		Overrides: overrides,
		Definition: weatherDefinition(func() WeatherConfig {
			return WeatherConfig{Units: "metric"}
		}),
	})
}

// LoadConstructedWeather runs the same rules over a detached constructed value.
func LoadConstructedWeather(configuration WeatherConfig) (*configkit.Result[WeatherConfig], error) {
	return configkit.Load(configkit.NoSource(), configkit.Options[WeatherConfig]{
		Definition: weatherDefinition(func() WeatherConfig { return configuration }),
	})
}

func weatherDefinition(defaults func() WeatherConfig) configkit.Definition[WeatherConfig] {
	return configkit.Definition[WeatherConfig]{
		Defaults: defaults,
		Resolve: func(configuration *WeatherConfig, resolution *configkit.Resolution) error {
			for reportName, report := range configuration.Reports {
				var modules []ModuleSpec
				if report.Modules != nil {
					modules = append(make([]ModuleSpec, 0, len(report.Modules)), report.Modules...)
				}
				for index, module := range modules {
					if module.Options.Sections != nil {
						sections := append([]string(nil), module.Options.Sections...)
						for position := range sections {
							sections[position] = strings.TrimSpace(sections[position])
						}
						module.Options.Sections = sections
					}
					modules[index] = module
				}
				configkit.Normalize(resolution, configkit.Keys("reports", reportName, "modules"),
					&report.Modules, modules, "normalized module options")
				configuration.Reports[reportName] = report
			}
			return nil
		},
		Validate: validateWeather,
	}
}

func validateWeather(configuration *WeatherConfig, validation *configkit.Validation) {
	if configuration.Units != "metric" && configuration.Units != "us" {
		validation.Error(configkit.Keys("units"), "must be metric or us")
	}
	for reportName, report := range configuration.Reports {
		path := configkit.Keys("reports", reportName)
		if report.Modules != nil && len(report.Modules) == 0 {
			validation.Error(path.Key("modules"), "must contain at least one module")
		}
		if report.PathTemplates != nil && len(report.PathTemplates) == 0 {
			validation.Error(path.Key("path_templates"), "must contain at least one template")
		}
		for index, module := range report.Modules {
			modulePath := path.Key("modules").Index(index)
			switch module.Module {
			case "chunker":
				if module.Options.WindowUnits == nil || *module.Options.WindowUnits < 1 {
					validation.Error(modulePath.Key("options").Key("window_units"), "must be a positive integer")
				}
				if module.Options.Sections != nil {
					validation.Error(modulePath.Key("options").Key("sections"), "not supported by this module")
				}
			case "discussion":
				if module.Options.WindowUnits != nil {
					validation.Error(modulePath.Key("options").Key("window_units"), "not supported by this module")
				}
				if len(module.Options.Sections) == 0 {
					validation.Error(modulePath.Key("options").Key("sections"), "must contain at least one section")
				}
			default:
				validation.Error(modulePath.Key("module"), "unsupported module")
			}
		}
	}
}

// SpeakerRule and SpeakerRules preserve declaration order for application matching.
type SpeakerRule struct {
	Prefix string `yaml:"prefix"`
	Name   string `yaml:"name"`
}

type SpeakerRules struct {
	Rules []SpeakerRule `yaml:"rules"`
}

// AutocorrectRule and AutocorrectRules preserve replacement order.
type AutocorrectRule struct {
	Find    string `yaml:"find"`
	Replace string `yaml:"replace"`
}

type AutocorrectRules struct {
	Rules []AutocorrectRule `yaml:"rules"`
}

// LoadSpeakerRules loads one independent Seriatim-shaped rule file.
func LoadSpeakerRules(path string) (*configkit.Result[SpeakerRules], error) {
	return configkit.Load(configkit.File(path), configkit.Options[SpeakerRules]{
		Definition: configkit.Definition[SpeakerRules]{Validate: validateSpeakerRules},
	})
}

// LoadAutocorrectRules loads another independent ordered rule file.
func LoadAutocorrectRules(path string) (*configkit.Result[AutocorrectRules], error) {
	return configkit.Load(configkit.File(path), configkit.Options[AutocorrectRules]{
		Definition: configkit.Definition[AutocorrectRules]{Validate: validateAutocorrectRules},
	})
}

func validateSpeakerRules(configuration *SpeakerRules, validation *configkit.Validation) {
	seen := make(map[string]int)
	for index, rule := range configuration.Rules {
		path := configkit.Keys("rules").Index(index)
		if rule.Prefix == "" {
			validation.Error(path.Key("prefix"), "must be nonempty")
		}
		if previous, ok := seen[rule.Prefix]; ok {
			validation.Error(path.Key("prefix"), "prefix must be unique",
				configkit.Keys("rules").Index(previous).Key("prefix"))
		}
		seen[rule.Prefix] = index
	}
}

func validateAutocorrectRules(configuration *AutocorrectRules, validation *configkit.Validation) {
	for index, rule := range configuration.Rules {
		path := configkit.Keys("rules").Index(index)
		if rule.Find == "" {
			validation.Error(path.Key("find"), "must be nonempty")
		}
	}
}

// SpeakerName is application runtime matching, not configuration infrastructure.
func SpeakerName(rules SpeakerRules, input string) (string, bool) {
	for _, rule := range rules.Rules {
		if strings.HasPrefix(input, rule.Prefix) {
			return rule.Name, true
		}
	}
	return "", false
}

// ApplyAutocorrect is application runtime replacement in declared order.
func ApplyAutocorrect(rules AutocorrectRules, input string) string {
	for _, rule := range rules.Rules {
		input = strings.ReplaceAll(input, rule.Find, rule.Replace)
	}
	return input
}