package main

import (
	"bufio"
	"encoding/json"
	"os"
	"strings"
	"testing"
)

func TestFormatContextInfo_NilUsage(t *testing.T) {
	result := formatContextInfo(200000, nil)
	expected := "0/200k"
	if result != expected {
		t.Errorf("formatContextInfo(200000, nil) = %q, want %q", result, expected)
	}
}

func TestFormatContextInfo_WithUsage(t *testing.T) {
	usage := &TokenUsage{
		InputTokens:          8500,
		CacheCreationTokens:  5000,
		CacheReadInputTokens: 2000,
	}
	result := formatContextInfo(200000, usage)
	expected := "15k/200k"
	if result != expected {
		t.Errorf("formatContextInfo(200000, usage) = %q, want %q", result, expected)
	}
}

func TestFormatContextInfo_SmallValues(t *testing.T) {
	usage := &TokenUsage{
		InputTokens:          500,
		CacheCreationTokens:  0,
		CacheReadInputTokens: 0,
	}
	result := formatContextInfo(100000, usage)
	expected := "0k/100k"
	if result != expected {
		t.Errorf("formatContextInfo(100000, usage) = %q, want %q", result, expected)
	}
}

func TestStripANSI(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{
			name:     "no ansi",
			input:    "hello world",
			expected: "hello world",
		},
		{
			name:     "single color",
			input:    "\033[32mgreen\033[0m",
			expected: "green",
		},
		{
			name:     "multiple colors",
			input:    "\033[31mred\033[0m \033[32mgreen\033[0m",
			expected: "red green",
		},
		{
			name:     "bold",
			input:    "\033[1mbold\033[0m",
			expected: "bold",
		},
		{
			name:     "complex",
			input:    "\033[32m●\033[0m \033[35mOpus\033[0m \033[1;32m➜\033[0m",
			expected: "● Opus ➜",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := stripANSI(tt.input)
			if result != tt.expected {
				t.Errorf("stripANSI(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}

func TestStatusInputParsing(t *testing.T) {
	jsonData := `{
		"model": {"display_name": "Opus 4.5"},
		"workspace": {"current_dir": "/root/projects/statusline"},
		"context_window": {
			"context_window_size": 200000,
			"current_usage": {
				"input_tokens": 5000,
				"cache_creation_input_tokens": 1000,
				"cache_read_input_tokens": 500
			}
		}
	}`

	var data StatusInput
	err := json.Unmarshal([]byte(jsonData), &data)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if data.Model.DisplayName != "Opus 4.5" {
		t.Errorf("Model.DisplayName = %q, want %q", data.Model.DisplayName, "Opus 4.5")
	}

	if data.Workspace.CurrentDir != "/root/projects/statusline" {
		t.Errorf("Workspace.CurrentDir = %q, want %q", data.Workspace.CurrentDir, "/root/projects/statusline")
	}

	if data.ContextWindow.ContextWindowSize != 200000 {
		t.Errorf("ContextWindow.ContextWindowSize = %d, want %d", data.ContextWindow.ContextWindowSize, 200000)
	}

	if data.ContextWindow.CurrentUsage == nil {
		t.Fatal("ContextWindow.CurrentUsage is nil")
	}

	if data.ContextWindow.CurrentUsage.InputTokens != 5000 {
		t.Errorf("CurrentUsage.InputTokens = %d, want %d", data.ContextWindow.CurrentUsage.InputTokens, 5000)
	}
}

func TestStatusInputParsing_NilUsage(t *testing.T) {
	jsonData := `{
		"model": {"display_name": "Sonnet"},
		"workspace": {"current_dir": "/tmp"},
		"context_window": {
			"context_window_size": 100000
		}
	}`

	var data StatusInput
	err := json.Unmarshal([]byte(jsonData), &data)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if data.ContextWindow.CurrentUsage != nil {
		t.Errorf("ContextWindow.CurrentUsage should be nil, got %+v", data.ContextWindow.CurrentUsage)
	}
}

func TestGetGitInfo_CurrentRepo(t *testing.T) {
	cwd, err := os.Getwd()
	if err != nil {
		t.Skipf("Could not get working directory: %v", err)
	}

	result := getGitInfo(cwd)

	// Should return something like " git:(master)" or " git:(master) ✗"
	if result == "" {
		t.Skip("Not in a git repository")
	}

	if !contains(result, "git:(") {
		t.Errorf("getGitInfo(%q) = %q, expected to contain 'git:('", cwd, result)
	}
}

func TestGetGitInfo_NonRepo(t *testing.T) {
	result := getGitInfo("/tmp")

	// /tmp is unlikely to be a git repo
	if result != "" && !contains(result, "git:(") {
		t.Errorf("getGitInfo(/tmp) = %q, expected empty or valid git info", result)
	}
}

func TestGetGiteaStatus(t *testing.T) {
	result := getGiteaStatus()

	// Should return either green or red dot
	greenDot := green + "●" + reset
	redDot := red + "●" + reset

	if result != greenDot && result != redDot {
		t.Errorf("getGiteaStatus() = %q, expected green or red dot", result)
	}
}

func contains(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsHelper(s, substr))
}

func containsHelper(s, substr string) bool {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return true
		}
	}
	return false
}

func TestGetTerminalWidth(t *testing.T) {
	// getTerminalWidth should return a positive integer
	// In test environment (no TTY), it should fall back to 80
	width := getTerminalWidth()
	if width <= 0 {
		t.Errorf("getTerminalWidth() = %d, expected positive value", width)
	}
}

func TestGetTerminalWidth_DefaultFallback(t *testing.T) {
	// When not connected to a terminal, should return 80
	width := getTerminalWidth()
	// In CI/test environments, this typically returns 80
	if width != 80 && width < 40 {
		t.Errorf("getTerminalWidth() = %d, expected 80 or reasonable terminal width", width)
	}
}

func TestGetGitInfo_InvalidPath(t *testing.T) {
	result := getGitInfo("/nonexistent/path/that/does/not/exist")
	if result != "" {
		t.Errorf("getGitInfo(invalid) = %q, expected empty string", result)
	}
}

func TestGetGitInfo_RootDir(t *testing.T) {
	// Root directory is unlikely to be a git repo
	result := getGitInfo("/")
	if result != "" && !contains(result, "git:(") {
		t.Errorf("getGitInfo(/) = %q, expected empty or valid git info", result)
	}
}

func TestFormatContextInfo_ZeroContextSize(t *testing.T) {
	result := formatContextInfo(0, nil)
	expected := "0/0k"
	if result != expected {
		t.Errorf("formatContextInfo(0, nil) = %q, want %q", result, expected)
	}
}

func TestFormatContextInfo_LargeValues(t *testing.T) {
	usage := &TokenUsage{
		InputTokens:          150000,
		CacheCreationTokens:  25000,
		CacheReadInputTokens: 10000,
	}
	result := formatContextInfo(200000, usage)
	expected := "185k/200k"
	if result != expected {
		t.Errorf("formatContextInfo(200000, large usage) = %q, want %q", result, expected)
	}
}

func TestFormatContextInfo_ExactThousand(t *testing.T) {
	usage := &TokenUsage{
		InputTokens:          1000,
		CacheCreationTokens:  0,
		CacheReadInputTokens: 0,
	}
	result := formatContextInfo(100000, usage)
	expected := "1k/100k"
	if result != expected {
		t.Errorf("formatContextInfo(100000, 1000 tokens) = %q, want %q", result, expected)
	}
}

func TestStripANSI_Empty(t *testing.T) {
	result := stripANSI("")
	if result != "" {
		t.Errorf("stripANSI(\"\") = %q, want empty", result)
	}
}

func TestStripANSI_OnlyANSI(t *testing.T) {
	result := stripANSI("\033[31m\033[0m")
	if result != "" {
		t.Errorf("stripANSI(only codes) = %q, want empty", result)
	}
}

func TestStripANSI_NestedCodes(t *testing.T) {
	input := "\033[1m\033[31mbold red\033[0m\033[0m"
	result := stripANSI(input)
	expected := "bold red"
	if result != expected {
		t.Errorf("stripANSI(%q) = %q, want %q", input, result, expected)
	}
}

func TestStatusInputParsing_EmptyJSON(t *testing.T) {
	jsonData := `{}`
	var data StatusInput
	err := json.Unmarshal([]byte(jsonData), &data)
	if err != nil {
		t.Fatalf("Failed to parse empty JSON: %v", err)
	}
	if data.Model.DisplayName != "" {
		t.Errorf("Expected empty DisplayName, got %q", data.Model.DisplayName)
	}
}

func TestStatusInputParsing_PartialJSON(t *testing.T) {
	jsonData := `{"model": {"display_name": "Test"}}`
	var data StatusInput
	err := json.Unmarshal([]byte(jsonData), &data)
	if err != nil {
		t.Fatalf("Failed to parse partial JSON: %v", err)
	}
	if data.Model.DisplayName != "Test" {
		t.Errorf("DisplayName = %q, want %q", data.Model.DisplayName, "Test")
	}
	if data.Workspace.CurrentDir != "" {
		t.Errorf("Expected empty CurrentDir, got %q", data.Workspace.CurrentDir)
	}
}

func TestStatusInputParsing_InvalidJSON(t *testing.T) {
	jsonData := `{invalid json}`
	var data StatusInput
	err := json.Unmarshal([]byte(jsonData), &data)
	if err == nil {
		t.Error("Expected error for invalid JSON, got nil")
	}
}

func TestANSIConstants(t *testing.T) {
	// Verify ANSI constants are properly defined
	tests := []struct {
		name     string
		constant string
		prefix   string
	}{
		{"reset", reset, "\033["},
		{"red", red, "\033["},
		{"green", green, "\033["},
		{"yellow", yellow, "\033["},
		{"magenta", magenta, "\033["},
		{"cyan", cyan, "\033["},
		{"boldGreen", boldGreen, "\033["},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if !contains(tt.constant, tt.prefix) {
				t.Errorf("%s constant doesn't start with ANSI escape", tt.name)
			}
		})
	}
}

