main_advanced_test.go

package main

import (
	"os"
	"path/filepath"
	"strings"
	"testing"
	"unicode/utf8"
)

// Advanced Edge Case Tests

func TestReplaceInLine_UnicodeEdgeCases(t *testing.T) {
	tests := []struct {
		name     string
		line     string
		search   string
		replace  string
		expected string
	}{
		{
			"emoji replacement",
			"hello 👋 world",
			"👋",
			"🌍",
			"hello 🌍 world",
		},
		{
			"multi-byte unicode",
			"こんにちは世界",
			"世界",
			"ワールド",
			"こんにちはワールド",
		},
		{
			"combining characters",
			"café résumé",
			"café",
			"coffee",
			"coffee résumé",
		},
		{
			"right-to-left text",
			"hello مرحبا world",
			"مرحبا",
			"שלום",
			"hello שלום world",
		},
		{
			"zero-width characters",
			"hello\u200Bworld",
			"hello\u200Bworld",
			"goodbye",
			"goodbye",
		},
		{
			"null byte in middle",
			"hello\x00world",
			"hello\x00world",
			"test",
			"test",
		},
		{
			"mixed scripts",
			"Привет hello 你好",
			"hello",
			"hola",
			"Привет hola 你好",
		},
	}

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

func TestReplaceInLine_BoundaryConditions(t *testing.T) {
	tests := []struct {
		name     string
		line     string
		search   string
		replace  string
		expected string
	}{
		{
			"empty line",
			"",
			"test",
			"exam",
			"",
		},
		{
			"empty search",
			"hello",
			"",
			"X",
			"hello",
		},
		{
			"empty replace",
			"hello world",
			"world",
			"",
			"hello ",
		},
		{
			"search longer than line",
			"hi",
			"hello world",
			"test",
			"hi",
		},
		{
			"replace entire line",
			"test",
			"test",
			"exam",
			"exam",
		},
		{
			"very long line",
			strings.Repeat("a", 100000) + "target" + strings.Repeat("b", 100000),
			"target",
			"replaced",
			strings.Repeat("a", 100000) + "replaced" + strings.Repeat("b", 100000),
		},
		{
			"many occurrences",
			strings.Repeat("x", 10000),
			"x",
			"y",
			strings.Repeat("y", 10000),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := replaceInLine(tt.line, tt.search, tt.replace, false, false)
			if result != tt.expected {
				// For very long strings, just check length
				if len(tt.line) > 1000 {
					if len(result) != len(tt.expected) {
						t.Errorf("Length mismatch: got %d, want %d", len(result), len(tt.expected))
					}
				} else {
					t.Errorf("replaceInLine(%q, %q, %q) = %q, want %q",
						tt.line, tt.search, tt.replace, result, tt.expected)
				}
			}
		})
	}
}

