package ckprompt

import (
	"fmt"
	"strconv"

	commandkit "go.maximumdirect.net/commandkit"
	promptkit "go.maximumdirect.net/promptkit"
)

// requestFlagDefinition keeps the canonical spellings, help text, and optional
// command-scoped aliases together for consumers of the standard flag sets.
type requestFlagDefinition struct {
	meta    commandkit.FlagMeta
	aliases []string
}

var requestFlags = struct {
	Endpoint         requestFlagDefinition
	Model            requestFlagDefinition
	Temperature      requestFlagDefinition
	MaxTokens        requestFlagDefinition
	TopP             requestFlagDefinition
	TimeoutSeconds   requestFlagDefinition
	ServiceTier      requestFlagDefinition
	ReasoningEffort  requestFlagDefinition
	APIKeyEnv        requestFlagDefinition
	TransientRetries requestFlagDefinition
	ExtraParams      requestFlagDefinition
	Prompt           requestFlagDefinition
	Profile          requestFlagDefinition
	Backend          requestFlagDefinition
	SessionID        requestFlagDefinition
	Var              requestFlagDefinition
	InputText        requestFlagDefinition
	InputFile        requestFlagDefinition
}{
	Endpoint:         requestFlagDefinition{commandkit.FlagMeta{Name: "llm-endpoint", Usage: "Use this endpoint."}, []string{"endpoint"}},
	Model:            requestFlagDefinition{commandkit.FlagMeta{Name: "llm-model", Usage: "Use this model."}, []string{"model"}},
	Temperature:      requestFlagDefinition{commandkit.FlagMeta{Name: "llm-temperature", Usage: "Use this temperature."}, []string{"temperature"}},
	MaxTokens:        requestFlagDefinition{commandkit.FlagMeta{Name: "llm-max-tokens", Usage: "Use this maximum token count."}, []string{"max-tokens"}},
	TopP:             requestFlagDefinition{commandkit.FlagMeta{Name: "llm-top-p", Usage: "Use this top-p value."}, []string{"top-p"}},
	TimeoutSeconds:   requestFlagDefinition{commandkit.FlagMeta{Name: "llm-timeout-seconds", Usage: "Set the request timeout in seconds."}, []string{"timeout-seconds"}},
	ServiceTier:      requestFlagDefinition{commandkit.FlagMeta{Name: "llm-service-tier", Usage: "Use this service tier."}, []string{"service-tier"}},
	ReasoningEffort:  requestFlagDefinition{commandkit.FlagMeta{Name: "llm-reasoning-effort", Usage: "Use this reasoning effort."}, []string{"reasoning-effort"}},
	APIKeyEnv:        requestFlagDefinition{commandkit.FlagMeta{Name: "llm-api-key-env", Usage: "Name the environment variable containing the API key."}, []string{"api-key-env"}},
	TransientRetries: requestFlagDefinition{commandkit.FlagMeta{Name: "llm-transient-retries", Usage: "Set the retry count for transient inference failures."}, []string{"transient-retries"}},
	ExtraParams:      requestFlagDefinition{commandkit.FlagMeta{Name: "llm-extra-params", Usage: "Supply provider parameters as a JSON object."}, []string{"extra-params"}},
	Prompt:           requestFlagDefinition{commandkit.FlagMeta{Name: "llm-prompt", Usage: "Select a prompt by ID."}, []string{"prompt"}},
	Profile:          requestFlagDefinition{commandkit.FlagMeta{Name: "llm-profile", Usage: "Select a profile by ID."}, []string{"profile"}},
	Backend:          requestFlagDefinition{commandkit.FlagMeta{Name: "llm-backend", Usage: "Select a backend by ID."}, []string{"backend"}},
	SessionID:        requestFlagDefinition{commandkit.FlagMeta{Name: "llm-session-id", Usage: "Supply the session ID."}, []string{"session-id"}},
	Var:              requestFlagDefinition{commandkit.FlagMeta{Name: "llm-var", Usage: "Supply a prompt variable as KEY=VALUE."}, []string{"var"}},
	InputText:        requestFlagDefinition{commandkit.FlagMeta{Name: "llm-input-text", Usage: "Supply text for a prompt input as NAME=TEXT."}, []string{"input-text", "llm-input", "input"}},
	InputFile:        requestFlagDefinition{commandkit.FlagMeta{Name: "llm-input-file", Usage: "Supply a file for a prompt input as NAME=PATH."}, []string{"input-file"}},
}

