package processor

import (
	"regexp"
	"strings"
	"testing"
)

// TestLogger implements the Logger interface for testing
type TestLogger struct {
	T *testing.T // Reference to the test's *testing.T
}

func (l *TestLogger) Printf(format string, v ...interface{}) {
	if l.T != nil {
		l.T.Logf(format, v...)
	}
}

// Helper function to normalize whitespace for comparison
func normalizeWhitespace(s string) string {
	// Replace all whitespace with a single space
	re := regexp.MustCompile(`\s+`)
	return re.ReplaceAllString(strings.TrimSpace(s), " ")
}

func TestSimpleValueMultiplication(t *testing.T) {
	content := `
		<config>
			<item>
				<value>100</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>150</value>
			</item>
		</config>
	`

	// Create a regex pattern with the (?s) flag for multiline matching
	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{T: t})
	luaExpr := BuildLuaScript("*1.5")

	// Enable verbose logging for this test
	t.Logf("Running test with regex pattern: %s", regex.String())
	t.Logf("Original content: %s", content)
	t.Logf("Lua expression: %s", luaExpr)

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "*1.5")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	t.Logf("Modified content: %s", modifiedContent)
	t.Logf("Expected content: %s", expected)

	// Compare normalized content
	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestShorthandNotation(t *testing.T) {
	content := `
		<config>
			<item>
				<value>100</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>150</value>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 * 1.5") // Use direct assignment syntax

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "v1 * 1.5")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestShorthandNotationFloats(t *testing.T) {
	content := `
		<config>
			<item>
				<value>132.671327</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>176.01681007940928</value>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d*\.?\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 * 1.32671327") // Use direct assignment syntax

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "v1 * 1.32671327")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestArrayNotation(t *testing.T) {
	content := `
		<config>
			<item>
				<value>100</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>150</value>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 = v1 * 1.5") // Use direct assignment syntax

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "v1 = v1 * 1.5")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestMultipleMatches(t *testing.T) {
	content := `
		<config>
			<item>
				<value>100</value>
			</item>
			<item>
				<value>200</value>
			</item>
			<item> <value>300</value> </item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>150</value>
			</item>
			<item>
				<value>300</value>
			</item>
			<item> <value>450</value> </item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("*1.5")

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "*1.5")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 3 {
		t.Errorf("Expected 3 matches, got %d", matchCount)
	}
	if modCount != 3 {
		t.Errorf("Expected 3 modifications, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestMultipleCaptureGroups(t *testing.T) {
	content := `
		<config>
			<item>
				<value>10</value>
				<multiplier>5</multiplier>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>50</value>
				<multiplier>5</multiplier>
			</item>
		</config>
	`

	// Use (?s) flag to match across multiple lines
	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>.*?<multiplier>(\d+)</multiplier>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 = v1 * v2") // Use direct assignment syntax

	// Verify the regex matches before processing
	matches := regex.FindStringSubmatch(content)
	if len(matches) <= 1 {
		t.Fatalf("Regex didn't match any capture groups in test input: %v", content)
	}

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test", "v1 = v1 * v2")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

func TestModifyingMultipleValues(t *testing.T) {
	content := `
		<config>
			<item>
				<value>50</value>
				<multiplier>3</multiplier>
				<divider>2</divider>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>75</value>
				<multiplier>5</multiplier>
				<divider>1</divider>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>.*?<multiplier>(\d+)</multiplier>.*?<divider>(\d+)</divider>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 = v1 * v2 / v3; v2 = min(v2 * 2, 5); v3 = max(1, v3 / 2)")

	modifiedContent, modCount, matchCount, err := processor.ProcessContent(content, luaExpr, "test",
		"v1 = v1 * v2 / v3; v2 = min(v2 * 2, 5); v3 = max(1, v3 / 2)")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	// Verify match and modification counts
	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}
	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

// Added from main_test.go
func TestDecimalValues(t *testing.T) {
	content := `
		<config>
			<item>
				<value>10.5</value>
				<multiplier>2.5</multiplier>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>26.25</value>
				<multiplier>2.5</multiplier>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>([0-9.]+)</value>.*?<multiplier>([0-9.]+)</multiplier>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 = v1 * v2")

	modifiedContent, _, _, err := processor.ProcessContent(content, luaExpr, "test", "v1 = v1 * v2")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

// Added from main_test.go
func TestLuaMathFunctions(t *testing.T) {
	content := `
		<config>
			<item>
				<value>16</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>4</value>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("v1 = math.sqrt(v1)")

	modifiedContent, _, _, err := processor.ProcessContent(content, luaExpr, "test", "v1 = math.sqrt(v1)")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

// Added from main_test.go
func TestDirectAssignment(t *testing.T) {
	content := `
		<config>
			<item>
				<value>100</value>
			</item>
		</config>
	`
	expected := `
		<config>
			<item>
				<value>0</value>
			</item>
		</config>
	`

	regex := regexp.MustCompile(`(?s)<value>(\d+)</value>`)
	processor := NewRegexProcessor(regex, &TestLogger{})
	luaExpr := BuildLuaScript("=0")

	modifiedContent, _, _, err := processor.ProcessContent(content, luaExpr, "test", "=0")
	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	if normalizedModified != normalizedExpected {
		t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified)
	}
}

// Added from main_test.go
func TestStringAndNumericOperations(t *testing.T) {
	tests := []struct {
		name           string
		input          string
		regexPattern   string
		luaExpression  string
		expectedOutput string
		expectedMods   int
	}{
		{
			name:           "Basic numeric multiplication",
			input:          "<value>42</value>",
			regexPattern:   "<value>(\\d+)</value>",
			luaExpression:  "v1 = v1 * 2",
			expectedOutput: "<value>84</value>",
			expectedMods:   1,
		},
		{
			name:           "Basic string manipulation",
			input:          "<n>test</n>",
			regexPattern:   "<n>(.*?)</n>",
			luaExpression:  "s1 = string.upper(s1)",
			expectedOutput: "<n>TEST</n>",
			expectedMods:   1,
		},
		{
			name:           "String concatenation",
			input:          "<id>abc123</id>",
			regexPattern:   "<id>(.*?)</id>",
			luaExpression:  "s1 = s1 .. '_modified'",
			expectedOutput: "<id>abc123_modified</id>",
			expectedMods:   1,
		},
		{
			name:           "Numeric value from string using num()",
			input:          "<price>19.99</price>",
			regexPattern:   "<price>(.*?)</price>",
			luaExpression:  "v1 = num(s1) * 1.2",
			expectedOutput: "<price>23.987999999999996</price>",
			expectedMods:   1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Compile the regex pattern with multiline support
			pattern := regexp.MustCompile("(?s)" + tt.regexPattern)
			processor := NewRegexProcessor(pattern, &TestLogger{})
			luaExpr := BuildLuaScript(tt.luaExpression)

			// Process with our function
			result, modCount, _, err := processor.ProcessContent(tt.input, luaExpr, "test", tt.luaExpression)
			if err != nil {
				t.Fatalf("Process function failed: %v", err)
			}

			// Check results
			if result != tt.expectedOutput {
				t.Errorf("Expected output: %s, got: %s", tt.expectedOutput, result)
			}

			if modCount != tt.expectedMods {
				t.Errorf("Expected %d modifications, got %d", tt.expectedMods, modCount)
			}
		})
	}
}

// Added from main_test.go
func TestEdgeCases(t *testing.T) {
	tests := []struct {
		name           string
		input          string
		regexPattern   string
		luaExpression  string
		expectedOutput string
		expectedMods   int
	}{
		{
			name:           "Empty capture group",
			input:          "<value></value>",
			regexPattern:   "<value>(.*?)</value>",
			luaExpression:  "s1 = 'filled'",
			expectedOutput: "<value>filled</value>",
			expectedMods:   1,
		},
		{
			name:           "Non-numeric string with numeric operation",
			input:          "<value>abc</value>",
			regexPattern:   "<value>(.*?)</value>",
			luaExpression:  "v1 = v1 * 2",        // This would fail if we didn't handle strings properly
			expectedOutput: "<value>abc</value>", // Should remain unchanged
			expectedMods:   0,                    // No modifications
		},
		{
			name:           "Invalid number conversion",
			input:          "<value>abc</value>",
			regexPattern:   "<value>(.*?)</value>",
			luaExpression:  "v1 = num(s1) + 10", // num(s1) should return 0
			expectedOutput: "<value>10</value>",
			expectedMods:   1,
		},
		{
			name:           "Multiline string",
			input:          "<text>Line 1\nLine 2</text>",
			regexPattern:   "<text>(.*?)</text>",
			luaExpression:  "s1 = string.gsub(s1, '\\n', ' - ')",
			expectedOutput: "<text>Line 1 - Line 2</text>",
			expectedMods:   1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Make sure the regex can match across multiple lines
			pattern := regexp.MustCompile("(?s)" + tt.regexPattern)
			processor := NewRegexProcessor(pattern, &TestLogger{})
			luaExpr := BuildLuaScript(tt.luaExpression)

			// Process with our function
			result, modCount, _, err := processor.ProcessContent(tt.input, luaExpr, "test", tt.luaExpression)
			if err != nil {
				t.Fatalf("Process function failed: %v", err)
			}

			// Check results
			if result != tt.expectedOutput {
				t.Errorf("Expected output: %s, got: %s", tt.expectedOutput, result)
			}

			if modCount != tt.expectedMods {
				t.Errorf("Expected %d modifications, got %d", tt.expectedMods, modCount)
			}
		})
	}
}

func TestBuildLuaScript(t *testing.T) {
	testCases := []struct {
		input    string
		expected string
	}{
		{"*1.5", "v1 = v1*1.5"},
		{"/2", "v1 = v1/2"},
		{"+10", "v1 = v1+10"},
		{"-5", "v1 = v1-5"},
		{"^2", "v1 = v1^2"},
		{"%2", "v1 = v1%2"},
		{"=100", "v1 =100"},
		{"v1 * 2", "v1 = v1 * 2"},
		{"v1 + v2", "v1 = v1 + v2"},
		{"math.max(v1, 100)", "v1 = math.max(v1, 100)"},
		// Added from main_test.go
		{"s1 .. '_suffix'", "v1 = s1 .. '_suffix'"},
		{"v1 * v2", "v1 = v1 * v2"},
		{"s1 .. s2", "v1 = s1 .. s2"},
	}

	for _, tc := range testCases {
		result := BuildLuaScript(tc.input)
		if result != tc.expected {
			t.Errorf("BuildLuaScript(%q): expected %q, got %q", tc.input, tc.expected, result)
		}
	}
}