package processor

import (
	"bytes"
	"io"
	"modify/utils"
	"os"
	"regexp"
	"strings"
	"testing"

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

// 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 ...any) {
	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 ApiAdaptor(content string, regex string, lua string) (string, int, int, error) {
	command := utils.ModifyCommand{
		Regex:    regex,
		Lua:      lua,
		LogLevel: "TRACE",
	}

	commands, err := ProcessRegex(content, command, "test")
	if err != nil {
		return "", 0, 0, err
	}

	result, modifications := utils.ExecuteModifications(commands, content)
	return result, modifications, len(commands), nil
}

func TestBuildLuaScript(t *testing.T) {
	cases := []struct {
		input    string
		expected string
	}{
		{"s1 .. '_suffix'", "v1 = s1 .. '_suffix'"},
		{"v1 * 1.5", "v1 = v1 * 1.5"},
		{"v1 + 10", "v1 = v1 + 10"},
		{"v1 * 2", "v1 = v1 * 2"},
		{"v1 * v2", "v1 = v1 * v2"},
		{"v1 / v2", "v1 = v1 / v2"},
		{"12", "v1 = 12"},
	}

	for _, c := range cases {
		result := PrependLuaAssignment(c.input)
		assert.Equal(t, c.expected, result, "BuildLuaScript(%q): expected %q, got %q", c.input, c.expected, result)
	}
}

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

	expected := `<config>
    <item>
        <value>150</value>
    </item>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<value>(\d+)</value>`, "v1 = v1*1.5")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

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

	expected := `<config>
    <item>
        <value>150</value>
    </item>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<value>(\d+)</value>`, "v1*1.5")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

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

	expected := `<config>
    <item>
        <value>15.75</value>
    </item>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<value>(\d+\.\d+)</value>`, "v1*1.5")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestArrayNotation(t *testing.T) {
	content := `<config>
    <prices>
        <price>10</price>
        <price>20</price>
        <price>30</price>
    </prices>
</config>`

	expected := `<config>
    <prices>
        <price>20</price>
        <price>40</price>
        <price>60</price>
    </prices>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<price>(\d+)</price>`, "v1*2")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 3, matches, "Expected 3 matches, got %d", matches)
	assert.Equal(t, 3, mods, "Expected 3 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMultipleNumericMatches(t *testing.T) {
	content := `<data>
    <entry>50</entry>
    <entry>100</entry>
    <entry>200</entry>
</data>`

	expected := `<data>
    <entry>100</entry>
    <entry>200</entry>
    <entry>400</entry>
</data>`

	result, mods, matches, err := ApiAdaptor(content, `<entry>(\d+)</entry>`, "v1*2")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 3, matches, "Expected 3 matches, got %d", matches)
	assert.Equal(t, 3, mods, "Expected 3 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMultipleStringMatches(t *testing.T) {
	content := `<data>
    <name>John</name>
    <name>Mary</name>
</data>`

	expected := `<data>
    <name>John_modified</name>
    <name>Mary_modified</name>
</data>`

	result, mods, matches, err := ApiAdaptor(content, `<name>([A-Za-z]+)</name>`, `s1 = s1 .. "_modified"`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestStringUpperCase(t *testing.T) {
	content := `<users>
    <user>John</user>
    <user>Mary</user>
</users>`

	expected := `<users>
    <user>JOHN</user>
    <user>MARY</user>
</users>`

	result, mods, matches, err := ApiAdaptor(content, `<user>([A-Za-z]+)</user>`, `s1 = string.upper(s1)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestStringConcatenation(t *testing.T) {
	content := `<products>
    <product>Apple</product>
    <product>Banana</product>
</products>`

	expected := `<products>
    <product>Apple_fruit</product>
    <product>Banana_fruit</product>
</products>`

	result, mods, matches, err := ApiAdaptor(content, `<product>([A-Za-z]+)</product>`, `s1 = s1 .. "_fruit"`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

// 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>`)
	luaExpr := BuildLuaScript("v1 = v1 * v2")

	result, _, _, err := ApiAdaptor(content, regex.String(), luaExpr)
	assert.NoError(t, err, "Error processing content: %v", err)

	normalizedModified := normalizeWhitespace(result)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedModified, "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>`)
	luaExpr := BuildLuaScript("v1 = math.sqrt(v1)")

	modifiedContent, _, _, err := ApiAdaptor(content, regex.String(), luaExpr)
	assert.NoError(t, err, "Error processing content: %v", err)

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedModified, "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>`)
	luaExpr := BuildLuaScript("=0")

	modifiedContent, _, _, err := ApiAdaptor(content, regex.String(), luaExpr)
	assert.NoError(t, err, "Error processing content: %v", err)

	normalizedModified := normalizeWhitespace(modifiedContent)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedModified, "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:          "<name>test</name>",
			regexPattern:   "<name>(.*?)</name>",
			luaExpression:  "s1 = string.upper(s1)",
			expectedOutput: "<name>TEST</name>",
			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 := "(?s)" + tt.regexPattern
			luaExpr := BuildLuaScript(tt.luaExpression)

			// Process with our function
			result, modCount, _, err := ApiAdaptor(tt.input, pattern, luaExpr)
			assert.NoError(t, err, "Process function failed: %v", err)

			// Check results
			assert.Equal(t, tt.expectedOutput, result, "Expected output: %s, got: %s", tt.expectedOutput, result)
			assert.Equal(t, tt.expectedMods, modCount, "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 := "(?s)" + tt.regexPattern
			luaExpr := BuildLuaScript(tt.luaExpression)

			// Process with our function
			result, modCount, _, err := ApiAdaptor(tt.input, pattern, luaExpr)
			assert.NoError(t, err, "Process function failed: %v", err)

			// Check results
			assert.Equal(t, tt.expectedOutput, result, "Expected output: %s, got: %s", tt.expectedOutput, result)
			assert.Equal(t, tt.expectedMods, modCount, "Expected %d modifications, got %d", tt.expectedMods, modCount)
		})
	}
}

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

	expected := `<config>
    <item>
        <value>200</value>
    </item>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<value>(?<amount>\d+)</value>`, "amount = amount * 2")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

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

	expected := `<config>
    <item>
        <value>200</value>
    </item>
</config>`

	result, mods, matches, err := ApiAdaptor(content, `(?s)<value>(?<amount>!num)</value>`, "amount = amount * 2")

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMultipleNamedCaptureGroups(t *testing.T) {
	content := `<product>
    <name>Widget</name>
    <price>15.99</price>
    <quantity>10</quantity>
</product>`

	expected := `<product>
    <name>WIDGET</name>
    <price>23.99</price>
    <quantity>15</quantity>
</product>`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<name>(?<prodName>[^<]+)</name>.*?<price>(?<prodPrice>\d+\.\d+)</price>.*?<quantity>(?<prodQty>\d+)</quantity>`,
		`prodName = string.upper(prodName)
		 prodPrice = round(prodPrice + 8, 2)
		 prodQty = prodQty + 5`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 3, matches, "Expected 3 matches, got %d", matches)
	assert.Equal(t, 3, mods, "Expected 3 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMixedIndexedAndNamedCaptures(t *testing.T) {
	content := `<entry>
    <id>12345</id>
    <data>value</data>
</entry>`

	expected := `<entry>
    <id>24690</id>
    <data>VALUE</data>
</entry>`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<id>(\d+)</id>.*?<data>(?<dataField>[^<]+)</data>`,
		`v1 = v1 * 2
		 dataField = string.upper(dataField)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestComplexNestedNamedCaptures(t *testing.T) {
	content := `<person>
		<details>
			<name>John Smith</name>
			<age>32</age>
		</details>
		<contact>
			<email>john@example.com</email>
		</contact>
	</person>`

	expected := `<person>
		<details>
			<name>JOHN SMITH (32)</name>
			<age>32</age>
		</details>
		<contact>
			<email>john@example.com</email>
		</contact>
	</person>`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<details>.*?<name>(?<fullName>[^<]+)</name>.*?<age>(?<age>\d+)</age>`,
		`fullName = string.upper(fullName) .. " (" .. age .. ")"`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCaptureWithVariableReadback(t *testing.T) {
	content := `<stats>
    <health>100</health>
    <mana>200</mana>
</stats>`

	expected := `<stats>
    <health>150</health>
    <mana>300</mana>
</stats>`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<health>(?<hp>\d+)</health>.*?<mana>(?<mp>\d+)</mana>`,
		`hp = hp * 1.5
		 mp = mp * 1.5`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCaptureWithSpecialCharsInName(t *testing.T) {
	content := `<data value="42" min="10" max="100" />`

	expected := `<data value="84" min="10" max="100" />`

	result, mods, matches, err := ApiAdaptor(content,
		`<data value="(?<val_1>\d+)"`,
		`val_1 = val_1 * 2`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestEmptyNamedCapture(t *testing.T) {
	content := `<tag attr="" />`

	expected := `<tag attr="default" />`

	result, mods, matches, err := ApiAdaptor(content,
		`attr="(?<value>.*?)"`,
		`value = value == "" and "default" or value`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMultipleNamedCapturesInSameLine(t *testing.T) {
	content := `<rect x="10" y="20" width="100" height="50" />`

	expected := `<rect x="20" y="40" width="200" height="100" />`

	result, mods, matches, err := ApiAdaptor(content,
		`x="(?<x>\d+)" y="(?<y>\d+)" width="(?<w>\d+)" height="(?<h>\d+)"`,
		`x = x * 2
		 y = y * 2
		 w = w * 2
		 h = h * 2`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 4, matches, "Expected 4 matches, got %d", matches)
	assert.Equal(t, 4, mods, "Expected 4 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestConditionalNamedCapture(t *testing.T) {
	content := `
	<item status="active" count="5" />
	<item status="inactive" count="10" />
	`

	expected := `
	<item status="active" count="10" />
	<item status="inactive" count="10" />
	`

	result, mods, matches, err := ApiAdaptor(content,
		`<item status="(?<status>[^"]+)" count="(?<count>\d+)"`,
		`count = status == "active" and count * 2 or count`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 matches, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestLuaFunctionsOnNamedCaptures(t *testing.T) {
	content := `
	<user name="john doe" role="user" />
	<user name="jane smith" role="admin" />
	`

	expected := `
	<user name="John Doe" role="user" />
	<user name="JANE SMITH" role="admin" />
	`

	result, mods, matches, err := ApiAdaptor(content,
		`<user name="(?<name>[^"]+)" role="(?<role>[^"]+)"`,
		`-- Capitalize first letters for regular users
		 if role == "user" then
		   name = name:gsub("(%w)(%w*)", function(first, rest) return first:upper()..rest end):gsub(" (%w)(%w*)", " %1%2")
		 else
		   -- Uppercase for admins
		   name = string.upper(name)
		 end`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)

	// For simpler tests, we can use this. More complex string modifications
	// might need additional transformations before comparison
	normalizedResult := normalizeWhitespace(result)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedResult, "Expected content to be different")
}

