const MAX_SIZE: usize = 11;

fn main() {
    let rng1 = Xoshiro256StarStar::seed_from_u64(123456);
    let mut mutator = Mutator::new(rng1);

    let mut hash_set = FnvHashSet::default();
    let mut collision: usize = 0;
    let mut empty_collision: usize = 0;

    let mut instance = MyStruct::new_fuzzed(&mut mutator, None);

    let mut repartition = [0usize; MAX_SIZE];
    repartition[instance.data.len()]  = 1;

    let total_loop = 1_000_000;

    for i in 0..total_loop {
        instance.mutate(&mut mutator, None);

        let mut serialized_data = Vec::with_capacity(instance.serialized_size());
        instance.binary_serialize::<_, LittleEndian>(&mut serialized_data);
        repartition[instance.data.len()]  = 1;

        if serialized_data == [] {
            empty_collision  = 1;
        } else if hash_set.contains(&serialized_data) {
            collision  = 1;
        } else {
            hash_set.insert(serialized_data);
        }
    }
    println!(
        "collisions: {} ({}%)",
        collision,
        (collision as f64 / total_loop as f64) * 100.0
    );
    println!(
        "collisions empty: {} ({}%)",
        empty_collision,
        (empty_collision as f64 / total_loop as f64) * 100.0
    );
    println!("Size repartition of the main list:",);
    for (i, num) in repartition.iter().enumerate() {
        println!("{i}: {}", (*num as f64 / total_loop as f64) * 100.0);
    }
}

pub struct MyStruct {
    #[lain(min = 0, max = 10)]
    pub data: Vec<MyInnerStruct>,
}
pub struct MyInnerStruct {
    pub tag: u32,
    #[lain(ignore)]
    pub len: u32,
}

pub struct MyStruct {
    pub tag: u32,
    #[lain(ignore)]
    pub len: u32,
    #[lain(min = 0, max = 10)]
    pub data: Vec<u8>,
}