// ExecutionInput contains request-scoped execution controls supplied on the CLI.
// A nil override or retry count leaves the corresponding native default intact.
type ExecutionInput struct {
	Execution        *promptkit.ExecutionTargetOverride
	TransientRetries *int
}

// ExecutionFlags exposes independently selectable execution-control bindings.
type ExecutionFlags[I any] struct {
	Endpoint, Model, Temperature, MaxTokens, TopP, TimeoutSeconds          commandkit.Flag[I]
	ServiceTier, ReasoningEffort, APIKeyEnv, TransientRetries, ExtraParams commandkit.Flag[I]
}

// All returns all execution controls.
func (f ExecutionFlags[I]) All() []commandkit.Flag[I] {
	return appendRequestBindings(nil, "", nil, f.bindings()...)
}

func (f ExecutionFlags[I]) bindings() []requestBinding[I] {
	return []requestBinding[I]{
		{f.Endpoint, requestFlags.Endpoint}, {f.Model, requestFlags.Model},
		{f.Temperature, requestFlags.Temperature}, {f.MaxTokens, requestFlags.MaxTokens},
		{f.TopP, requestFlags.TopP}, {f.TimeoutSeconds, requestFlags.TimeoutSeconds},
		{f.ServiceTier, requestFlags.ServiceTier}, {f.ReasoningEffort, requestFlags.ReasoningEffort},
		{f.APIKeyEnv, requestFlags.APIKeyEnv}, {f.TransientRetries, requestFlags.TransientRetries},
		{f.ExtraParams, requestFlags.ExtraParams},
	}
}

// NewExecutionFlags binds execution controls to a field of the caller's input.
// Parsed provider parameters are copied when the binding is applied.
func NewExecutionFlags[I any](destination func(*I) *ExecutionInput) ExecutionFlags[I] {
	target := func(input *I) *promptkit.ExecutionTargetOverride {
		value := destination(input)
		if value.Execution == nil {
			value.Execution = &promptkit.ExecutionTargetOverride{}
		}
		return value.Execution
	}
	return ExecutionFlags[I]{
		Endpoint:         executionFlag(requestFlags.Endpoint.meta, parseDefinitionString, func(i *I, v string) { target(i).Endpoint = v }),
		Model:            executionFlag(requestFlags.Model.meta, parseDefinitionString, func(i *I, v string) { target(i).Model = v }),
		Temperature:      executionFlag(requestFlags.Temperature.meta, parseExecutionFloat, func(i *I, v float64) { target(i).Temperature = &v }),
		MaxTokens:        executionFlag(requestFlags.MaxTokens.meta, strconv.Atoi, func(i *I, v int) { target(i).MaxTokens = &v }),
		TopP:             executionFlag(requestFlags.TopP.meta, parseExecutionFloat, func(i *I, v float64) { target(i).TopP = &v }),
		TimeoutSeconds:   executionFlag(requestFlags.TimeoutSeconds.meta, strconv.Atoi, func(i *I, v int) { target(i).TimeoutSeconds = &v }),
		ServiceTier:      executionFlag(requestFlags.ServiceTier.meta, parseDefinitionString, func(i *I, v string) { target(i).ServiceTier = v }),
		ReasoningEffort:  executionFlag(requestFlags.ReasoningEffort.meta, parseDefinitionString, func(i *I, v string) { target(i).ReasoningEffort = &v }),
		APIKeyEnv:        executionFlag(requestFlags.APIKeyEnv.meta, parseDefinitionString, func(i *I, v string) { target(i).APIKeyEnv = v }),
		TransientRetries: executionFlag(requestFlags.TransientRetries.meta, strconv.Atoi, func(i *I, v int) { destination(i).TransientRetries = &v }),
		ExtraParams:      executionFlag(requestFlags.ExtraParams.meta, parseExtraParams, func(i *I, v map[string]any) { target(i).ExtraParams = copyProviderParams(v) }),
	}
}

func copyProviderParams(params map[string]any) map[string]any {
	if params == nil {
		return nil
	}
	result := make(map[string]any, len(params))
	for key, value := range params {
		result[key] = copyProviderValue(value)
	}
	return result
}

func copyProviderValue(value any) any {
	switch value := value.(type) {
	case map[string]any:
		return copyProviderParams(value)
	case []any:
		if value == nil {
			return []any(nil)
		}
		result := make([]any, len(value))
		for i, element := range value {
			result[i] = copyProviderValue(element)
		}
		return result
	default:
		return value
	}
}

