main_test.go

package main

import (
	"bytes"
	"io"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"4d63.com/testcli"
	"github.com/adrg/xdg"
)

// mainFunc wraps our runMain function to match testcli.MainFunc signature
func mainFunc(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
	return runMain(args, stdin, stdout, stderr)
}

func TestHelp(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"--help"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	// Check for ASCII art banner
	if !strings.Contains(stdout, "███████╗██╗██╗") {
		t.Error("expected ASCII art banner in help output")
	}

	// Check for description
	if !strings.Contains(stdout, "Run AI tools") {
		t.Error("expected description in help output")
	}

	// Check for usage
	if !strings.Contains(stdout, "Usage:") {
		t.Error("expected usage section in help output")
	}

	// Check for examples
	if !strings.Contains(stdout, "Examples:") {
		t.Error("expected examples section in help output")
	}

	// Check for command groups
	if !strings.Contains(stdout, "Tools:") {
		t.Error("expected Tools group in help output")
	}

	if !strings.Contains(stdout, "Container Commands:") {
		t.Error("expected Container Commands group in help output")
	}

	if !strings.Contains(stdout, "Configuration:") {
		t.Error("expected Configuration group in help output")
	}

	// Check for config command
	if !strings.Contains(stdout, "config") {
		t.Error("expected config command in help output")
	}
}

func TestVersion(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"--version"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	if !strings.Contains(stdout, "silo version") {
		t.Errorf("expected version output, got: %s", stdout)
	}
}

func TestRootMountFlags(t *testing.T) {
	rootCmd := newRootCmd(io.Discard, io.Discard)

	mountFlag := rootCmd.Flags().Lookup("mount")
	if mountFlag == nil {
		t.Fatal("expected --mount flag on root command")
	}
	if mountFlag.Shorthand != "m" {
		t.Fatalf("expected --mount shorthand to be -m, got %q", mountFlag.Shorthand)
	}

	mountROFlag := rootCmd.Flags().Lookup("mountro")
	if mountROFlag == nil {
		t.Fatal("expected --mountro flag on root command")
	}

	if err := rootCmd.Flags().Parse([]string{
		"--mount", "/tmp/rw-a",
		"-m", "/tmp/rw-b",
		"--mountro", "/tmp/ro-a",
	}); err != nil {
		t.Fatalf("failed to parse mount flags: %v", err)
	}

	mountsRW, mountsRO, err := extraMountsFromFlags(rootCmd)
	if err != nil {
		t.Fatalf("failed to read mount flags: %v", err)
	}

	if len(mountsRW) != 2 || mountsRW[0] != "/tmp/rw-a" || mountsRW[1] != "/tmp/rw-b" {
		t.Fatalf("expected rw mounts [/tmp/rw-a /tmp/rw-b], got %v", mountsRW)
	}
	if len(mountsRO) != 1 || mountsRO[0] != "/tmp/ro-a" {
		t.Fatalf("expected ro mounts [/tmp/ro-a], got %v", mountsRO)
	}

	// Tool subcommands have flag parsing disabled — they should not own these
	// flags themselves.
	claudeCmd, _, err := rootCmd.Find([]string{"claude"})
	if err != nil {
		t.Fatalf("failed to find claude command: %v", err)
	}
	if claudeCmd.Flags().Lookup("mount") != nil {
		t.Error("did not expect --mount flag on claude command")
	}
	if !claudeCmd.DisableFlagParsing {
		t.Error("expected DisableFlagParsing on claude command")
	}
}

func TestQuietFlags(t *testing.T) {
	rootCmd := newRootCmd(io.Discard, io.Discard)

	rootQuiet := rootCmd.Flags().Lookup("quiet")
	if rootQuiet == nil {
		t.Fatal("expected --quiet flag on root command")
	}
	if rootQuiet.Shorthand != "q" {
		t.Fatalf("expected root --quiet shorthand to be -q, got %q", rootQuiet.Shorthand)
	}

	// Silo flags only live on the root command — tool subcommands forward
	// everything after the tool name to the tool unchanged.
	claudeCmd, _, err := rootCmd.Find([]string{"claude"})
	if err != nil {
		t.Fatalf("failed to find claude command: %v", err)
	}
	if claudeCmd.Flags().Lookup("quiet") != nil {
		t.Error("did not expect --quiet flag on claude command")
	}
}

