rag-module 0.6.7

//! Example demonstrating the delete collection functionality
//! 
//! This example shows how to:
//! 1. Create a test collection with documents
//! 2. List the generated files
//! 3. Delete the collection and all associated files
//! 4. Verify the cleanup

use anyhow::Result;
use rag_module::RagModule;

#[tokio::main]
async fn main() -> Result<()> {
    println!("🗑️ Testing Collection Deletion Functionality\n");

    let base_path = "./batch-test-data";
    let user_id = "delete_test_user";
    let collection_name = "test_collection_to_delete";

    // Initialize RAG module
    let rag = RagModule::new(base_path).await?;
    rag.initialize().await?;

    println!("📂 Step 1: Creating a test collection with sample data...");
    
    // Create some test documents for batch ingestion
    let test_data = vec![
        serde_json::json!({
            "content": "Test EC2 instance for deletion demo",
            "resource_type": "ec2_instance",
            "instance_id": "i-test123"
        }),
        serde_json::json!({
            "content": "Test S3 bucket for deletion demo", 
            "resource_type": "s3_bucket",
            "bucket_name": "test-delete-bucket"
        }),
        serde_json::json!({
            "content": "Test RDS database for deletion demo",
            "resource_type": "rds_instance", 
            "db_identifier": "test-delete-db"
        })
    ];

    // Ingest test data
    let _ingest_result = rag.ingest_aws_estate_batch(test_data, user_id, collection_name).await?;
    println!("✅ Created test collection with 3 documents");

    // List generated files before deletion
    println!("\n📋 Step 2: Listing generated files before deletion...");
    let user_path = std::path::Path::new(base_path).join("qdrant-data").join(user_id);
    
    if user_path.exists() {
        println!("📁 Files in user directory:");
        let mut entries = tokio::fs::read_dir(&user_path).await?;
        while let Some(entry) = entries.next_entry().await? {
            if let Some(name) = entry.file_name().to_str() {
                if name.starts_with(collection_name) {
                    let metadata = entry.metadata().await?;
                    println!("   📄 {} ({} bytes)", name, metadata.len());
                }
            }
        }
    }

    // Set user context and delete the collection
    println!("\n🗑️ Step 3: Deleting collection '{}'...", collection_name);
    rag.set_user_context(user_id).await?;
    
    let delete_result = rag.delete_collection(collection_name, user_id).await?;

    // Display deletion results
    println!("\n📊 Deletion Results:");
    println!("════════════════════════════════════");
    println!("Collection: {}", delete_result.collection_name);
    println!("User ID: {}", delete_result.user_id);
    println!("Collection deleted: {}", if delete_result.collection_deleted { "✅ Yes" } else { "❌ No" });
    println!("Files removed: {}", delete_result.files_removed);
    
    if !delete_result.removed_files.is_empty() {
        println!("Removed files:");
        for file in &delete_result.removed_files {
            println!("   🗑️ {}", file);
        }
    }

    if !delete_result.errors.is_empty() {
        println!("⚠️ Errors encountered:");
        for error in &delete_result.errors {
            println!("   ❌ {}", error);
        }
    }

    // Verify cleanup
    println!("\n🔍 Step 4: Verifying cleanup...");
    
    if user_path.exists() {
        let mut remaining_files = Vec::new();
        let mut entries = tokio::fs::read_dir(&user_path).await?;
        while let Some(entry) = entries.next_entry().await? {
            if let Some(name) = entry.file_name().to_str() {
                if name.starts_with(collection_name) {
                    remaining_files.push(name.to_string());
                }
            }
        }
        
        if remaining_files.is_empty() {
            println!("✅ All collection files have been removed");
        } else {
            println!("⚠️ Some files remain:");
            for file in remaining_files {
                println!("   📄 {}", file);
            }
        }
    } else {
        println!("✅ User directory has been cleaned up");
    }

    // Test trying to delete a non-existent collection
    println!("\n🧪 Step 5: Testing deletion of non-existent collection...");
    let non_existent_result = rag.delete_collection("non_existent_collection", user_id).await?;
    
    println!("Non-existent collection deletion:");
    println!("   Files removed: {}", non_existent_result.files_removed);
    println!("   Errors: {}", non_existent_result.errors.len());
    
    if non_existent_result.errors.is_empty() {
        println!("   ✅ No errors (as expected for non-existent collection)");
    }

    println!("\n🎉 Collection deletion demo completed!");
    println!("\n💡 Usage in your code:");
    println!("```rust");
    println!("let result = rag.delete_collection(\"collection_name\", \"user_id\").await?;");
    println!("if result.is_successful() {{");
    println!("    println!(\"Successfully deleted collection with {{}} files\", result.files_removed);");
    println!("}} else if result.has_partial_success() {{");
    println!("    println!(\"Partial deletion: {{}} errors\", result.errors.len());");
    println!("}} else {{");
    println!("    println!(\"Deletion failed\");");
    println!("}}");
    println!("```");

    Ok(())
}