use at_mst::Mst;
use at_crypto::cid::cid_for_cbor;

fn cid_for_str(s: &str) -> cid::Cid {
    let bytes = format!("rec:{s}");
    cid_for_cbor(bytes.as_bytes()).expect("cid_for_cbor")
}

fn main() {
    let keys = vec!["alpha", "bravo", "charlie", "delta", "echo", "foxtrot"];
    let values: Vec<_> = keys.iter().map(|k| cid_for_str(k)).collect();

    let mut forward = Mst::new();
    for (k, v) in keys.iter().zip(values.iter()) {
        forward = forward.put(k.to_string(), *v, None).unwrap();
    }

    let mut backward = Mst::new();
    for (k, v) in keys.iter().rev().zip(values.iter().rev()) {
        backward = backward.put(k.to_string(), *v, None).unwrap();
    }

    println!("forward  root: {:?}", forward.root_cid());
    println!("backward root: {:?}", backward.root_cid());
    println!("forward  blocks: {}", forward.blocks().len());
    println!("backward blocks: {}", backward.blocks().len());

    let f_set: std::collections::BTreeSet<_> = forward.blocks().keys().copied().collect();
    let b_set: std::collections::BTreeSet<_> = backward.blocks().keys().copied().collect();
    println!("forward == backward blocks: {}", f_set == b_set);
    println!("forward - backward: {:?}", f_set.difference(&b_set).collect::<Vec<_>>());
    println!("backward - forward: {:?}", b_set.difference(&f_set).collect::<Vec<_>>());

    // 100 random keys
    let mut rng_keys: Vec<String> = (0..100).map(|i| format!("k/{i:05}")).collect();
    let mut a = Mst::new();
    let mut b = Mst::new();
    for k in &rng_keys {
        a = a.put(k.clone(), cid_for_str(k), None).unwrap();
    }
    rng_keys.reverse();
    for k in &rng_keys {
        b = b.put(k.clone(), cid_for_str(k), None).unwrap();
    }
    println!("\n100 keys:");
    println!("a root: {:?}", a.root_cid());
    println!("b root: {:?}", b.root_cid());
    let a_set: std::collections::BTreeSet<_> = a.blocks().keys().copied().collect();
    let b_set: std::collections::BTreeSet<_> = b.blocks().keys().copied().collect();
    println!("a == b blocks: {}", a_set == b_set);
    println!("a - b: {}", a_set.difference(&b_set).count());
    println!("b - a: {}", b_set.difference(&a_set).count());

    // deeper test: deliberately insert things that have layer > 0
    // find a key with leading zeros in sha256
    use at_crypto::cid::sha256;
    for n in 1..1000 {
        let key = format!("k{n}");
        let h = sha256(key.as_bytes());
        if h[0] == 0 && h[1] == 0 {
            println!("k{}: 2 leading zero bytes -> layer 8, capped to 1 or 2", n);
            break;
        }
    }
    for n in 1..1000 {
        let key = format!("k{n}");
        let h = sha256(key.as_bytes());
        if h[0] < 4 {
            println!("k{}: leading byte 0x{:02x} -> layer {}", n, h[0], h[0].leading_zeros()/2);
            break;
        }
    }
}