func TestNoTTYFlags(t *testing.T) {
	rootCmd := newRootCmd(io.Discard, io.Discard)

	rootNoTTY := rootCmd.Flags().Lookup("no-tty")
	if rootNoTTY == nil {
		t.Fatal("expected --no-tty flag on root command")
	}

	claudeCmd, _, err := rootCmd.Find([]string{"claude"})
	if err != nil {
		t.Fatalf("failed to find claude command: %v", err)
	}
	if claudeCmd.Flags().Lookup("no-tty") != nil {
		t.Error("did not expect --no-tty flag on claude command")
	}
}

func TestPassThroughFlags(t *testing.T) {
	rootCmd := newRootCmd(io.Discard, io.Discard)

	if rootCmd.Flags().Lookup("continue") == nil {
		t.Fatal("expected --continue flag on root command")
	}
	if rootCmd.Flags().Lookup("resume") == nil {
		t.Fatal("expected --resume flag on root command")
	}

	if err := rootCmd.Flags().Parse([]string{"--continue", "--resume", "abc"}); err != nil {
		t.Fatalf("failed to parse pass-through flags: %v", err)
	}

	got := passThroughToolArgs(rootCmd)
	want := []string{"--continue", "--resume", "abc"}
	if len(got) != len(want) {
		t.Fatalf("expected %v, got %v", want, got)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Fatalf("expected %v, got %v", want, got)
		}
	}
}

func TestConfigShowCommand(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"config", "show"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	// Check that output is valid JSONC with expected fields
	if !strings.Contains(stdout, `"mounts_ro"`) {
		t.Error("expected mounts_ro field in JSONC output")
	}

	if !strings.Contains(stdout, `"mounts_rw"`) {
		t.Error("expected mounts_rw field in JSONC output")
	}

	if !strings.Contains(stdout, `"env"`) {
		t.Error("expected env field in JSONC output")
	}

	if !strings.Contains(stdout, `"tools"`) {
		t.Error("expected tools field in JSONC output")
	}

	// Check for default tools in JSONC
	if !strings.Contains(stdout, `"claude"`) {
		t.Error("expected claude tool in JSONC output")
	}

	if !strings.Contains(stdout, `"cline"`) {
		t.Error("expected cline tool in JSONC output")
	}

	if !strings.Contains(stdout, `"opencode"`) {
		t.Error("expected opencode tool in JSONC output")
	}

	if !strings.Contains(stdout, `"paperclipai"`) {
		t.Error("expected paperclipai tool in JSONC output")
	}

	if !strings.Contains(stdout, `"copilot"`) {
		t.Error("expected copilot tool in JSONC output")
	}

	// Check for source comments
	if !strings.Contains(stdout, "// default") {
		t.Error("expected source comments in JSONC output")
	}
}

func TestConfigHelp(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"config", "--help"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	if !strings.Contains(stdout, "Configuration management commands") {
		t.Error("expected config description in help output")
	}

	if !strings.Contains(stdout, "show") {
		t.Error("expected show subcommand in help output")
	}

	if !strings.Contains(stdout, "paths") {
		t.Error("expected paths subcommand in help output")
	}

	if !strings.Contains(stdout, "edit") {
		t.Error("expected edit subcommand in help output")
	}
}