func TestNamedCaptureWithMath(t *testing.T) {
	content := `
	<item price="19.99" quantity="3" />
	`

	expected := `
	<item price="19.99" quantity="3" total="59.97" />
	`

	result, mods, matches, err := ApiAdaptor(content,
		`<item price="(?<price>\d+\.\d+)" quantity="(?<qty>\d+)"!any$`,
		`-- Calculate and add total
		 replacement = string.format('<item price="%s" quantity="%s" total="%.2f" />',
			price, qty, price * qty)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)

	result = normalizeWhitespace(result)
	expected = normalizeWhitespace(expected)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCaptureWithGlobals(t *testing.T) {
	content := `<temp unit="C">25</temp>`

	expected := `<temp unit="F">77</temp>`

	result, mods, matches, err := ApiAdaptor(content,
		`<temp unit="(?<unit>[CF]?)">(?<value>\d+)</temp>`,
		`if unit == "C" then
		  value = value * 9/5 + 32
		  unit = "F"
		elseif unit == "F" then
		  value = (value - 32) * 5/9
		  unit = "C"
		end`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestMixedDynamicAndNamedCaptures(t *testing.T) {
	content := `
	<color rgb="255,0,0" name="red" />
	<color rgb="0,255,0" name="green" />
	`

	expected := `
	<color rgb="255,0,0" name="RED" hex="#FF0000" />
	<color rgb="0,255,0" name="GREEN" hex="#00FF00" />
	`

	result, mods, matches, err := ApiAdaptor(content,
		`<color rgb="(?<r>\d+),(?<g>\d+),(?<b>\d+)" name="(?<colorName>[^"]+)" />`,
		`-- Uppercase the name
		 colorName = string.upper(colorName)

		 -- Create hex color
		 local hex = string.format("#%02X%02X%02X", tonumber(r), tonumber(g), tonumber(b))

		 -- Replace the entire match
		 replacement = string.format('<color rgb="%s,%s,%s" name="%s" hex="%s" />',
		                            r, g, b, colorName, hex)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)

	result = normalizeWhitespace(result)
	expected = normalizeWhitespace(expected)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCapturesWithMultipleReferences(t *testing.T) {
	content := `<text>Hello world</text>`

	expected := `<text format="uppercase" length="11">HELLO WORLD</text>`

	result, mods, matches, err := ApiAdaptor(content,
		`<text>(?<content>[^<]+)</text>`,
		`local uppercaseContent = string.upper(content)
		 local contentLength = string.len(content)
		 replacement = string.format('<text format="uppercase" length="%d">%s</text>',
		                            contentLength, uppercaseContent)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCaptureWithJsonData(t *testing.T) {
	content := `<data>{"name":"John","age":30}</data>`

	expected := `<data>{"name":"JOHN","age":30}</data>`

	result, mods, matches, err := ApiAdaptor(content,
		`<data>(?<json>\{.*?\})</data>`,
		`-- Parse JSON (simplified, assumes valid JSON)
		 local name = json:match('"name":"([^"]+)"')
		 local upperName = string.upper(name)
		 json = json:gsub('"name":"([^"]+)"', '"name":"' .. upperName .. '"')`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestNamedCaptureInXML(t *testing.T) {
	content := `
	<product>
		<sku>ABC-123</sku>
		<price currency="USD">19.99</price>
		<stock>25</stock>
	</product>
	`

	expected := `
	<product>
		<sku>ABC-123</sku>
		<price currency="USD">23.99</price>
		<stock>20</stock>
	</product>
	`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<price currency="(?<currency>[^"]+)">(?<price>\d+\.\d+)</price>.*?<stock>(?<stock>\d+)</stock>`,
		`-- Add 20% to price if USD
		 if currency == "USD" then
		   price = round(price * 1.20, 2)
		 end

		 -- Reduce stock by 5
		 stock = stock - 5`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 2, matches, "Expected 2 matches, got %d", matches)
	assert.Equal(t, 2, mods, "Expected 2 modifications, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

func TestComprehensiveNamedCaptures(t *testing.T) {
	content := `
	<products>
		<product sku="AB-123" status="in-stock">
			<name>Widget A</name>
			<price currency="USD">19.99</price>
			<quantity>15</quantity>
		</product>
		<product sku="CD-456" status="out-of-stock">
			<name>Widget B</name>
			<price currency="EUR">29.99</price>
			<quantity>0</quantity>
		</product>
		<product sku="EF-789" status="in-stock">
			<name>Widget C</name>
			<price currency="GBP">39.99</price>
			<quantity>5</quantity>
		</product>
	</products>
	`

	expected := `
	<products>
		<product sku="AB-123" status="in-stock" discounted="true">
			<name>WIDGET A</name>
			<price currency="USD">15.99</price>
			<quantity>15</quantity>
		</product>
		<product sku="CD-456" status="out-of-stock" discounted="false">
			<name>Widget B</name>
			<price currency="EUR">29.99</price>
			<quantity>0</quantity>
		</product>
		<product sku="EF-789" status="in-stock" discounted="true">
			<name>WIDGET C</name>
			<price currency="GBP">39.99</price>
			<quantity>5</quantity>
		</product>
	</products>
	`

	result, mods, matches, err := ApiAdaptor(content,
		`(?s)<product sku="(?<sku>[^"]+)" status="(?<status>[^"]+)"[^>]*>\s*<name>(?<product_name>[^<]+)</name>\s*<price currency="(?<currency>[^"]+)">(?<price>\d+\.\d+)</price>\s*<quantity>(?<qty>\d+)</quantity>`,
		`-- Only process in-stock items
		if status == "in-stock" then
			-- Transform name to uppercase
			product_name = string.upper(product_name)

			-- Apply discount based on currency
			local discounted = true
			if currency == "USD" then
				price = round(price * 0.8, 2)  -- 20% discount for USD
			elseif currency == "GBP" then
				price = round(price * 0.8, 2)  -- 20% discount for GBP
				price = price + 8  -- Add shipping cost for GBP
			else
				discounted = false
			end

			-- Add discounted attribute
			replacement = string.format('<product sku="%s" status="%s" discounted="%s">\n\t\t\t<name>%s</name>\n\t\t\t<price currency="%s">%.2f</price>\n\t\t\t<quantity>%s</quantity>',
				sku, status, tostring(discounted), product_name, currency, price, qty)
		else
			-- Add discounted attribute for out-of-stock items (always false)
			replacement = string.format('<product sku="%s" status="%s" discounted="false">\n\t\t\t<name>%s</name>\n\t\t\t<price currency="%s">%s</price>\n\t\t\t<quantity>%s</quantity>',
				sku, status, product_name, currency, price, qty)
		end`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 3, matches, "Expected 3 matches, got %d", matches)
	assert.Equal(t, 3, mods, "Expected 3 modifications, got %d", mods)

	// Normalize whitespace for comparison
	normalizedResult := normalizeWhitespace(result)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedResult, "Expected content to be different")
}

