wedb_embed 0.1.0

use aok::Void;
use tempfile::tempdir;
use wedb_embed::{
    BlockSplitBloomFilter, BloomChainMeta, BloomFilterAddResult, BloomFilterInsertOptions,
    CuckooChainMeta, CuckooFilterHelper, CuckooFilterInsertOptions, WeDb,
};

#[ctor::ctor(unsafe)]
fn _log_init() {
    log_init::init();
}

#[test]
fn test_block_split_bloom_math_and_filter() -> Void {
    // 验证最优位与字节计算（对标 Kvrocks OptimalNumOfBits/Bytes）
    let bits_1000 = BlockSplitBloomFilter::optimal_num_of_bits(1000, 0.01);
    assert!(bits_1000.is_power_of_two());
    assert!(bits_1000 >= 32 * 8);

    let bytes_1000 = BlockSplitBloomFilter::optimal_num_of_bytes(1000, 0.01);
    assert_eq!(bytes_1000, bits_1000 / 8);

    // 单块 32 字节测试
    let mut data = vec![0u8; 32];
    let h1 = BlockSplitBloomFilter::hash(b"hello");
    let h2 = BlockSplitBloomFilter::hash(b"world");

    assert!(!BlockSplitBloomFilter::find_hash(&data, h1));
    assert!(!BlockSplitBloomFilter::find_hash(&data, h2));

    BlockSplitBloomFilter::insert_hash(&mut data, h1);
    assert!(BlockSplitBloomFilter::find_hash(&data, h1));
    assert!(!BlockSplitBloomFilter::find_hash(&data, h2));

    BlockSplitBloomFilter::insert_hash(&mut data, h2);
    assert!(BlockSplitBloomFilter::find_hash(&data, h1));
    assert!(BlockSplitBloomFilter::find_hash(&data, h2));

    Ok(())
}

#[test]
fn test_bloom_chain_metadata_codec_and_capacity() -> Void {
    let meta = BloomChainMeta::new(100, 0.01, 2, 1, 1000, 256);
    assert_eq!(meta.get_capacity(), 100);
    assert!(meta.is_scaling());

    let encoded = meta.encode();
    assert_eq!(encoded.len(), BloomChainMeta::ENCODED_SIZE);

    let decoded = BloomChainMeta::decode(&encoded).expect("decode failed");
    assert_eq!(decoded.base_capacity, 100);
    assert_eq!(decoded.error_rate, 0.01);
    assert_eq!(decoded.expansion, 2);
    assert_eq!(decoded.n_filters, 1);
    assert_eq!(decoded.bloom_bytes, 256);

    // 非扩容模式
    let non_scaling_meta = BloomChainMeta::new(500, 0.01, 0, 1, 0, 512);
    assert!(!non_scaling_meta.is_scaling());
    assert_eq!(non_scaling_meta.get_capacity(), 500);

    Ok(())
}

#[test]
fn test_bloom_reserve_add_exists_info_scaling() -> Void {
    let dir = tempdir()?;
    let db = WeDb::open(dir.path())?;

    // BF.RESERVE
    db.bf_reserve("bfkey", 0.01, 1000, 2)?;
    assert!(db.bf_reserve("bfkey", 0.01, 1000, 2).is_err());

    // BF.ADD & BF.EXISTS
    assert!(db.bf_add("bfkey", "item1")?);
    assert!(!db.bf_add("bfkey", "item1")?);

    assert!(db.bf_exists("bfkey", "item1")?);
    assert!(!db.bf_exists("bfkey", "item2")?);

    // BF.MADD & BF.MEXISTS
    let madd_res = db.bf_madd("bfkey", &["item2", "item3"])?;
    assert_eq!(madd_res, vec![true, true]);

    let mex_res = db.bf_mexists("bfkey", &["item1", "item2", "item4"])?;
    assert_eq!(mex_res, vec![true, true, false]);

    // BF.INFO & BF.CARD
    let info = db.bf_info("bfkey")?;
    assert_eq!(info.n_filters, 1);
    assert_eq!(info.size, 3);
    assert_eq!(db.bf_card("bfkey")?, 3);

    // 自动扩容 (Scaling) 测试
    let dir_scale = tempdir()?;
    let db_scale = WeDb::open(dir_scale.path())?;
    db_scale.bf_reserve("bf_scale", 0.01, 5, 2)?;

    for i in 0..15 {
        let item = format!("item_{i}");
        assert!(db_scale.bf_add("bf_scale", item)?);
    }

    let scale_info = db_scale.bf_info("bf_scale")?;
    assert!(scale_info.n_filters > 1);
    assert_eq!(scale_info.size, 15);

    for i in 0..15 {
        let item = format!("item_{i}");
        assert!(db_scale.bf_exists("bf_scale", item)?);
    }

    // 非扩容满过滤器 (Non-scaling full) 测试
    let dir_fixed = tempdir()?;
    let db_fixed = WeDb::open(dir_fixed.path())?;
    db_fixed.bf_reserve("bf_fixed", 0.01, 3, 0)?;

    for i in 0..3 {
        let item = format!("elem_{i}");
        assert!(db_fixed.bf_add("bf_fixed", item)?);
    }
    // 超过容量应报错 Full
    assert!(db_fixed.bf_add("bf_fixed", "elem_overflow").is_err());

    Ok(())
}

