package llm

import (
	"fmt"
	"strings"

	ck "gitea.maximumdirect.net/eric/ConfigKit"
	"gitea.maximumdirect.net/eric/audita/internal/core/config"
	"gitea.maximumdirect.net/eric/audita/internal/core/redaction"
	"gopkg.in/yaml.v3"
)

type selectedProfileView struct {
	ID              string  `yaml:"id"`
	Backend         string  `yaml:"backend"`
	Model           string  `yaml:"model"`
	Temperature     float64 `yaml:"temperature"`
	MaxTokens       int     `yaml:"max_tokens"`
	TopP            float64 `yaml:"top_p"`
	TimeoutSeconds  int     `yaml:"timeout_seconds"`
	ServiceTier     string  `yaml:"service_tier,omitempty"`
	ReasoningEffort string  `yaml:"reasoning_effort,omitempty"`
}

// SelectedProfilesYAML exposes selected controls without endpoint, credential,
// or arbitrary extra provider parameters.
func (r *Runtime) SelectedProfilesYAML() ([]byte, error) {
	if r == nil {
		return nil, fmt.Errorf("LLM runtime is unavailable")
	}
	view := func(role string) (selectedProfileView, error) {
		profile, ok := r.Profiles[role]
		if !ok {
			return selectedProfileView{}, fmt.Errorf("%s profile is unavailable", role)
		}
		target := profile.EffectiveModelParams
		return selectedProfileView{ID: profile.ProfileID, Backend: target.BackendID, Model: target.Model,
			Temperature: target.Temperature, MaxTokens: target.MaxTokens, TopP: target.TopP,
			TimeoutSeconds: target.TimeoutSeconds, ServiceTier: target.ServiceTier, ReasoningEffort: target.ReasoningEffort}, nil
	}
	proposal, err := view("proposal")
	if err != nil {
		return nil, err
	}
	validation, err := view("validation")
	if err != nil {
		return nil, err
	}
	raw, err := yaml.Marshal(struct {
		Proposal   selectedProfileView `yaml:"proposal"`
		Validation selectedProfileView `yaml:"validation"`
	}{proposal, validation})
	if err != nil {
		return nil, err
	}
	return redaction.New(ConfiguredSecrets(&r.Config)).YAML(raw)
}

type derivationView struct {
	Operation    ck.ChangeKind `yaml:"operation"`
	Reason       string        `yaml:"reason"`
	Dependencies []string      `yaml:"dependencies,omitempty"`
}
type inheritanceStepView struct {
	From      string `yaml:"from"`
	To        string `yaml:"to"`
	Reference string `yaml:"reference"`
}
type explanationView struct {
	Path        string                `yaml:"path"`
	Source      string                `yaml:"source"`
	Layer       ck.Layer              `yaml:"layer"`
	Derivations []derivationView      `yaml:"derivations,omitempty"`
	Inheritance []inheritanceStepView `yaml:"inheritance,omitempty"`
}

// ExplanationYAML reports only origins and recorded resolution operations.
// It intentionally excludes effective and historical values, including secrets.
func ExplanationYAML(result *ck.Result[config.Config]) ([]byte, error) {
	if result == nil {
		return nil, fmt.Errorf("configuration result is unavailable")
	}
	metadata := result.Metadata()
	sources := make(map[string]string)
	for _, source := range result.Sources() {
		sources[source.ID] = source.Label
	}
	records := make([]explanationView, 0)
	paths := metadata.HistoricalPaths()
	for i, path := range paths {
		if path.String() == "" {
			continue
		}
		if i+1 < len(paths) && strings.HasPrefix(paths[i+1].String(), path.String()+"/") {
			continue
		}
		info, ok := metadata.Lookup(path)
		if !ok {
			continue
		}
		record := explanationView{Path: path.String(), Layer: info.Origin.Layer, Source: string(info.Origin.Layer)}
		for _, step := range info.Origin.Inheritance {
			record.Inheritance = append(record.Inheritance, inheritanceStepView{
				From: step.From.String(), To: step.To.String(), Reference: step.Reference.String(),
			})
		}
		if len(info.Origin.Locations) > 0 {
			if label := sources[info.Origin.Locations[0].SourceID]; label != "" {
				record.Source = label
			}
		}
		for _, change := range metadata.History(path) {
			if change.Origin.Layer != ck.LayerResolution {
				continue
			}
			for _, reason := range change.Reasons {
				derivation := derivationView{Operation: change.Origin.Operation, Reason: reason}
				for _, dependency := range change.Dependencies {
					derivation.Dependencies = append(derivation.Dependencies, dependency.String())
				}
				record.Derivations = append(record.Derivations, derivation)
			}
		}
		records = append(records, record)
	}
	return yaml.Marshal(records)
}