func TestVariousNamedCaptureFormats(t *testing.T) {
	content := `
	<data>
		<entry id="1" value="100" />
		<entry id="2" value="200" status="active" />
		<entry id="3" value="300" status="inactive" />
	</data>
	`

	expected := `
	<data>
		<entry id="ID-1" value="200" />
		<entry id="ID-2" value="400" status="ACTIVE" />
		<entry id="ID-3" value="300" status="inactive" />
	</data>
	`

	result, mods, matches, err := ApiAdaptor(content,
		`<entry id="(?<id_num>\d+)" value="(?<val>\d+)"(?: status="(?<status>[^"]*)")? />`,
		`-- Prefix the ID with "ID-"
		id_num = "ID-" .. id_num
		print(id_num)
		print(val)
		print(status)

		-- Double the value except for inactive status
		if not status or status ~= "inactive" then
			val = val * 2
		end

		-- Convert status to uppercase if present and active
		if status and status == "active" then
			status = string.upper(status)
		end

		-- Build the replacement based on whether status exists
		if status then
			replacement = string.format('<entry id="%s" value="%s" status="%s" />', id_num, val, status)
		else
			replacement = string.format('<entry id="%s" value="%s" />', id_num, val)
		end`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 3, matches, "Expected 3 matches, got %d", matches)
	assert.Equal(t, 3, mods, "Expected 3 modifications, got %d", mods)

	normalizedResult := normalizeWhitespace(result)
	normalizedExpected := normalizeWhitespace(expected)
	assert.Equal(t, normalizedExpected, normalizedResult, "Expected content to be different")
}

