#!/usr/bin/env rhai

// Test 3: PCRE Pattern Matching for Bulk Operations
// This test covers the powerful pattern-based deletion functionality

// Helper function to generate timestamp for unique names
fn timestamp() {
    let now = 1640995200; // Base timestamp
    let random = (now % 1000000).to_string();
    random
}

print("=== Kubernetes PCRE Pattern Matching Test ===");
print("");

// Setup test namespace
let test_namespace = "sal-test-patterns-" + timestamp();
print("Setting up test namespace: " + test_namespace);

try {
    let setup_km = kubernetes_manager_new("default");
    setup_km.create_namespace(test_namespace);
    print("✅ Test namespace created");
} catch (error) {
    print("❌ Failed to create test namespace: " + error);
    throw error;
}

// Create manager for test namespace
let km = kubernetes_manager_new(test_namespace);

print("");

// Create multiple test resources with different naming patterns
print("Test 1: Creating Test Resources");
print("------------------------------");

let test_resources = [
    "test-app-frontend",
    "test-app-backend", 
    "test-app-database",
    "prod-app-frontend",
    "prod-app-backend",
    "staging-service",
    "dev-service",
    "temp-worker-1",
    "temp-worker-2",
    "permanent-service"
];

try {
    print("Creating " + test_resources.len() + " test pods...");
    
    for resource_name in test_resources {
        let labels = #{
            "app": resource_name,
            "test": "pattern-matching",
            "created-by": "sal-integration-test"
        };
        
        km.create_pod(resource_name, "nginx:alpine", labels);
        print("  ✅ Created: " + resource_name);
    }
    
    print("✅ All test resources created");
    
} catch (error) {
    print("❌ Test resource creation failed: " + error);
    throw error;
}

print("");

// Verify all resources exist
print("Test 2: Verify Resource Creation");
print("--------------------------------");

try {
    let all_pods = km.pods_list();
    print("Total pods created: " + all_pods.len());
    
    if all_pods.len() >= test_resources.len() {
        print("✅ Expected number of pods found");
    } else {
        print("❌ Missing pods. Expected: " + test_resources.len() + ", Found: " + all_pods.len());
        throw "Resource verification failed";
    }
    
    // List all pod names for verification
    print("Created pods:");
    for pod in all_pods {
        print("  - " + pod.name);
    }
    
} catch (error) {
    print("❌ Resource verification failed: " + error);
    throw error;
}

print("");

// Test pattern matching - delete all "test-app-*" resources
print("Test 3: Pattern Deletion - test-app-*");
print("--------------------------------------");

try {
    let pattern = "test-app-.*";
    print("Deleting resources matching pattern: " + pattern);
    
    // Count pods before deletion
    let pods_before = km.pods_list();
    let count_before = pods_before.len();
    print("Pods before deletion: " + count_before);
    
    // Perform pattern deletion
    km.delete(pattern);
    print("✅ Pattern deletion executed");
    
    // Wait for deletion to propagate
    print("Waiting for deletion to propagate...");
    
    // Count pods after deletion
    let pods_after = km.pods_list();
    let count_after = pods_after.len();
    print("Pods after deletion: " + count_after);
    
    // Should have deleted 3 pods (test-app-frontend, test-app-backend, test-app-database)
    let expected_deleted = 3;
    let actual_deleted = count_before - count_after;
    
    if actual_deleted >= expected_deleted {
        print("✅ Pattern deletion successful. Deleted " + actual_deleted + " pods");
    } else {
        print("⚠️  Pattern deletion may still be propagating. Expected to delete " + expected_deleted + ", deleted " + actual_deleted);
    }
    
    // Verify specific pods are gone
    print("Remaining pods:");
    for pod in pods_after {
        print("  - " + pod.name);
        
        // Check that no test-app-* pods remain
        if pod.name.starts_with("test-app-") {
            print("❌ Found test-app pod that should have been deleted: " + pod.name);
        }
    }
    
} catch (error) {
    print("❌ Pattern deletion test failed: " + error);
    throw error;
}