func TestGetGiteaStatus_ReturnsValidColor(t *testing.T) {
	result := getGiteaStatus()

	// Must contain the dot character
	if !contains(result, "●") {
		t.Errorf("getGiteaStatus() = %q, expected to contain dot", result)
	}

	// Must contain ANSI codes
	stripped := stripANSI(result)
	if stripped != "●" {
		t.Errorf("stripped getGiteaStatus() = %q, expected just dot", stripped)
	}
}

func TestReadInputFromStdin(t *testing.T) {
	input := "line1\nline2\nline3"
	reader := bufio.NewReader(strings.NewReader(input))
	result := readInputFromStdin(reader)
	expected := "line1\nline2\nline3"
	if result != expected {
		t.Errorf("readInputFromStdin = %q, want %q", result, expected)
	}
}

func TestReadInputFromStdin_Empty(t *testing.T) {
	reader := bufio.NewReader(strings.NewReader(""))
	result := readInputFromStdin(reader)
	if result != "" {
		t.Errorf("readInputFromStdin (empty) = %q, want empty", result)
	}
}

func TestParseStatusInput_Valid(t *testing.T) {
	jsonStr := `{"model": {"display_name": "Test"}, "workspace": {"current_dir": "/test"}}`
	data, err := parseStatusInput(jsonStr)
	if err != nil {
		t.Fatalf("parseStatusInput failed: %v", err)
	}
	if data.Model.DisplayName != "Test" {
		t.Errorf("DisplayName = %q, want Test", data.Model.DisplayName)
	}
	if data.Workspace.CurrentDir != "/test" {
		t.Errorf("CurrentDir = %q, want /test", data.Workspace.CurrentDir)
	}
}