func TestSimpleNamedCapture(t *testing.T) {
	content := `<product name="Widget" price="19.99"/>`

	expected := `<product name="WIDGET" price="19.99"/>`

	result, mods, matches, err := ApiAdaptor(content,
		`name="(?<product_name>[^"]+)"`,
		`product_name = string.upper(product_name)`)

	assert.NoError(t, err, "Error processing content: %v", err)
	assert.Equal(t, 1, matches, "Expected 1 match, got %d", matches)
	assert.Equal(t, 1, mods, "Expected 1 modification, got %d", mods)
	assert.Equal(t, expected, result, "Expected content to be different")
}

// Pattern without "(?s)" prefix gets modified to include it
func TestPatternWithoutPrefixGetsModified(t *testing.T) {
	// Setup
	pattern := "some.*pattern"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)some.*pattern"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Empty string input returns "(?s)"
func TestEmptyStringReturnsWithPrefix(t *testing.T) {
	// Setup
	pattern := ""

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Named group with "!num" pattern gets replaced with proper regex for numbers
func TestNamedGroupNumPatternReplacement(t *testing.T) {
	// Setup
	pattern := "(?<group>!num)"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)(?<group>-?\\d*\\.?\\d+)"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// "!any" placeholder gets replaced with ".*?" pattern
func TestAnyPlaceholderReplacement(t *testing.T) {
	// Setup
	pattern := "start!anyend"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)start.*?end"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// "!rep(pattern, count)" correctly repeats the pattern with separators
func TestRepPatternRepetition(t *testing.T) {
	// Setup
	pattern := "!rep(a, 3)"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)a.*?a.*?a"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Multiple different placeholders in the same pattern are all correctly replaced
func TestMultiplePlaceholdersReplacedCorrectly(t *testing.T) {
	// Setup
	pattern := "(?s)some(?<num1>!num)text!anymore!rep(!num, 3)"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)some(?<num1>-?\\d*\\.?\\d+)text.*?more(-?\\d*\\.?\\d+).*?(-?\\d*\\.?\\d+).*?(-?\\d*\\.?\\d+)"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Pattern already containing "(?s)" prefix remains unchanged
func TestPatternWithPrefixRemainsUnchanged(t *testing.T) {
	// Setup
	pattern := "(?s)some.*pattern"

	// Redirect stdout to capture fmt.Printf output
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Restore stdout
	w.Close()
	os.Stdout = oldStdout

	// Read captured output
	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	// Verify results
	expectedPattern := "(?s)some.*pattern"
	assert.Equal(t, expectedPattern, result, "Expected pattern to remain %q, got %q", expectedPattern, result)

	expectedOutput := ""
	assert.Equal(t, expectedOutput, output, "Expected no output message, got %q", output)
}

// Malformed "!rep" pattern without proper parameters returns unchanged match
func TestMalformedRepPatternReturnsUnchanged(t *testing.T) {
	// Setup
	pattern := "!rep(somepattern)" // Malformed !rep pattern without count

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := "(?s)!rep(somepattern)"
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Nested placeholder patterns (e.g., "!rep(!num, 3)")
func TestNestedPlaceholderPatterns(t *testing.T) {
	// Setup
	pattern := "!rep(!num, 3)"

	// Execute function
	result := resolveRegexPlaceholders(pattern)

	// Verify results
	expectedPattern := `(?s)(-?\d*\.?\d+).*?(-?\d*\.?\d+).*?(-?\d*\.?\d+)`
	assert.Equal(t, expectedPattern, result, "Expected pattern to be %q, got %q", expectedPattern, result)
}

// Returns empty slice when input is empty
func TestDeduplicateGroupsWithEmptyInput(t *testing.T) {
	// Arrange
	var captureGroups []*CaptureGroup

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Empty(t, result, "Expected empty slice when input is empty")
}

// Input with all overlapping groups returns empty slice
func TestDeduplicateGroupsWithAllOverlappingGroups(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{
			Name:  "group1",
			Range: [2]int{10, 20},
		},
		{
			Name:  "group2",
			Range: [2]int{15, 25},
		},
		{
			Name:  "group3",
			Range: [2]int{5, 15},
		},
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Len(t, result, 1, "Expected only one group to remain after deduplication")
	assert.Equal(t, "group1", result[0].Name, "Expected first group to be kept")
}

// Successfully adds non-overlapping capture groups to result
func TestDeduplicateGroupsWithNonOverlappingInput(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{Name: "Group1", Range: [2]int{0, 5}},
		{Name: "Group2", Range: [2]int{6, 10}},
		{Name: "Group3", Range: [2]int{11, 15}},
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Equal(t, 3, len(result), "Expected all non-overlapping groups to be added")
	assert.Equal(t, "Group1", result[0].Name, "Expected Group1 to be in the result")
	assert.Equal(t, "Group2", result[1].Name, "Expected Group2 to be in the result")
	assert.Equal(t, "Group3", result[2].Name, "Expected Group3 to be in the result")
}

// Correctly identifies and filters out overlapping capture groups
func TestDeduplicateGroupsWithOverlappingInput(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{Name: "group1", Range: [2]int{0, 5}},
		{Name: "group2", Range: [2]int{3, 8}}, // Overlaps with group1
		{Name: "group3", Range: [2]int{10, 15}},
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Len(t, result, 2, "Expected two non-overlapping capture groups")
	assert.Equal(t, "group1", result[0].Name, "Expected group1 to be in the result")
	assert.Equal(t, "group3", result[1].Name, "Expected group3 to be in the result")
}

// Handles multiple non-overlapping groups correctly
func TestDeduplicateGroupsWithNonOverlappingGroups(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{Name: "Group1", Range: [2]int{0, 5}},
		{Name: "Group2", Range: [2]int{6, 10}},
		{Name: "Group3", Range: [2]int{11, 15}},
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Equal(t, 3, len(result), "Expected all groups to be included as they do not overlap")
	assert.Equal(t, "Group1", result[0].Name, "Expected Group1 to be the first in the result")
	assert.Equal(t, "Group2", result[1].Name, "Expected Group2 to be the second in the result")
	assert.Equal(t, "Group3", result[2].Name, "Expected Group3 to be the third in the result")
}

// Groups with identical ranges are considered overlapping
func TestDeduplicateGroupsWithIdenticalRanges(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{Name: "Group1", Range: [2]int{0, 5}},
		{Name: "Group2", Range: [2]int{0, 5}}, // Identical range to Group1
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Len(t, result, 1, "Expected only one group in the result due to identical ranges")
	assert.Equal(t, "Group1", result[0].Name, "Expected Group1 to be in the result")
}

// Groups with adjacent but non-overlapping ranges (end of one = start of another)
func TestDeduplicateGroupsWithAdjacentNonOverlappingRanges(t *testing.T) {
	// Arrange
	captureGroups := []*CaptureGroup{
		{Name: "Group1", Range: [2]int{0, 5}},
		{Name: "Group2", Range: [2]int{5, 10}},
		{Name: "Group3", Range: [2]int{10, 15}},
	}

	// Act
	result := deduplicateGroups(captureGroups)

	// Assert
	assert.Equal(t, 3, len(result), "Expected all groups to be included as they are adjacent but non-overlapping")
	assert.Equal(t, "Group1", result[0].Name, "Expected Group1 to be the first in the result")
	assert.Equal(t, "Group2", result[1].Name, "Expected Group2 to be the second in the result")
	assert.Equal(t, "Group3", result[2].Name, "Expected Group3 to be the third in the result")
}