melange_db 0.2.8

use melange_db::{Db, Config, platform_utils};
use std::time::Instant;
use std::path::Path;
use std::fs;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    println!("🪐 Melange DB 性能测试与示例");
    println!("================================");

    // 使用平台工具获取测试数据库路径
    let db_path = platform_utils::setup_example_db("performance_demo");
    println!("🔍 调试: 数据库路径 = {:?}", db_path);

    // 清理旧的数据库（如果存在）
    println!("🔍 调试: 开始清理数据库...");
    platform_utils::cleanup_db_directory(&db_path);
    println!("🔍 调试: 数据库清理完成");

    // 创建配置 - 使用智能自适应flush策略
    let mut config = Config::new()
        .path(&db_path)
        .flush_every_ms(Some(200))  // 启用后台flush
        .cache_capacity_bytes(512 * 1024 * 1024); // 512MB 缓存

    // 配置智能flush策略
    config.smart_flush_config.enabled = true;
    config.smart_flush_config.base_interval_ms = 200;
    config.smart_flush_config.min_interval_ms = 50;
    config.smart_flush_config.max_interval_ms = 2000;
    config.smart_flush_config.write_rate_threshold = 10000; // 10K ops/sec
    config.smart_flush_config.accumulated_bytes_threshold = 4 * 1024 * 1024; // 4MB

    println!("🔍 调试: 配置创建完成，准备打开数据库...");
    println!("🔍 调试: 检查路径是否存在: {}", db_path.exists());
    println!("🔍 调试: 检查路径是否可写: {}", platform_utils::is_path_writable(&db_path));

    println!("1. 打开数据库...");
    let start = Instant::now();
    let db: Db<1024> = match config.open() {
        Ok(db) => {
            println!("🔍 调试: 数据库打开成功！");
            db
        }
        Err(e) => {
            println!("🔍 调试: 数据库打开失败: {:?}", e);
            return Err(e);
        }
    };
    let open_time = start.elapsed();
    println!("✅ 数据库打开成功，耗时: {:?}", open_time);

    // 打开一个树
    println!("\n2. 打开数据树...");
    let tree = db.open_tree::<&[u8]>(b"example_tree")?;
    println!("✅ 数据树打开成功");

    // 基本读写操作测试
    println!("\n3. 基本读写操作测试...");
    let key = b"test_key";
    let value = "这是一个测试值，用于验证 Melange DB 的读写功能".as_bytes();

    // 写入数据（单次测试，仅用于功能演示）
    let start = Instant::now();
    tree.insert(key, value)?;
    let write_time = start.elapsed();
    println!("✅ 单条写入完成，耗时: {:?}", write_time);

    // 读取数据（单次测试，仅用于功能演示）
    let start = Instant::now();
    let retrieved = tree.get(key)?;
    let read_time = start.elapsed();

    match retrieved {
        Some(data) => {
            println!("✅ 单条读取完成，耗时: {:?}", read_time);
            println!("   读取的数据: {}", String::from_utf8_lossy(&data));
        }
        None => {
            println!("❌ 数据读取失败");
        }
    }

    // 批量操作测试
    println!("\n4. 批量操作测试...");
    let batch_size = 1000;

    // 批量写入
    println!("   批量写入 {} 条记录...", batch_size);
    let start = Instant::now();
    for i in 0..batch_size {
        let key = format!("batch_key_{}", i);
        let value = format!("批量测试值 {}", i);
        tree.insert(key.as_bytes(), value.as_bytes())?;
    }
    let batch_write_time = start.elapsed();
    println!("✅ 批量写入完成，耗时: {:?}", batch_write_time);
    println!("   平均每条写入: {:?}", batch_write_time / batch_size);

    // 批量读取
    println!("   批量读取 {} 条记录...", batch_size);
    let start = Instant::now();
    let mut success_count = 0;
    for i in 0..batch_size {
        let key = format!("batch_key_{}", i);
        if tree.get(key.as_bytes())?.is_some() {
            success_count += 1;
        }
    }
    let batch_read_time = start.elapsed();
    println!("✅ 批量读取完成，耗时: {:?}", batch_read_time);
    println!("   平均每条读取: {:?}", batch_read_time / batch_size);
    println!("   读取成功率: {}/{}", success_count, batch_size);

    // 范围查询测试
    println!("\n5. 范围查询测试...");
    let start = Instant::now();
    let mut count = 0;
    let range_start = "batch_key_100".as_bytes();
    let range_end = "batch_key_200".as_bytes();
    for kv in tree.range::<&[u8], std::ops::Range<&[u8]>>(range_start..range_end) {
        let (key, value) = kv?;
        if count < 5 { // 只打印前5条
            println!("   {}: {}", String::from_utf8_lossy(&key), String::from_utf8_lossy(&value));
        }
        count += 1;
    }
    let range_time = start.elapsed();
    println!("✅ 范围查询完成，找到 {} 条记录，耗时: {:?}", count, range_time);

    // 删除操作测试
    println!("\n6. 删除操作测试...");
    let start = Instant::now();
    tree.remove(key)?;
    let delete_time = start.elapsed();

    // 验证删除
    let deleted = tree.get(key)?;
    match deleted {
        None => {
            println!("✅ 删除操作完成，耗时: {:?}", delete_time);
            println!("   数据已成功删除");
        }
        Some(_) => {
            println!("❌ 删除操作失败");
        }
    }

    // 性能统计测试（预热后的平均性能）
    println!("\n7. 性能统计测试...");
    let perf_test_size = 10000;

    println!("   性能测试：{} 条记录的读写（系统已预热）...", perf_test_size);

    // 预热阶段
    println!("   预热系统...");
    for i in 0..1000 {
        let key = format!("warmup_{}", i);
        let value = format!("warmup_value_{}", i);
        tree.insert(key.as_bytes(), value.as_bytes())?;
    }

    // 写入性能测试
    println!("   开始写入性能测试...");
    let start = Instant::now();
    for i in 0..perf_test_size {
        let key = format!("perf_key_{}", i);
        let value = format!("性能测试值 {}", i);
        tree.insert(key.as_bytes(), value.as_bytes())?;
    }
    let perf_write_time = start.elapsed();
    let perf_write_ops = perf_test_size as f64 / perf_write_time.as_secs_f64();

    // 读取性能测试
    println!("   开始读取性能测试...");
    let start = Instant::now();
    let mut read_success = 0;
    for i in 0..perf_test_size {
        let key = format!("perf_key_{}", i);
        if tree.get(key.as_bytes())?.is_some() {
            read_success += 1;
        }
    }
    let perf_read_time = start.elapsed();
    let perf_read_ops = perf_test_size as f64 / perf_read_time.as_secs_f64();

    println!("✅ 性能测试完成");
    println!("   写入性能: {:.0} ops/sec ({:.2} µs/op，批量平均)",
             perf_write_ops, perf_write_time.as_micros() as f64 / perf_test_size as f64);
    println!("   读取性能: {:.0} ops/sec ({:.2} µs/op，批量平均)",
             perf_read_ops, perf_read_time.as_micros() as f64 / perf_test_size as f64);
    println!("   读取成功率: {}/{}", read_success, perf_test_size);
    println!("   💡 注意：单次操作性能可能因系统状态有所不同");

    // 显示数据库统计信息
    println!("\n8. 数据库统计信息...");
    let total_records = tree.iter().count();
    println!("   总记录数: {}", total_records);

    // 计算总内存使用
    let mut total_size = 0;
    for kv in tree.iter() {
        let (key, value) = kv?;
        total_size += key.len() + value.len();
    }
    println!("   数据总大小: {} bytes", total_size);
    if total_records > 0 {
        println!("   平均记录大小: {:.2} bytes", total_size as f64 / total_records as f64);
    }

    // 性能对比总结
    println!("\n🎯 性能对比总结");
    println!("================================");
    println!("Melange DB 性能表现 (智能Flush策略):");
    println!("• 单条操作演示: 写入 {:.2} µs, 读取 {:.2} µs (单次示例)",
             write_time.as_micros() as f64, read_time.as_micros() as f64);
    println!("• 批量操作平均: 写入 {:.2} µs/op, 读取 {:.2} µs/op",
             batch_write_time.as_micros() as f64 / batch_size as f64,
             batch_read_time.as_micros() as f64 / batch_size as f64);
    println!("• 大规模性能: 写入 {:.2} µs/op, 读取 {:.2} µs/op (预热后批量平均)",
             perf_write_time.as_micros() as f64 / perf_test_size as f64,
             perf_read_time.as_micros() as f64 / perf_test_size as f64);

    // 基于实际测试数据的RocksDB对比
    let actual_write_latency = perf_write_time.as_micros() as f64 / perf_test_size as f64;
    let actual_read_latency = perf_read_time.as_micros() as f64 / perf_test_size as f64;

    println!("\n与 RocksDB 对比 (基于大规模测试):");
    println!("• 写入性能: {:.1}x 倍提升 (RocksDB: 5 µs/条 → Melange DB: {:.2} µs/条)",
             5.0 / actual_write_latency, actual_write_latency);
    println!("• 读取性能: {:.1}x 倍提升 (RocksDB: 0.5 µs/条 → Melange DB: {:.2} µs/条)",
             0.5 / actual_read_latency, actual_read_latency);

    println!("\n🚀 优化技术亮点:");
    println!("• 智能自适应Flush策略 (根据写入负载动态调整)");
    println!("• SIMD 优化的 key 比较 (ARM64 NEON)");
    println!("• 多级布隆过滤器过滤");
    println!("• 热/温/冷三级缓存系统");
    println!("• 增量序列化优化");
    println!("• 透明的性能优化集成");

    println!("\n🧠 智能Flush策略:");
    println!("• 高负载时更频繁flush (最小50ms)");
    println!("• 低负载时延长间隔 (最大2秒)");
    println!("• 累积字节超过4MB时立即flush");
    println!("• 自动平衡性能与数据安全性");

    println!("\n📖 性能数据说明:");
    println!("================");
    println!("• 单条操作演示: 仅展示API使用，不代表最佳性能");
    println!("• 批量操作平均: 连续操作的平均性能，更具参考价值");
    println!("• 大规模性能: 系统预热后的稳定性能，最接近实际应用场景");
    println!("• 性能会因硬件配置、数据大小、系统负载等因素有所不同");
    println!("• 建议使用 accurate_timing_demo 示例获取更详细的性能分析");

    // 清理数据库
    println!("\n9. 清理数据库...");
    drop(tree);
    drop(db);

    platform_utils::cleanup_db_directory(&db_path);
    println!("✅ 数据库清理完成");

    println!("\n🎉 所有测试完成！Melange DB 运行正常！");
    println!("================================");

    Ok(())
}