func TestParseStatusInput_Invalid(t *testing.T) {
	_, err := parseStatusInput("invalid json")
	if err == nil {
		t.Error("parseStatusInput should fail on invalid JSON")
	}
}

func TestBuildStatusLine_ContainsComponents(t *testing.T) {
	data := &StatusInput{}
	data.Model.DisplayName = "TestModel"
	data.Workspace.CurrentDir = "/home/user/project"
	data.ContextWindow.ContextWindowSize = 100000
	data.ContextWindow.CurrentUsage = &TokenUsage{
		InputTokens:          5000,
		CacheCreationTokens:  1000,
		CacheReadInputTokens: 500,
	}

	left, right := buildStatusLine(data)

	// Check left contains model name and directory
	if !contains(left, "TestModel") {
		t.Errorf("left statusline missing model: %q", left)
	}
	if !contains(left, "project") {
		t.Errorf("left statusline missing directory: %q", left)
	}

	// Check right contains context info
	if !contains(right, "6k/100k") {
		t.Errorf("right statusline missing context info: %q", right)
	}
}

func TestBuildStatusLine_HasGiteaStatus(t *testing.T) {
	data := &StatusInput{}
	data.Model.DisplayName = "Model"
	data.Workspace.CurrentDir = "/tmp"
	data.ContextWindow.ContextWindowSize = 100000

	left, _ := buildStatusLine(data)

	// Check for gitea status (dot)
	if !contains(left, "●") {
		t.Errorf("left statusline missing gitea status: %q", left)
	}
}

func TestCalculatePadding_ZeroWidth(t *testing.T) {
	result := calculatePadding("left", "right", 0)
	expected := 1
	if result != expected {
		t.Errorf("calculatePadding(\"left\", \"right\", 0) = %d, want %d", result, expected)
	}
}

func TestCalculatePadding_NegativeResult(t *testing.T) {
	result := calculatePadding("left", "right", 5)
	expected := 1
	if result != expected {
		t.Errorf("calculatePadding with overflow = %d, want minimum of %d", result, expected)
	}
}

func TestCalculatePadding_Normal(t *testing.T) {
	result := calculatePadding("left", "right", 50)
	expected := 50 - len("left") - len("right")
	if result != expected {
		t.Errorf("calculatePadding(\"left\", \"right\", 50) = %d, want %d", result, expected)
	}
}

func TestFormatOutput_Composition(t *testing.T) {
	result := formatOutput("LEFT", "RIGHT", 5)
	expected := "LEFT     RIGHT"
	if result != expected {
		t.Errorf("formatOutput = %q, want %q", result, expected)
	}
}

func TestFormatOutput_Empty(t *testing.T) {
	result := formatOutput("", "", 0)
	expected := ""
	if result != expected {
		t.Errorf("formatOutput (empty) = %q, want %q", result, expected)
	}
}

func TestFormatOutput_WithANSI(t *testing.T) {
	left := red + "text" + reset
	right := green + "info" + reset
	result := formatOutput(left, right, 3)

	stripped := stripANSI(result)
	if !contains(stripped, "text") || !contains(stripped, "info") {
		t.Errorf("formatOutput with ANSI = %q, expected both parts visible", stripped)
	}
}