#[test]
fn test_cuckoo_filter_helper_and_meta() -> Void {
    // 桶计算测试
    let req_buckets = CuckooFilterHelper::calculate_required_buckets(1000, 2)?;
    assert!(req_buckets.is_power_of_two());

    // 指纹与异或哈希测试
    let hash = CuckooFilterHelper::hash(b"test_item");
    let fp = CuckooFilterHelper::generate_fingerprint(hash);
    assert_ne!(fp, 0);

    let alt_hash = CuckooFilterHelper::get_alt_hash(fp, hash);
    let original_hash = CuckooFilterHelper::get_alt_hash(fp, alt_hash);
    assert_eq!(hash, original_hash); // 异或对称性

    let num_buckets = 64u32;
    let b1 = (hash % (num_buckets as u64)) as u32;
    let b2 = CuckooFilterHelper::get_alt_bucket_index(b1, fp, num_buckets);
    let b1_recovered = CuckooFilterHelper::get_alt_bucket_index(b2, fp, num_buckets);
    assert_eq!(b1, b1_recovered);

    // 元数据编码/解码测试
    let meta = CuckooChainMeta::new(1024, 2, 20, 1, 2048, 1, 0);
    assert_eq!(meta.get_total_capacity(), 1024);
    assert!(meta.is_scaling());

    let encoded = meta.encode();
    assert_eq!(encoded.len(), CuckooChainMeta::ENCODED_SIZE);

    let decoded = CuckooChainMeta::decode(&encoded).expect("cuckoo decode failed");
    assert_eq!(decoded.base_capacity, 1024);
    assert_eq!(decoded.bucket_size, 2);
    assert_eq!(decoded.max_iterations, 20);
    assert_eq!(decoded.expansion, 1);
    assert_eq!(decoded.page_size, 2048);

    Ok(())
}

