package main

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/pinchtab/pinchtab/internal/cli"
	"github.com/pinchtab/pinchtab/internal/config"
	"github.com/pinchtab/pinchtab/internal/server"
	"github.com/spf13/cobra"
)

var clipboardExecCommand = exec.Command

var configCmd = &cobra.Command{
	Use:   "config",
	Short: "Manage configuration",
	Run: func(cmd *cobra.Command, args []string) {
		handleConfigOverview(loadConfig())
	},
}

func init() {
	configCmd.GroupID = "config"
	configCmd.AddCommand(&cobra.Command{
		Use:   "show",
		Short: "Display current configuration",
		Run: func(cmd *cobra.Command, args []string) {
			cfg := config.Load()
			cli.HandleConfigShow(cfg)
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "init",
		Short: "Initialize a new config file",
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigInit()
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "path",
		Short: "Show config file path",
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigPath()
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "validate",
		Short: "Validate config file",
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigValidate()
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "get <path>",
		Short: "Get a config value (e.g., server.port)",
		Args:  cobra.ExactArgs(1),
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigGet(args[0])
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "set <path> <val>",
		Short: "Set a config value (e.g., server.port 8080)",
		Args:  cobra.ExactArgs(2),
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigSet(args[0], args[1])
		},
	})
	configCmd.AddCommand(&cobra.Command{
		Use:   "patch <json>",
		Short: "Merge JSON into config",
		Args:  cobra.ExactArgs(1),
		Run: func(cmd *cobra.Command, args []string) {
			handleConfigPatch(args[0])
		},
	})

	rootCmd.AddCommand(configCmd)
}

func handleConfigOverview(cfg *config.RuntimeConfig) {
	_, configPath, err := config.LoadFileConfig()
	if err != nil {
		fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.ErrorStyle, fmt.Sprintf("Error loading config path: %v", err)))
		os.Exit(1)
	}

	dashPort := cfg.Port
	if dashPort == "" {
		dashPort = "9870"
	}
	dashboardURL := fmt.Sprintf("http://localhost:%s", dashPort)
	running := server.CheckPinchTabRunning(dashPort, cfg.Token)

	for {
		fmt.Print(renderConfigOverview(cfg, configPath, dashboardURL, running))

		if !isInteractiveTerminal() {
			return
		}

		nextCfg, changed, done, err := promptConfigEdit(cfg)
		if err != nil {
			fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.ErrorStyle, err.Error()))
			fmt.Println()
			continue
		}
		if done {
			return
		}
		if !changed {
			fmt.Println()
			continue
		}

		cfg = nextCfg
		dashPort = cfg.Port
		if dashPort == "" {
			dashPort = "9870"
		}
		dashboardURL = fmt.Sprintf("http://localhost:%s", dashPort)
		running = server.CheckPinchTabRunning(dashPort, cfg.Token)
		fmt.Println()
	}
}

func renderConfigOverview(cfg *config.RuntimeConfig, configPath, dashboardURL string, running bool) string {
	out := ""
	out += cli.StyleStdout(cli.HeadingStyle, "Config") + "\n\n"
	out += fmt.Sprintf("  1. %-18s %s\n", "Strategy", cli.StyleStdout(cli.ValueStyle, cfg.Strategy))
	out += fmt.Sprintf("  2. %-18s %s\n", "Allocation policy", cli.StyleStdout(cli.ValueStyle, cfg.AllocationPolicy))
	out += fmt.Sprintf("  3. %-18s %s\n", "Stealth level", cli.StyleStdout(cli.ValueStyle, cfg.StealthLevel))
	out += fmt.Sprintf("  4. %-18s %s\n", "Tab eviction", cli.StyleStdout(cli.ValueStyle, cfg.TabEvictionPolicy))
	out += fmt.Sprintf("  5. %-18s %s\n", "Copy token", cli.StyleStdout(cli.MutedStyle, "clipboard"))
	out += "\n"
	out += cli.StyleStdout(cli.HeadingStyle, "More") + "\n\n"
	out += fmt.Sprintf("  %s %s\n", cli.StyleStdout(cli.MutedStyle, "File:"), cli.StyleStdout(cli.ValueStyle, configPath))
	out += fmt.Sprintf("  %s %s\n", cli.StyleStdout(cli.MutedStyle, "Token:"), cli.StyleStdout(cli.ValueStyle, config.MaskToken(cfg.Token)))
	if running {
		out += fmt.Sprintf("  %s %s\n", cli.StyleStdout(cli.MutedStyle, "Dashboard:"), cli.StyleStdout(cli.ValueStyle, dashboardURL))
	} else {
		out += fmt.Sprintf("  %s %s\n", cli.StyleStdout(cli.MutedStyle, "Dashboard:"), cli.StyleStdout(cli.MutedStyle, "not running"))
	}
	if isInteractiveTerminal() {
		out += "\n"
		out += cli.StyleStdout(cli.MutedStyle, "Edit item (1-5, blank to exit):") + " "
	}
	out += "\n"
	return out
}