func TestReplaceInLine_SpecialCharacters(t *testing.T) {
	tests := []struct {
		name     string
		line     string
		search   string
		replace  string
		expected string
	}{
		{
			"newline in content",
			"hello\nworld",
			"hello\nworld",
			"test",
			"test",
		},
		{
			"tab characters",
			"hello\tworld",
			"\t",
			"    ",
			"hello    world",
		},
		{
			"carriage return",
			"hello\rworld",
			"\r",
			"",
			"helloworld",
		},
		{
			"multiple whitespace types",
			"hello \t\n\r world",
			" \t\n\r ",
			" ",
			"hello world",
		},
		{
			"backslash",
			"path\\to\\file",
			"\\",
			"/",
			"path/to/file",
		},
		{
			"quotes",
			`"hello" 'world'`,
			`"hello"`,
			`'hi'`,
			`'hi' 'world'`,
		},
		{
			"regex special chars",
			"hello.*world+test?",
			".*world+",
			"REPLACED",
			"helloREPLACEDtest?",
		},
	}

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

func TestContainsWholeWord_ComplexBoundaries(t *testing.T) {
	tests := []struct {
		name     string
		text     string
		word     string
		expected bool
	}{
		{"unicode boundary", "hello世界world", "world", true},
		{"emoji boundary", "test👋word", "word", true},
		{"emoji boundary fail", "test👋word", "test", true},
		{"multiple underscores", "___word___", "word", false},
		{"hyphen boundary", "test-word-test", "word", true},
		{"parentheses", "(word)", "word", true},
		{"brackets", "[word]", "word", true},
		{"braces", "{word}", "word", true},
		{"angle brackets", "<word>", "word", true},
		{"at start with special", "@word", "word", true},
		{"at end with special", "word!", "word", true},
		{"dot boundary", "word.com", "word", true},
		{"comma boundary", "word,test", "word", true},
		{"semicolon boundary", "word;test", "word", true},
		{"colon boundary", "word:test", "word", true},
	}

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

// File System Edge Cases

func TestReplaceInFile_BinaryContent(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	// Create file with binary content
	binaryContent := []byte{0x00, 0x01, 0x02, 't', 'e', 's', 't', 0xFF, 0xFE}
	filePath := filepath.Join(tmpDir, "binary.bin")
	if err := os.WriteFile(filePath, binaryContent, 0644); err != nil {
		t.Fatalf("Failed to create binary file: %v", err)
	}

	config := Config{
		Search:  "test",
		Replace: "exam",
		DryRun:  false,
	}

	// Should handle binary content without crashing
	_, _, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed on binary content: %v", err)
	}
}

func TestReplaceInFile_InvalidUTF8(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	// Create file with invalid UTF-8 sequences
	invalidUTF8 := []byte("hello \xFF\xFE world test\n")
	filePath := filepath.Join(tmpDir, "invalid.txt")
	if err := os.WriteFile(filePath, invalidUTF8, 0644); err != nil {
		t.Fatalf("Failed to create file: %v", err)
	}

	config := Config{
		Search:  "test",
		Replace: "exam",
		DryRun:  false,
	}

	// Should handle invalid UTF-8 without crashing
	linesChanged, _, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed on invalid UTF-8: %v", err)
	}

	if linesChanged != 1 {
		t.Errorf("Expected 1 line changed, got %d", linesChanged)
	}
}

func TestReplaceInFile_NoTrailingNewline(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	// File without trailing newline
	content := "line1\nline2\nline3 with target"
	filePath := createTestFile(t, tmpDir, "nonewline.txt", content)

	config := Config{
		Search:  "target",
		Replace: "REPLACED",
		DryRun:  false,
	}

	linesChanged, _, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed: %v", err)
	}

	if linesChanged != 1 {
		t.Errorf("Expected 1 line changed, got %d", linesChanged)
	}

	// Verify file structure preserved
	actualContent := readFileContent(t, filePath)
	if !strings.Contains(actualContent, "REPLACED") {
		t.Error("Replacement not found")
	}
}

func TestReplaceInFile_OnlyNewlines(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	content := "\n\n\n\n\n"
	filePath := createTestFile(t, tmpDir, "newlines.txt", content)

	config := Config{
		Search:  "test",
		Replace: "exam",
		DryRun:  false,
	}

	linesChanged, replacements, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed: %v", err)
	}

	if linesChanged != 0 {
		t.Errorf("Expected 0 lines changed, got %d", linesChanged)
	}

	if replacements != 0 {
		t.Errorf("Expected 0 replacements, got %d", replacements)
	}
}

// Case Insensitive Edge Cases

func TestCaseInsensitiveReplace_UnicodeCase(t *testing.T) {
	tests := []struct {
		name     string
		line     string
		search   string
		replace  string
		expected string
	}{
		{
			"German eszett",
			"straße",
			"strasse",
			"street",
			"straße", // ß doesn't lowercase to ss in simple lowercase
		},
		{
			"Turkish I problem",
			"Istanbul",
			"istanbul",
			"CITY",
			"CITY",
		},
		{
			"Greek sigma variants",
			"σίσυφος",
			"σίσυφος",
			"sisyphus",
			"sisyphus",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := caseInsensitiveReplace(tt.line, tt.search, tt.replace)
			if result != tt.expected {
				t.Logf("Note: Unicode case folding may behave differently")
				t.Logf("Got: %q, Expected: %q", result, tt.expected)
			}
		})
	}
}

// Complex Exclude Filter Tests

