// Text Rhai Test Runner
//
// This script runs all Text-related Rhai tests and reports results.

print("=== Text Rhai Test Suite ===");
print("Running comprehensive tests for Text Rhai integration...\n");

let total_tests = 0;
let passed_tests = 0;
let failed_tests = 0;

// Test 1: Text Indentation Functions
print("Test 1: Text Indentation Functions");
total_tests += 1;
try {
    let indented = "    line 1\n    line 2\n        line 3";
    let dedented = dedent(indented);
    
    let text = "line 1\nline 2";
    let prefixed = prefix(text, "> ");
    
    if dedented == "line 1\nline 2\n    line 3" && prefixed == "> line 1\n> line 2" {
        passed_tests += 1;
        print("✓ PASSED: Text indentation functions work correctly");
    } else {
        failed_tests += 1;
        print("✗ FAILED: Text indentation functions returned unexpected results");
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: Text indentation test failed - ${err}`);
}

// Test 2: String Normalization Functions
print("\nTest 2: String Normalization Functions");
total_tests += 1;
try {
    let unsafe_name = "User's File [Draft].txt";
    let safe_name = name_fix(unsafe_name);
    
    let unsafe_path = "/path/to/User's File.txt";
    let safe_path = path_fix(unsafe_path);
    
    if safe_name == "user_s_file_draft_.txt" && safe_path == "/path/to/user_s_file.txt" {
        passed_tests += 1;
        print("✓ PASSED: String normalization functions work correctly");
    } else {
        failed_tests += 1;
        print(`✗ FAILED: String normalization - expected 'user_s_file_draft_.txt' and '/path/to/user_s_file.txt', got '${safe_name}' and '${safe_path}'`);
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: String normalization test failed - ${err}`);
}

// Test 3: TextReplacer Builder Pattern
print("\nTest 3: TextReplacer Builder Pattern");
total_tests += 1;
try {
    let builder = text_replacer_new();
    builder = pattern(builder, "hello");
    builder = replacement(builder, "hi");
    builder = regex(builder, false);
    
    let replacer = build(builder);
    let result = replace(replacer, "hello world, hello universe");
    
    if result == "hi world, hi universe" {
        passed_tests += 1;
        print("✓ PASSED: TextReplacer builder pattern works correctly");
    } else {
        failed_tests += 1;
        print(`✗ FAILED: TextReplacer - expected 'hi world, hi universe', got '${result}'`);
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: TextReplacer builder test failed - ${err}`);
}

// Test 4: TextReplacer with Regex
print("\nTest 4: TextReplacer with Regex");
total_tests += 1;
try {
    let builder = text_replacer_new();
    builder = pattern(builder, "\\d+");
    builder = replacement(builder, "NUMBER");
    builder = regex(builder, true);
    
    let replacer = build(builder);
    let result = replace(replacer, "There are 123 items and 456 more");
    
    if result == "There are NUMBER items and NUMBER more" {
        passed_tests += 1;
        print("✓ PASSED: TextReplacer regex functionality works correctly");
    } else {
        failed_tests += 1;
        print(`✗ FAILED: TextReplacer regex - expected 'There are NUMBER items and NUMBER more', got '${result}'`);
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: TextReplacer regex test failed - ${err}`);
}

