use super::*;
use atools::prelude::*;
const fn lenleb128(x: u128) -> usize {
    let mut n2 = 0;
    let mut w = x;
    loop {
        w >>= 7;
        if w == 0 {
            n2 += 1;
            break;
        } else {
            n2 += 1;
        }
    }
    n2
}
const fn leb128<const X: u128>() -> [u8; lenleb128(X)] {
    let mut i = 0;
    let mut into: [u8; _] = [0; _];
    let mut w = X;
    loop {
        let n = (w & 127) as u8;
        w >>= 7;
        if w == 0 {
            into[i] = n;
            break;
        } else {
            into[i] = n | 1 << 7;
        }
        i += 1;
    }
    into
}

#[test]
fn test_struct() {
    #[derive(Serialize)]
    struct Test {
        int: u32,
        seq: Vec<&'static str>,
    }

    let test = Test {
        int: 1,
        seq: vec!["hello", "bendncode"],
    };
    let expected = (*b"m")
        .couple(leb128::<2>())
        .couple(*b"s\x03intu")
        .couple(leb128::<1>())
        .couple(*b"s\x03seq")
        .join(b'l')
        .couple(leb128::<2>())
        .join(b's')
        .couple(leb128::<5>())
        .couple(*b"hello")
        .join(b's')
        .couple(leb128::<9>())
        .couple(*b"bendncode");

    assert_eq!(to_bytes(&test).unwrap(), expected);
}

#[test]
fn test_enum() {
    #[derive(Serialize)]
    enum E {
        Unit,
        Newtype(u32),
        Tuple(u32, u32),
        Struct { a: u32 },
    }

    let u = E::Unit;
    let expected = [b'n', b'u', 0];
    assert_eq!(to_bytes(&u).unwrap(), expected);

    // println!("--");

    let n = E::Newtype(51);
    let expected = b"vu"
        .couple(leb128::<1>())
        .join(b'u') // i rather dislike this byte
        .couple(leb128::<51>());

    assert_eq!(to_bytes(&n).unwrap(), expected);
    // println!("--");
    let t = E::Tuple(1, 24151561);
    let expected = b"xu"
        .couple(leb128::<2>())
        .couple(leb128::<2>())
        .join(b'u')
        .couple(leb128::<1>())
        .join(b'u')
        .couple(leb128::<24151561>());
    assert_eq!(to_bytes(&t).unwrap(), expected);
    // println!("--");
    let s = E::Struct { a: 1 };
    let expected = b"yu"
        .couple(leb128::<3>())
        .couple(leb128::<1>())
        .join(b's')
        .couple(leb128::<1>())
        .couple(*b"au")
        .couple(leb128::<1>());
    assert_eq!(to_bytes(&s).unwrap(), expected);
}