func promptConfigEdit(cfg *config.RuntimeConfig) (*config.RuntimeConfig, bool, bool, error) {
	choice, err := promptInput("", "")
	if err != nil {
		return nil, false, false, err
	}
	choice = strings.TrimSpace(choice)
	if choice == "" {
		return nil, false, true, nil
	}

	switch choice {
	case "1":
		nextCfg, changed, err := editConfigSelection("Instance strategy", "multiInstance.strategy", cfg.Strategy, config.ValidStrategies())
		return nextCfg, changed, false, err
	case "2":
		nextCfg, changed, err := editConfigSelection("Allocation policy", "multiInstance.allocationPolicy", cfg.AllocationPolicy, config.ValidAllocationPolicies())
		return nextCfg, changed, false, err
	case "3":
		nextCfg, changed, err := editConfigSelection("Default stealth level", "instanceDefaults.stealthLevel", cfg.StealthLevel, config.ValidStealthLevels())
		return nextCfg, changed, false, err
	case "4":
		nextCfg, changed, err := editConfigSelection("Default tab eviction", "instanceDefaults.tabEvictionPolicy", cfg.TabEvictionPolicy, config.ValidEvictionPolicies())
		return nextCfg, changed, false, err
	case "5":
		if err := copyConfigToken(cfg.Token); err != nil {
			return nil, false, false, err
		}
		return nil, false, false, nil
	default:
		return nil, false, false, fmt.Errorf("invalid selection %q", choice)
	}
}

func editConfigSelection(title, path, current string, values []string) (*config.RuntimeConfig, bool, error) {
	options := make([]menuOption, 0, len(values)+1)
	for _, value := range values {
		label := value
		if value == current {
			label += " (current)"
		}
		options = append(options, menuOption{label: label, value: value})
	}
	options = append(options, menuOption{label: "Cancel", value: "cancel"})

	picked, err := promptSelect(title, options)
	if err != nil {
		return nil, false, err
	}
	if picked == "" || picked == "cancel" {
		return nil, false, nil
	}

	nextCfg, changed, err := updateConfigValue(path, picked)
	if err != nil {
		return nil, false, err
	}
	if changed {
		fmt.Println(cli.StyleStdout(cli.SuccessStyle, fmt.Sprintf("Updated %s to %s", path, picked)))
		fmt.Println(cli.StyleStdout(cli.MutedStyle, "Restart PinchTab to apply file-based changes."))
	}
	return nextCfg, changed, nil
}

func copyConfigToken(token string) error {
	if strings.TrimSpace(token) == "" {
		return fmt.Errorf("server token is empty")
	}

	if err := copyToClipboard(token); err == nil {
		fmt.Println(cli.StyleStdout(cli.SuccessStyle, "Token copied to clipboard."))
		return nil
	}

	fmt.Println(cli.StyleStdout(cli.WarningStyle, "Clipboard unavailable; copy the token manually:"))
	fmt.Println(cli.StyleStdout(cli.ValueStyle, token))
	return nil
}

func copyToClipboard(text string) error {
	candidates := clipboardCommands()
	var lastErr error

	for _, candidate := range candidates {
		if _, err := exec.LookPath(candidate.name); err != nil {
			lastErr = err
			continue
		}
		cmd := clipboardExecCommand(candidate.name, candidate.args...)
		cmd.Stdin = strings.NewReader(text)
		if output, err := cmd.CombinedOutput(); err != nil {
			if len(strings.TrimSpace(string(output))) > 0 {
				lastErr = fmt.Errorf("%s: %s", err, strings.TrimSpace(string(output)))
			} else {
				lastErr = err
			}
			continue
		}
		return nil
	}

	if lastErr == nil {
		return fmt.Errorf("no clipboard command available")
	}
	return lastErr
}

type clipboardCommand struct {
	name string
	args []string
}