#[test]
fn test_cuckoo_filter_crud_and_kickout() -> Void {
    let dir = tempdir()?;
    let db = WeDb::open(dir.path())?;

    // CF.RESERVE
    db.cf_reserve("cfkey", 1000, 2, 20, 1)?;
    assert!(db.cf_reserve("cfkey", 1000, 2, 20, 1).is_err());

    // CF.ADD & CF.EXISTS
    assert!(db.cf_add("cfkey", "alpha")?);
    assert!(db.cf_add("cfkey", "beta")?);
    assert!(db.cf_exists("cfkey", "alpha")?);
    assert!(db.cf_exists("cfkey", "beta")?);
    assert!(!db.cf_exists("cfkey", "gamma")?);

    // CF.ADDNX
    assert!(!db.cf_addnx("cfkey", "alpha")?);
    assert!(db.cf_addnx("cfkey", "gamma")?);
    assert!(db.cf_exists("cfkey", "gamma")?);

    // CF.COUNT & 重复项
    assert_eq!(db.cf_count("cfkey", "alpha")?, 1);
    assert!(db.cf_add("cfkey", "alpha")?);
    assert_eq!(db.cf_count("cfkey", "alpha")?, 2);

    // CF.DEL
    assert!(db.cf_del("cfkey", "alpha")?);
    assert_eq!(db.cf_count("cfkey", "alpha")?, 1);
    assert!(db.cf_del("cfkey", "alpha")?);
    assert_eq!(db.cf_count("cfkey", "alpha")?, 0);
    assert!(!db.cf_exists("cfkey", "alpha")?);
    assert!(!db.cf_del("cfkey", "alpha")?);

    // CF.MEXISTS
    let mex = db.cf_mexists("cfkey", &["alpha", "beta", "gamma", "delta"])?;
    assert_eq!(mex, vec![false, true, true, false]);

    // CF.INFO
    let info = db.cf_info("cfkey")?;
    assert_eq!(info.bucket_size, 2);
    assert_eq!(info.num_filters, 1);
    assert_eq!(info.num_items_deleted, 2);
    assert_eq!(info.size, 2); // beta, gamma

    // 踢出算法与扩容测试
    let dir_dense = tempdir()?;
    let db_dense = WeDb::open(dir_dense.path())?;
    db_dense.cf_reserve("cf_dense", 16, 2, 20, 2)?;

    for i in 0..50 {
        let item = format!("dense_item_{i}");
        assert!(db_dense.cf_add("cf_dense", item)?);
    }

    for i in 0..50 {
        let item = format!("dense_item_{i}");
        assert!(db_dense.cf_exists("cf_dense", item)?);
    }

    let dense_info = db_dense.cf_info("cf_dense")?;
    assert!(dense_info.num_filters > 1);
    assert_eq!(dense_info.size, 50);

    // CF.INSERT & CF.INSERTNX 测试
    let ins_res = db_dense.cf_insert(
        "cf_ins",
        &["one", "two"],
        &CuckooFilterInsertOptions::default(),
    )?;
    assert_eq!(ins_res, vec![true, true]);

    let nx_res = db_dense.cf_insertnx(
        "cf_ins",
        &["one", "three"],
        &CuckooFilterInsertOptions::default(),
    )?;
    assert_eq!(nx_res, vec![false, true]);

    // BF.INSERT 测试
    let bf_ins_res = db.bf_insert(
        "bf_custom_ins",
        &["x", "y"],
        &BloomFilterInsertOptions {
            capacity: 500,
            error_rate: 0.001,
            expansion: 2,
            auto_create: true,
        },
    )?;
    assert_eq!(
        bf_ins_res,
        vec![BloomFilterAddResult::Ok, BloomFilterAddResult::Ok]
    );

    Ok(())
}

#[test]
fn test_bloom_edge_cases_and_insert_options() -> Void {
    let dir = tempdir()?;
    let db = WeDb::open(dir.path())?;

    // 边界条件：无效容量与错误率
    assert!(db.bf_reserve("err_k", 0.01, 0, 2).is_err());
    assert!(db.bf_reserve("err_k", 0.0, 100, 2).is_err());
    assert!(db.bf_reserve("err_k", 1.0, 100, 2).is_err());
    assert!(db.bf_reserve("err_k", -0.5, 100, 2).is_err());

    // 空 items 测试
    let empty_items: &[&str] = &[];
    let empty_res = db.bf_insert(
        "bf_empty",
        empty_items,
        &BloomFilterInsertOptions::default(),
    )?;
    assert!(empty_res.is_empty());

    // BF.INSERT NOCREATE 对不存在的 key 应报错
    assert!(
        db.bf_insert(
            "bf_nocreate",
            &["item1"],
            &BloomFilterInsertOptions {
                auto_create: false,
                ..Default::default()
            }
        )
        .is_err()
    );

    // BF.CARD 对不存在的 key 返回 0
    assert_eq!(db.bf_card("non_existent_bf")?, 0);

    // BF.EXISTS 对不存在的 key 返回 false
    assert!(!db.bf_exists("non_existent_bf", "foo")?);
    let mex = db.bf_mexists("non_existent_bf", &["a", "b"])?;
    assert_eq!(mex, vec![false, false]);

    // BF.INFO 对不存在的 key 返回 Err
    assert!(db.bf_info("non_existent_bf").is_err());

    Ok(())
}

