use anyhow::Result;
use std::time::{Duration, Instant};

fn main() -> Result<()> {
    println!("=== FileTree Sled POC Performance Test ===\n");

    let user_id = "test_sled";

    println!("Step 1: Initialize Sled database...");
    let start = Instant::now();
    let tree = filetree_sled::FileTreeSled::init_user_db(user_id)?;
    let init_time = start.elapsed();
    println!("  ✓ Init time: {:?}", init_time);

    println!("\nStep 2: Insert 1,000 nodes (single insert)...");
    let nodes: Vec<filetree_sled::FileNode> = (0..1000)
        .map(|i| filetree_sled::FileTreeSled::new_folder(&format!("folder_{}", i), None))
        .collect();

    let start = Instant::now();
    for node in &nodes {
        tree.insert_node(node)?;
    }
    let single_insert_time = start.elapsed();
    let single_throughput = nodes.len() as f64 / single_insert_time.as_secs_f64();
    println!("  ✓ Single insert: {:?}", single_insert_time);
    println!("  ✓ Throughput: {:.2} nodes/sec", single_throughput);

    println!("\nStep 3: Insert 10,000 nodes (batch insert)...");
    let nodes_batch: Vec<filetree_sled::FileNode> = (0..10000)
        .map(|i| filetree_sled::FileTreeSled::new_folder(&format!("batch_folder_{}", i), None))
        .collect();

    tree.delete_all_nodes()?;

    let start = Instant::now();
    tree.insert_node_batch(&nodes_batch)?;
    let batch_insert_time = start.elapsed();
    let batch_throughput = nodes_batch.len() as f64 / batch_insert_time.as_secs_f64();
    println!("  ✓ Batch insert: {:?}", batch_insert_time);
    println!("  ✓ Throughput: {:.2} nodes/sec", batch_throughput);

    println!("\nStep 4: Query single node (10,000 iterations)...");
    let test_node_id = &nodes_batch[5000].node_id;
    let start = Instant::now();
    for _ in 0..10000 {
        let _ = tree.get_node(test_node_id)?;
    }
    let query_time = start.elapsed();
    let query_latency = query_time.as_nanos() as f64 / 10000.0;
    println!("  ✓ Total time: {:?}", query_time);
    println!("  ✓ Average latency: {:.2} ns", query_latency);

    println!("\nStep 5: Load all nodes...");
    let start = Instant::now();
    let all_nodes = tree.load_all()?;
    let load_time = start.elapsed();
    println!("  ✓ Load time: {:?}", load_time);
    println!("  ✓ Nodes loaded: {}", all_nodes.len());

    println!("\nStep 6: Concurrent reads (single process, 10 simulated threads)...");
    let db_path = filetree_sled::FileTreeSled::user_db_path(user_id);
    let start = Instant::now();

    for i in 0..10000 {
        let node_id = format!("batch_folder_{}", i % 1000);
        let _ = tree.get_node(&node_id)?;
    }

    let concurrent_time = start.elapsed();
    let concurrent_ops = 10000;
    let concurrent_throughput = concurrent_ops as f64 / concurrent_time.as_secs_f64();
    println!("  ✓ Concurrent time: {:?}", concurrent_time);
    println!("  ✓ Total ops: {}", concurrent_ops);
    println!("  ✓ Throughput: {:.2} ops/sec", concurrent_throughput);

    println!("\nStep 7: Database size...");
    let db_size = std::fs::metadata(&db_path)?.len();
    println!(
        "  ✓ DB size: {} bytes ({:.2} MB)",
        db_size,
        db_size as f64 / 1024.0 / 1024.0
    );
    println!("  ✓ Nodes count: {}", tree.count_nodes()?);

    println!("\n=== Performance Summary ===");
    println!(
        "Single insert: {:?} ({:.2} nodes/sec)",
        single_insert_time, single_throughput
    );
    println!(
        "Batch insert: {:?} ({:.2} nodes/sec)",
        batch_insert_time, batch_throughput
    );
    println!("Query latency: {:.2} ns", query_latency);
    println!("Concurrent reads: {:.2} ops/sec", concurrent_throughput);
    println!("DB size: {:.2} MB", db_size as f64 / 1024.0 / 1024.0);

    println!("\nStep 8: Cleanup...");
    std::fs::remove_dir_all(&db_path)?;
    println!("  ✓ Test database removed");

    println!("\n✅ POC Test completed successfully!");

    Ok(())
}