package profile

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"

	"github.com/pelletier/go-toml/v2"

	"github.com/tidbcloud/AgentTeam/desktop/internal/agent/runtimeconfig"
)

// RuntimeDefaultSettings captures the concrete default settings the current
// machine can resolve for a runtime.
type RuntimeDefaultSettings struct {
	Model           string `json:"model,omitempty"`
	ReasoningEffort string `json:"reasoningEffort,omitempty"`
}

// DetectRuntimeDefaults resolves the current machine defaults for the supplied
// runtime names. Unknown fields are left empty so callers can still surface a
// generic "runtime default" label while preserving explicit-empty semantics.
func DetectRuntimeDefaults(runtimeNames []string) map[string]RuntimeDefaultSettings {
	if len(runtimeNames) == 0 {
		return map[string]RuntimeDefaultSettings{}
	}

	defaults := make(map[string]RuntimeDefaultSettings, len(runtimeNames))
	seen := make(map[string]struct{}, len(runtimeNames))
	for _, runtimeName := range runtimeNames {
		normalized := string(runtimeconfig.NormalizeType(strings.TrimSpace(runtimeName)))
		if normalized == "" {
			continue
		}
		if _, ok := seen[normalized]; ok {
			continue
		}
		seen[normalized] = struct{}{}
		defaults[normalized] = detectRuntimeDefault(normalized)
	}
	return defaults
}

func detectRuntimeDefault(runtimeName string) RuntimeDefaultSettings {
	switch runtimeconfig.EffectiveRuntimeType(runtimeconfig.NormalizeType(runtimeName)) {
	case runtimeconfig.TypeClaudeCode:
		return RuntimeDefaultSettings{}
	case runtimeconfig.TypeCodex:
		return detectCodexRuntimeDefault()
	case runtimeconfig.TypeOpenCode:
		return detectOpenCodeRuntimeDefault()
	default:
		return RuntimeDefaultSettings{}
	}
}

func detectOpenCodeRuntimeDefault() RuntimeDefaultSettings {
	home, _ := os.UserHomeDir()
	if home == "" {
		return RuntimeDefaultSettings{}
	}

	configDir := filepath.Join(home, ".config", "opencode")
	for _, name := range []string{"opencode.json", "opencode.jsonc"} {
		path := filepath.Join(configDir, name)
		data, err := os.ReadFile(path)
		if err != nil {
			continue
		}

		var config openCodeConfig
		if err := json.Unmarshal([]byte(stripJSONComments(string(data))), &config); err != nil {
			continue
		}
		return RuntimeDefaultSettings{Model: strings.TrimSpace(config.Model)}
	}

	return RuntimeDefaultSettings{}
}

func detectCodexRuntimeDefault() RuntimeDefaultSettings {
	home, _ := os.UserHomeDir()
	if home == "" {
		return RuntimeDefaultSettings{}
	}

	path := filepath.Join(home, ".codex", "config.toml")
	data, err := os.ReadFile(path)
	if err != nil {
		return RuntimeDefaultSettings{}
	}

	var config struct {
		Model                string `toml:"model"`
		ModelReasoningEffort string `toml:"model_reasoning_effort"`
	}
	if err := toml.Unmarshal(data, &config); err != nil {
		return RuntimeDefaultSettings{}
	}

	return RuntimeDefaultSettings{
		Model:           strings.TrimSpace(config.Model),
		ReasoningEffort: strings.TrimSpace(config.ModelReasoningEffort),
	}
}