func TestReplaceInFile_ComplexExcludePatterns(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	content := `result = calculate()
dirresult = process()
tempresult = temp()
finalresult = final()
return result
`
	filePath := createTestFile(t, tmpDir, "test.txt", content)

	config := Config{
		Search:       "result",
		Replace:      "res",
		ExcludeLines: []string{"dirresult", "tempresult"},
		DryRun:       false,
	}

	linesChanged, _, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed: %v", err)
	}

	actualContent := readFileContent(t, filePath)

	// Should replace in first and last line, and finalresult line
	if !strings.Contains(actualContent, "res = calculate()") {
		t.Error("First line should be replaced")
	}
	if !strings.Contains(actualContent, "return res") {
		t.Error("Last line should be replaced")
	}
	if !strings.Contains(actualContent, "finalres") {
		t.Error("finalresult should be replaced")
	}

	// Should NOT replace these
	if !strings.Contains(actualContent, "dirresult") {
		t.Error("dirresult should not be replaced")
	}
	if !strings.Contains(actualContent, "tempresult") {
		t.Error("tempresult should not be replaced")
	}

	// Count lines changed - should be 3 (first, finalresult, last)
	if linesChanged != 3 {
		t.Errorf("Expected 3 lines changed, got %d", linesChanged)
	}
}

func TestReplaceInFile_ExcludeWithUnicode(t *testing.T) {
	tmpDir := setupTestDir(t)
	defer cleanupTestDir(t, tmpDir)

	content := "test normal\ntest 世界\ntest emoji 👋\n"
	filePath := createTestFile(t, tmpDir, "unicode.txt", content)

	config := Config{
		Search:       "test",
		Replace:      "exam",
		ExcludeLines: []string{"世界"},
		DryRun:       false,
	}

	linesChanged, _, err := replaceInFile(filePath, config)
	if err != nil {
		t.Fatalf("replaceInFile failed: %v", err)
	}

	if linesChanged != 2 {
		t.Errorf("Expected 2 lines changed, got %d", linesChanged)
	}

	actualContent := readFileContent(t, filePath)
	if !strings.Contains(actualContent, "test 世界") {
		t.Error("Unicode excluded line should not be replaced")
	}
}

// Whole Word Replacement Edge Cases

func TestWholeWordReplace_AdjacentMatches(t *testing.T) {
	tests := []struct {
		line     string
		search   string
		replace  string
		expected string
	}{
		{
			"log log log",
			"log",
			"X",
			"X X X",
		},
		{
			"logloglog",
			"log",
			"X",
			"logloglog",
		},
		{
			"log,log,log",
			"log",
			"X",
			"X,X,X",
		},
		{
			"log\tlog\tlog",
			"log",
			"X",
			"X\tX\tX",
		},
	}

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

// Positional Correctness

func TestReplaceInLine_AllPositions(t *testing.T) {
	// Test replacing a pattern at every possible position
	// Use a base string that doesn't contain the search pattern
	base := "abcdefghijklmnopqrstuvw"
	search := "XYZ"
	replace := "123"

	for i := 0; i <= len(base); i++ {
		line := base[:i] + search + base[i:]
		expected := base[:i] + replace + base[i:]

		result := replaceInLine(line, search, replace, false, false)
		if result != expected {
			t.Errorf("Position %d: got %q, want %q", i, result, expected)
		}
	}
}

// UTF-8 Validation Tests

func TestUTF8Handling(t *testing.T) {
	tests := []struct {
		name  string
		input string
		valid bool
	}{
		{"valid ASCII", "hello world", true},
		{"valid UTF-8", "hello 世界", true},
		{"valid emoji", "hello 👋🌍", true},
		{"invalid UTF-8 sequence", "hello \xFF\xFE", false},
		{"truncated UTF-8", "hello \xE4\xB8", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := utf8.ValidString(tt.input)
			if isValid != tt.valid {
				t.Errorf("UTF-8 validation mismatch: got %v, want %v", isValid, tt.valid)
			}

			// Test that our functions don't crash on invalid UTF-8
			_ = replaceInLine(tt.input, "world", "test", false, false)
			_ = containsWholeWord(tt.input, "hello")
		})
	}
}

// Search Pattern Edge Cases

func TestCountReplacements_LongSearchPattern(t *testing.T) {
	// Test with very long search pattern
	longPattern := strings.Repeat("abcdefghij", 100) // 1000 chars
	line := "prefix " + longPattern + " suffix"

	count := countReplacements(line, longPattern, false, false)
	if count != 1 {
		t.Errorf("Expected 1 replacement, got %d", count)
	}
}