func TestConfigPathsCommand(t *testing.T) {
	// Create a temp dir with a config file
	tmpDir := testcli.MkdirTemp(t)
	testcli.Chdir(t, tmpDir)

	configPath := filepath.Join(tmpDir, "silo.jsonc")
	if err := os.WriteFile(configPath, []byte("{}"), 0644); err != nil {
		t.Fatalf("failed to write config: %v", err)
	}

	exitCode, stdout, _ := testcli.Main(t, []string{"config", "paths"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	// Should show the config path we created
	if !strings.Contains(stdout, configPath) {
		t.Errorf("expected %s in paths output, got: %s", configPath, stdout)
	}
}

func TestInitCommand(t *testing.T) {
	tmpDir := testcli.MkdirTemp(t)
	testcli.Chdir(t, tmpDir)

	exitCode, _, stderr := testcli.Main(t, []string{"config", "init", "--local"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d, stderr: %s", exitCode, stderr)
	}

	// Check that config file was created
	configPath := filepath.Join(tmpDir, "silo.jsonc")
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		t.Error("expected silo.jsonc to be created")
	}

	// Check contents
	content, err := os.ReadFile(configPath)
	if err != nil {
		t.Fatalf("failed to read config file: %v", err)
	}

	if !strings.Contains(string(content), "mounts_ro") {
		t.Error("expected mounts_ro field in config")
	}

	if !strings.Contains(string(content), "mounts_rw") {
		t.Error("expected mounts_rw field in config")
	}

	if !strings.Contains(string(content), `"env"`) {
		t.Error("expected env field in config")
	}
}

func TestInitCommandAlreadyExists(t *testing.T) {
	tmpDir := testcli.MkdirTemp(t)
	testcli.Chdir(t, tmpDir)

	// Create existing config
	configPath := filepath.Join(tmpDir, "silo.jsonc")
	testcli.WriteFile(t, configPath, []byte("{}"))

	exitCode, _, stderr := testcli.Main(t, []string{"config", "init", "--local"}, nil, mainFunc)

	if exitCode == 0 {
		t.Error("expected failure when config already exists")
	}

	if !strings.Contains(stderr, "already exists") {
		t.Errorf("expected 'already exists' error, got: %s", stderr)
	}
}

func TestInitHelp(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"config", "init", "--help"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	if !strings.Contains(stdout, "Create a sample") {
		t.Error("expected init description in help output")
	}

	if !strings.Contains(stdout, "--global") {
		t.Error("expected --global flag in help output")
	}

	if !strings.Contains(stdout, "--local") {
		t.Error("expected --local flag in help output")
	}
}

func TestInitCommandGlobal(t *testing.T) {
	tmpDir := testcli.MkdirTemp(t)
	configDir := filepath.Join(tmpDir, ".config")

	// Set XDG_CONFIG_HOME to temp directory
	oldXdg := os.Getenv("XDG_CONFIG_HOME")
	os.Setenv("XDG_CONFIG_HOME", configDir)
	xdg.Reload()
	defer func() {
		os.Setenv("XDG_CONFIG_HOME", oldXdg)
		xdg.Reload()
	}()

	exitCode, _, stderr := testcli.Main(t, []string{"config", "init", "--global"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d, stderr: %s", exitCode, stderr)
	}

	// Check that config file was created in the right place
	configPath := filepath.Join(configDir, "silo", "silo.jsonc")
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		t.Errorf("expected global config at %s to be created", configPath)
	}
}

func TestInvalidTool(t *testing.T) {
	exitCode, _, stderr := testcli.Main(t, []string{"invalid-tool"}, nil, mainFunc)

	if exitCode == 0 {
		t.Error("expected failure for invalid tool")
	}

	if !strings.Contains(stderr, "unknown command") {
		t.Errorf("expected 'unknown command' error, got: %s", stderr)
	}
}

func TestQuietSuppressesTopLevelErrors(t *testing.T) {
	var stdout, stderr bytes.Buffer

	exitCode := runMain([]string{"--quiet", "invalid-tool"}, nil, &stdout, &stderr)

	if exitCode == 0 {
		t.Fatal("expected failure for invalid tool")
	}
	if stderr.Len() != 0 {
		t.Fatalf("expected no stderr output with --quiet, got: %s", stderr.String())
	}
}

func TestCompletionCommand(t *testing.T) {
	shells := []string{"bash", "zsh", "fish", "powershell"}

	for _, shell := range shells {
		t.Run(shell, func(t *testing.T) {
			exitCode, stdout, stderr := testcli.Main(t, []string{"completion", shell}, nil, mainFunc)

			if exitCode != 0 {
				t.Fatalf("expected exit code 0 for %s completion, got %d, stderr: %s", shell, exitCode, stderr)
			}

			if stdout == "" {
				t.Errorf("expected completion output for %s", shell)
			}
		})
	}
}

func TestHelpCommand(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"help"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	// Should show same as --help
	if !strings.Contains(stdout, "Run AI tools") {
		t.Error("expected description in help output")
	}
}

func TestHelpConfig(t *testing.T) {
	exitCode, stdout, _ := testcli.Main(t, []string{"help", "config"}, nil, mainFunc)

	if exitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", exitCode)
	}

	if !strings.Contains(stdout, "Show the current merged configuration") {
		t.Error("expected config description in help output")
	}
}

func TestRunMainFunction(t *testing.T) {
	var stdout, stderr bytes.Buffer

	exitCode := runMain([]string{"--help"}, nil, &stdout, &stderr)

	if exitCode != 0 {
		t.Errorf("expected exit code 0, got %d", exitCode)
	}

	if !strings.Contains(stdout.String(), "silo") {
		t.Error("expected help output")
	}
}