func executionFlag[I, V any](meta commandkit.FlagMeta, parse func(string) (V, error), set func(*I, V)) commandkit.Flag[I] {
	return commandkit.ValueFlag(meta, (*V)(nil), parse, func(i *I, value commandkit.Supplied[V]) {
		if value.Set {
			set(i, value.Value)
		}
	})
}

func parseExtraParams(raw string) (map[string]any, error) {
	value, err := commandkit.ParseCLIJSON(raw)
	if err != nil {
		return nil, err
	}
	object, ok := value.(map[string]any)
	if !ok {
		return nil, fmt.Errorf("provider parameters must be a JSON object")
	}
	return object, nil
}

// ResourceInput retains whether each resource identifier was explicitly supplied.
type ResourceInput struct {
	Prompt, Profile, Backend, SessionID commandkit.Supplied[string]
}

// ResourceFlags exposes independently selectable resource and session bindings.
type ResourceFlags[I any] struct {
	Prompt, Profile, Backend, SessionID commandkit.Flag[I]
}

// All returns all resource bindings.
func (f ResourceFlags[I]) All() []commandkit.Flag[I] {
	return []commandkit.Flag[I]{f.Prompt, f.Profile, f.Backend, f.SessionID}
}

// NewResourceFlags binds resource identifiers to a field of the caller's input.
func NewResourceFlags[I any](destination func(*I) *ResourceInput) ResourceFlags[I] {
	flag := func(meta commandkit.FlagMeta, selectField func(*ResourceInput) *commandkit.Supplied[string]) commandkit.Flag[I] {
		return commandkit.ValueFlag(meta, (*string)(nil), parseDefinitionString, func(i *I, v commandkit.Supplied[string]) { *selectField(destination(i)) = v })
	}
	return ResourceFlags[I]{
		Prompt:    flag(requestFlags.Prompt.meta, func(v *ResourceInput) *commandkit.Supplied[string] { return &v.Prompt }),
		Profile:   flag(requestFlags.Profile.meta, func(v *ResourceInput) *commandkit.Supplied[string] { return &v.Profile }),
		Backend:   flag(requestFlags.Backend.meta, func(v *ResourceInput) *commandkit.Supplied[string] { return &v.Backend }),
		SessionID: flag(requestFlags.SessionID.meta, func(v *ResourceInput) *commandkit.Supplied[string] { return &v.SessionID }),
	}
}

// PromptInputs contains caller variables and native artifact references.
type PromptInputs struct {
	Vars   map[string]string
	Inputs map[string]promptkit.ArtifactRef
}

// PromptInputFlags exposes variable and named artifact input bindings.
type PromptInputFlags[I any] struct {
	Variable, Text, File commandkit.Flag[I]
}

// All returns all variable and input bindings.
func (f PromptInputFlags[I]) All() []commandkit.Flag[I] {
	return []commandkit.Flag[I]{f.Variable, f.Text, f.File}
}

// NewPromptInputFlags binds caller variables and input references to a field of
// the caller's input.
func NewPromptInputFlags[I any](destination func(*I) *PromptInputs) PromptInputFlags[I] {
	variable := commandkit.RepeatFlag(requestFlags.Var.meta, []variableAssignment(nil), parseVariableAssignment, func(i *I, v commandkit.Supplied[[]variableAssignment]) {
		if !v.Set {
			return
		}
		values := make(map[string]string, len(v.Value))
		for _, assignment := range v.Value {
			values[assignment.key] = assignment.value
		}
		destination(i).Vars = values
	})
	inputFlag := func(meta commandkit.FlagMeta, makeRef func(string) promptkit.ArtifactRef) commandkit.Flag[I] {
		return commandkit.OccurrenceFlag(meta, parseInputAssignment, func(i *I, v commandkit.Supplied[inputAssignment]) {
			input := destination(i)
			if input.Inputs == nil {
				input.Inputs = make(map[string]promptkit.ArtifactRef)
			}
			input.Inputs[v.Value.name] = makeRef(v.Value.value)
		})
	}
	return PromptInputFlags[I]{Variable: variable, Text: inputFlag(requestFlags.InputText.meta, promptkit.Inline), File: inputFlag(requestFlags.InputFile.meta, promptkit.File)}
}

func parseExecutionFloat(value string) (float64, error) {
	return strconv.ParseFloat(value, 64)
}