print("");

// Test more specific pattern - delete all "temp-*" resources
print("Test 4: Pattern Deletion - temp-*");
print("----------------------------------");

try {
    let pattern = "temp-.*";
    print("Deleting resources matching pattern: " + pattern);
    
    // Count pods before deletion
    let pods_before = km.pods_list();
    let count_before = pods_before.len();
    print("Pods before deletion: " + count_before);
    
    // Perform pattern deletion
    km.delete(pattern);
    print("✅ Pattern deletion executed");
    
    // Wait for deletion to propagate
    print("Waiting for deletion to propagate...");
    
    // Count pods after deletion
    let pods_after = km.pods_list();
    let count_after = pods_after.len();
    print("Pods after deletion: " + count_after);
    
    // Should have deleted 2 pods (temp-worker-1, temp-worker-2)
    let expected_deleted = 2;
    let actual_deleted = count_before - count_after;
    
    if actual_deleted >= expected_deleted {
        print("✅ Pattern deletion successful. Deleted " + actual_deleted + " pods");
    } else {
        print("⚠️  Pattern deletion may still be propagating. Expected to delete " + expected_deleted + ", deleted " + actual_deleted);
    }
    
} catch (error) {
    print("❌ Temp pattern deletion test failed: " + error);
    throw error;
}

print("");

// Test complex pattern - delete all "*-service" resources
print("Test 5: Pattern Deletion - *-service");
print("------------------------------------");

try {
    let pattern = ".*-service$";
    print("Deleting resources matching pattern: " + pattern);
    
    // Count pods before deletion
    let pods_before = km.pods_list();
    let count_before = pods_before.len();
    print("Pods before deletion: " + count_before);
    
    // Perform pattern deletion
    km.delete(pattern);
    print("✅ Pattern deletion executed");
    
    // Wait for deletion to propagate
    print("Waiting for deletion to propagate...");
    
    // Count pods after deletion
    let pods_after = km.pods_list();
    let count_after = pods_after.len();
    print("Pods after deletion: " + count_after);
    
    // Should have deleted service pods (staging-service, dev-service, permanent-service)
    let actual_deleted = count_before - count_after;
    print("✅ Pattern deletion executed. Deleted " + actual_deleted + " pods");
    
} catch (error) {
    print("❌ Service pattern deletion test failed: " + error);
    throw error;
}

print("");

// Test safety - verify remaining resources
print("Test 6: Verify Remaining Resources");
print("----------------------------------");

try {
    let remaining_pods = km.pods_list();
    print("Remaining pods: " + remaining_pods.len());
    
    print("Remaining pod names:");
    for pod in remaining_pods {
        print("  - " + pod.name);
    }
    
    // Should only have prod-app-* pods remaining
    let expected_remaining = ["prod-app-frontend", "prod-app-backend"];
    
    for pod in remaining_pods {
        let is_expected = false;
        for expected in expected_remaining {
            if pod.name == expected {
                is_expected = true;
                break;
            }
        }
        
        if is_expected {
            print("✅ Expected pod remains: " + pod.name);
        } else {
            print("⚠️  Unexpected pod remains: " + pod.name);
        }
    }
    
} catch (error) {
    print("❌ Remaining resources verification failed: " + error);
    throw error;
}

print("");

// Cleanup
print("Test 7: Cleanup");
print("---------------");

try {
    let cleanup_km = kubernetes_manager_new("default");
    cleanup_km.delete_namespace(test_namespace);
    print("✅ Test namespace cleanup initiated");
    
} catch (error) {
    print("❌ Cleanup failed: " + error);
    // Don't throw here as this is cleanup
}

print("");
print("=== PCRE Pattern Matching Test Complete ===");
print("✅ All pattern matching tests passed");
print("");
print("⚠️  IMPORTANT: Pattern deletion is a powerful feature!");
print("   Always test patterns in safe environments first.");
print("   Use specific patterns to avoid accidental deletions.");