package executor

import (
	"context"
	"io"
	"log/slog"
	"strings"
	"testing"

	"github.com/thepeterstone/claudomator/internal/storage"
	"github.com/thepeterstone/claudomator/internal/task"
)

func TestGeminiRunner_BuildArgs_BasicTask(t *testing.T) {
	r := &GeminiRunner{}
	tk := &task.Task{
		Agent: task.AgentConfig{
			Type:         "gemini",
			Instructions: "fix the bug",
			Model:        "gemini-2.5-flash-lite",
			SkipPlanning: true,
		},
	}

	args := r.buildArgs(tk, &storage.Execution{ID: "test-exec"}, "/tmp/q.json")

	// Gemini CLI: instructions passed via -p for non-interactive mode
	if len(args) < 2 || args[0] != "-p" || args[1] != "fix the bug" {
		t.Errorf("expected -p <instructions> as first args, got: %v", args)
	}

	argMap := make(map[string]bool)
	for _, a := range args {
		argMap[a] = true
	}
	for _, want := range []string{"--output-format", "stream-json", "--model", "gemini-2.5-flash-lite"} {
		if !argMap[want] {
			t.Errorf("missing arg %q in %v", want, args)
		}
	}
}

func TestGeminiRunner_BuildArgs_PreamblePrepended(t *testing.T) {
	r := &GeminiRunner{}
	tk := &task.Task{
		Agent: task.AgentConfig{
			Type:         "gemini",
			Instructions: "fix the bug",
			SkipPlanning: false,
		},
	}

	args := r.buildArgs(tk, &storage.Execution{ID: "test-exec"}, "/tmp/q.json")

	if len(args) < 2 || args[0] != "-p" {
		t.Fatalf("expected -p <instructions> as first args, got: %v", args)
	}
	if !strings.HasPrefix(args[1], planningPreamble) {
		t.Errorf("instructions should start with planning preamble")
	}
	if !strings.HasSuffix(args[1], "fix the bug") {
		t.Errorf("instructions should end with original instructions")
	}
}

func TestGeminiRunner_BuildArgs_IncludesYolo(t *testing.T) {
	r := &GeminiRunner{}
	tk := &task.Task{
		Agent: task.AgentConfig{
			Type:         "gemini",
			Instructions: "write a doc",
			SkipPlanning: true,
		},
	}
	args := r.buildArgs(tk, &storage.Execution{ID: "test-exec"}, "/tmp/q.json")
	argMap := make(map[string]bool)
	for _, a := range args {
		argMap[a] = true
	}
	if !argMap["--yolo"] {
		t.Errorf("expected --yolo in gemini args (enables all tools); got: %v", args)
	}
}

func TestGeminiRunner_BuildArgs_IncludesPromptFlag(t *testing.T) {
	r := &GeminiRunner{}
	tk := &task.Task{
		Agent: task.AgentConfig{
			Type:         "gemini",
			Instructions: "do the thing",
			SkipPlanning: true,
		},
	}
	args := r.buildArgs(tk, &storage.Execution{ID: "test-exec"}, "/tmp/q.json")
	// Instructions must be passed via -p/--prompt for non-interactive headless mode,
	// not as a bare positional (which starts interactive mode).
	found := false
	for i, a := range args {
		if (a == "-p" || a == "--prompt") && i+1 < len(args) && args[i+1] == "do the thing" {
			found = true
			break
		}
	}
	if !found {
		t.Errorf("expected instructions passed via -p/--prompt flag; got: %v", args)
	}
}

func TestGeminiRunner_Run_InaccessibleProjectDir_ReturnsError(t *testing.T) {
	r := &GeminiRunner{
		BinaryPath: "true", // would succeed if it ran
		Logger:     slog.New(slog.NewTextHandler(io.Discard, nil)),
		LogDir:     t.TempDir(),
	}
	tk := &task.Task{
		Agent: task.AgentConfig{
			Type:         "gemini",
			ProjectDir:   "/nonexistent/path/does/not/exist",
			SkipPlanning: true,
		},
	}
	exec := &storage.Execution{ID: "test-exec"}

	err := r.Run(context.Background(), tk, exec)

	if err == nil {
		t.Fatal("expected error for inaccessible project_dir, got nil")
	}
	if !strings.Contains(err.Error(), "project_dir") {
		t.Errorf("expected 'project_dir' in error, got: %v", err)
	}
}

func TestGeminiRunner_BinaryPath_Default(t *testing.T) {
	r := &GeminiRunner{}
	if r.binaryPath() != "gemini" {
		t.Errorf("want 'gemini', got %q", r.binaryPath())
	}
}

func TestGeminiRunner_BinaryPath_Custom(t *testing.T) {
	r := &GeminiRunner{BinaryPath: "/usr/local/bin/gemini"}
	if r.binaryPath() != "/usr/local/bin/gemini" {
		t.Errorf("want custom path, got %q", r.binaryPath())
	}
}