// Test 5: TextReplacer Chained Operations
print("\nTest 5: TextReplacer Chained Operations");
total_tests += 1;
try {
    let builder = text_replacer_new();
    builder = pattern(builder, "world");
    builder = replacement(builder, "universe");
    builder = regex(builder, false);
    builder = and(builder);
    builder = pattern(builder, "\\d+");
    builder = replacement(builder, "NUMBER");
    builder = regex(builder, true);
    
    let replacer = build(builder);
    let result = replace(replacer, "Hello world, there are 123 items");
    
    if result == "Hello universe, there are NUMBER items" {
        passed_tests += 1;
        print("✓ PASSED: TextReplacer chained operations work correctly");
    } else {
        failed_tests += 1;
        print(`✗ FAILED: TextReplacer chained - expected 'Hello universe, there are NUMBER items', got '${result}'`);
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: TextReplacer chained operations test failed - ${err}`);
}

// Test 6: Error Handling - Invalid Regex
print("\nTest 6: Error Handling - Invalid Regex");
total_tests += 1;
try {
    let builder = text_replacer_new();
    builder = pattern(builder, "[invalid regex");
    builder = replacement(builder, "test");
    builder = regex(builder, true);
    let replacer = build(builder);
    
    failed_tests += 1;
    print("✗ FAILED: Should have failed with invalid regex");
} catch(err) {
    passed_tests += 1;
    print("✓ PASSED: Invalid regex properly rejected");
}

// Test 7: Unicode Handling
print("\nTest 7: Unicode Handling");
total_tests += 1;
try {
    let unicode_text = "    Hello 世界\n    Goodbye 世界";
    let dedented = dedent(unicode_text);
    
    let unicode_name = "Café";
    let fixed_name = name_fix(unicode_name);
    
    let unicode_prefix = prefix("Hello 世界", "🔹 ");
    
    if dedented == "Hello 世界\nGoodbye 世界" && 
       fixed_name == "caf" && 
       unicode_prefix == "🔹 Hello 世界" {
        passed_tests += 1;
        print("✓ PASSED: Unicode handling works correctly");
    } else {
        failed_tests += 1;
        print("✗ FAILED: Unicode handling returned unexpected results");
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: Unicode handling test failed - ${err}`);
}

// Test 8: Edge Cases
print("\nTest 8: Edge Cases");
total_tests += 1;
try {
    let empty_dedent = dedent("");
    let empty_prefix = prefix("test", "");
    let empty_name_fix = name_fix("");
    
    if empty_dedent == "" && empty_prefix == "test" && empty_name_fix == "" {
        passed_tests += 1;
        print("✓ PASSED: Edge cases handled correctly");
    } else {
        failed_tests += 1;
        print("✗ FAILED: Edge cases returned unexpected results");
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: Edge cases test failed - ${err}`);
}

// Test 9: Complex Workflow
print("\nTest 9: Complex Text Processing Workflow");
total_tests += 1;
try {
    // Normalize filename
    let unsafe_filename = "User's Script [Draft].py";
    let safe_filename = name_fix(unsafe_filename);
    
    // Process code
    let indented_code = "    def hello():\n        print('Hello World')\n        return True";
    let dedented_code = dedent(indented_code);
    let commented_code = prefix(dedented_code, "# ");
    
    // Replace text
    let builder = text_replacer_new();
    builder = pattern(builder, "Hello World");
    builder = replacement(builder, "SAL Text");
    builder = regex(builder, false);
    
    let replacer = build(builder);
    let final_code = replace(replacer, commented_code);
    
    if safe_filename == "user_s_script_draft_.py" &&
       final_code.contains("# def hello():") && 
       final_code.contains("SAL Text") {
        passed_tests += 1;
        print("✓ PASSED: Complex workflow completed successfully");
    } else {
        failed_tests += 1;
        print("✗ FAILED: Complex workflow returned unexpected results");
    }
} catch(err) {
    failed_tests += 1;
    print(`✗ ERROR: Complex workflow test failed - ${err}`);
}

// Test 10: Template Builder Error Handling
print("\nTest 10: Template Builder Error Handling");
total_tests += 1;
try {
    let builder = template_builder_open("/nonexistent/file.txt");
    failed_tests += 1;
    print("✗ FAILED: Should have failed with nonexistent file");
} catch(err) {
    passed_tests += 1;
    print("✓ PASSED: Template builder properly handles nonexistent files");
}

// Print final results
print("\n=== Test Results ===");
print(`Total Tests: ${total_tests}`);
print(`Passed: ${passed_tests}`);
print(`Failed: ${failed_tests}`);

if failed_tests == 0 {
    print("\n✓ All tests passed!");
} else {
    print(`\n✗ ${failed_tests} test(s) failed.`);
}

print("\n=== Text Rhai Test Suite Completed ===");