#[test]
fn test_cuckoo_filter_edge_cases_and_multi_item_batch() -> Void {
    let dir = tempdir()?;
    let db = WeDb::open(dir.path())?;

    // 边界参数校验
    assert!(db.cf_reserve("cf_err", 1, 2, 20, 1).is_err()); // capacity < 2
    assert!(db.cf_reserve("cf_err", 100, 0, 20, 1).is_err()); // bucket_size == 0
    assert!(db.cf_reserve("cf_err", 100, 2, 0, 1).is_err()); // max_iterations == 0
    assert!(db.cf_reserve("cf_err", 100, 2, 20, 40000).is_err()); // expansion > 32768

    // 空 items 测试
    let empty_items: &[&str] = &[];
    let empty_res = db.cf_insert(
        "cf_empty",
        empty_items,
        &CuckooFilterInsertOptions::default(),
    )?;
    assert!(empty_res.is_empty());

    // CF.INSERT NOCREATE 对不存在的 key 应报错
    assert!(
        db.cf_insert(
            "cf_nocreate",
            &["item1"],
            &CuckooFilterInsertOptions {
                auto_create: false,
                ..Default::default()
            }
        )
        .is_err()
    );

    // CF.COUNT 和 CF.DEL 对不存在的 key
    assert_eq!(db.cf_count("non_existent_cf", "foo")?, 0);
    assert!(!db.cf_del("non_existent_cf", "foo")?);
    assert!(!db.cf_exists("non_existent_cf", "foo")?);

    // 多元素批量插入并发扩容事务一致性测试
    let mut items = Vec::new();
    for i in 0..100 {
        items.push(format!("batch_item_{i}"));
    }

    let insert_res = db.cf_insert(
        "cf_batch",
        &items,
        &CuckooFilterInsertOptions {
            capacity: 8,
            bucket_size: 2,
            max_iterations: 10,
            expansion: 2,
            page_size: 2048,
            auto_create: true,
            nx: false,
        },
    )?;
    assert_eq!(insert_res.len(), 100);
    assert!(insert_res.iter().all(|&ok| ok));

    // 验证所有 100 个元素均可查到（确保在踢出和扩容过程中没有丢失任何先前的 dirty page）
    for item in &items {
        assert!(db.cf_exists("cf_batch", item)?);
    }

    let info = db.cf_info("cf_batch")?;
    assert_eq!(info.size, 100);
    assert!(info.num_filters > 1);

    // 非扩容满过滤器测试（expansion = 0）
    db.cf_reserve("cf_fixed", 4, 2, 5, 0)?;
    let mut count = 0;
    for i in 0..100 {
        let it = format!("fixed_{i}");
        if db.cf_add("cf_fixed", it).is_ok() {
            count += 1;
        } else {
            break;
        }
    }
    // 达到容量上限后应报错
    assert!(count > 0 && count < 100);

    Ok(())
}

#[test]
fn test_bloom_and_cuckoo_deep_scaling_and_binary_items() -> Void {
    let dir = tempdir()?;
    let db = WeDb::open(dir.path())?;

    // 1. 测试特殊二进制/空字符串项在 Bloom Filter 中的行为
    db.bf_reserve("bf_bin", 0.01, 100, 2)?;
    let bin_items: Vec<Vec<u8>> = vec![
        vec![],
        vec![0u8],
        vec![0u8, 1, 2, 3, 255, 254],
        b"normal_text".to_vec(),
        vec![b'a'; 1000],
    ];

    for item in &bin_items {
        assert!(!db.bf_exists("bf_bin", item)?);
        assert!(db.bf_add("bf_bin", item)?);
        assert!(db.bf_exists("bf_bin", item)?);
    }

    // 重复插入二进制项应返回 false
    for item in &bin_items {
        assert!(!db.bf_add("bf_bin", item)?);
    }

    // 2. 测试 Cuckoo Filter 重复添加同一元素计数与逐个删除
    db.cf_reserve("cf_dup", 64, 4, 20, 2)?;
    let dup_target = "same_key_item";

    for count in 1..=5 {
        assert!(db.cf_add("cf_dup", dup_target)?);
        assert_eq!(db.cf_count("cf_dup", dup_target)?, count);
    }

    for expected_left in (0..5).rev() {
        assert!(db.cf_del("cf_dup", dup_target)?);
        assert_eq!(db.cf_count("cf_dup", dup_target)?, expected_left as u64);
    }
    // 全部删除后应不再存在
    assert!(!db.cf_del("cf_dup", dup_target)?);
    assert!(!db.cf_exists("cf_dup", dup_target)?);

    // 3. 多级扩容链深度遍历测试 (Bloom 扩容因子 1 和 2)
    db.bf_reserve("bf_deep_scale", 0.01, 10, 1)?; // expansion = 1: 每次扩展容量相同
    for i in 0..60 {
        let it = format!("deep_item_{i}");
        assert!(db.bf_add("bf_deep_scale", it)?);
    }
    let deep_info = db.bf_info("bf_deep_scale")?;
    assert!(deep_info.n_filters >= 5);
    assert_eq!(deep_info.size, 60);

    for i in 0..60 {
        let it = format!("deep_item_{i}");
        assert!(db.bf_exists("bf_deep_scale", it)?);
    }

    Ok(())
}