func clipboardCommands() []clipboardCommand {
	switch runtime.GOOS {
	case "darwin":
		return []clipboardCommand{{name: "pbcopy"}}
	case "windows":
		return []clipboardCommand{{name: "clip"}}
	default:
		return []clipboardCommand{
			{name: "wl-copy"},
			{name: "xclip", args: []string{"-selection", "clipboard"}},
			{name: "xsel", args: []string{"--clipboard", "--input"}},
		}
	}
}

func handleConfigInit() {
	configPath := os.Getenv("PINCHTAB_CONFIG")
	if configPath == "" {
		configPath = config.DefaultConfigPath()
	}

	if _, err := os.Stat(configPath); err == nil {
		fmt.Printf("Config file already exists at %s\n", configPath)
		fmt.Print("Overwrite? (y/N): ")
		var response string
		_, _ = fmt.Scanln(&response)
		if response != "y" && response != "Y" {
			return
		}
	}

	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
		fmt.Printf("Error creating directory: %v\n", err)
		os.Exit(1)
	}

	fc := config.DefaultFileConfig()
	token, err := config.GenerateAuthToken()
	if err != nil {
		fmt.Printf("Error generating auth token: %v\n", err)
		os.Exit(1)
	}
	fc.Server.Token = token

	if err := config.SaveFileConfig(&fc, configPath); err != nil {
		fmt.Printf("Error writing config: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Config file created at %s\n", configPath)
}

func handleConfigPath() {
	configPath := os.Getenv("PINCHTAB_CONFIG")
	if configPath == "" {
		configPath = config.DefaultConfigPath()
	}
	fmt.Println(configPath)
}

func handleConfigGet(path string) {
	fc, _, err := config.LoadFileConfig()
	if err != nil {
		fmt.Printf("Error loading config: %v\n", err)
		os.Exit(1)
	}

	value, err := config.GetConfigValue(fc, path)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}

	fmt.Println(value)
}

func handleConfigSet(path, value string) {
	fc, configPath, err := config.LoadFileConfig()
	if err != nil {
		fmt.Printf("Error loading config: %v\n", err)
		os.Exit(1)
	}

	if err := config.SetConfigValue(fc, path, value); err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}

	if errs := config.ValidateFileConfig(fc); len(errs) > 0 {
		fmt.Printf("Warning: new value causes validation error(s):\n")
		for _, err := range errs {
			fmt.Printf("  - %v\n", err)
		}
		fmt.Print("Save anyway? (y/N): ")
		var response string
		_, _ = fmt.Scanln(&response)
		if response != "y" && response != "Y" {
			return
		}
	}

	if err := config.SaveFileConfig(fc, configPath); err != nil {
		fmt.Printf("Error saving config: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Set %s = %s\n", path, value)
}

func handleConfigPatch(jsonPatch string) {
	fc, configPath, err := config.LoadFileConfig()
	if err != nil {
		fmt.Printf("Error loading config: %v\n", err)
		os.Exit(1)
	}

	if err := config.PatchConfigJSON(fc, jsonPatch); err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}

	if errs := config.ValidateFileConfig(fc); len(errs) > 0 {
		fmt.Printf("Warning: patch causes validation error(s):\n")
		for _, err := range errs {
			fmt.Printf("  - %v\n", err)
		}
		fmt.Print("Save anyway? (y/N): ")
		var response string
		_, _ = fmt.Scanln(&response)
		if response != "y" && response != "Y" {
			return
		}
	}

	if err := config.SaveFileConfig(fc, configPath); err != nil {
		fmt.Printf("Error saving config: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("Config patched successfully")
}

func handleConfigValidate() {
	configPath := os.Getenv("PINCHTAB_CONFIG")
	if configPath == "" {
		configPath = config.DefaultConfigPath()
	}
	data, err := os.ReadFile(configPath)
	if err != nil {
		fmt.Printf("Error reading config file: %v\n", err)
		os.Exit(1)
	}

	fc := &config.FileConfig{}
	if err := json.Unmarshal(data, fc); err != nil {
		fmt.Printf("Error parsing config: %v\n", err)
		os.Exit(1)
	}

	if errs := config.ValidateFileConfig(fc); len(errs) > 0 {
		fmt.Printf("Config file has %d error(s):\n", len(errs))
		for _, err := range errs {
			fmt.Printf("  - %v\n", err)
		}
		os.Exit(1)
	}

	fmt.Printf("Config file is valid: %s\n", configPath)
}