use criterion::{black_box, criterion_group, criterion_main, Criterion};
use hwphysics::{common::GearId, data::GearDataManager};

#[derive(Clone, Copy, Default)]
struct P {
    position: u64,
}

#[derive(Clone, Copy, Default)]
struct V {
    velocity: u64,
}

#[derive(Clone, Copy, Default)]
struct Pv {
    position: u64,
    velocity: u64,
}

const SIZE: usize = 4 * 1024;

pub fn array_run(c: &mut Criterion) {
    let mut items = [Pv::default(); SIZE];

    c.bench_function("array run", |b| {
        b.iter(|| {
            for item in &mut items {
                item.velocity += black_box(item.position);
            }
        })
    });
}

pub fn component_run(c: &mut Criterion) {
    let mut manager = GearDataManager::new();

    manager.register::<P>();
    manager.register::<V>();

    for i in 1..=SIZE {
        let gear_id = GearId::new(i as u16).unwrap();
        manager.add(gear_id, &P::default());
        manager.add(gear_id, &V::default());
    }

    c.bench_function("component run", |b| {
        b.iter(|| {
            manager
                .iter()
                .run(|(p, v): (&mut P, &mut V)| v.velocity += black_box(p.position));
        })
    });
}

pub fn component_multirun(c: &mut Criterion) {
    for n in (16..=64).step_by(16) {
        let mut manager = GearDataManager::new();

        manager.register::<P>();
        manager.register::<V>();

        for i in 1..=(SIZE / n) {
            let gear_id = GearId::new(i as u16).unwrap();
            manager.add(gear_id, &P::default());
            manager.add(gear_id, &V::default());
        }

        c.bench_function(&format!("component run {}", n), |b| {
            b.iter(|| {
                for i in 0..n {
                    manager
                        .iter()
                        .run(|(p, v): (&mut P, &mut V)| v.velocity += black_box(p.position));
                }
            })
        });
    }
}

pub fn component_add_remove(c: &mut Criterion) {
    let mut manager = GearDataManager::new();
    let mut gears1 = vec![];
    let mut gears2 = vec![];

    manager.register::<P>();
    manager.register::<V>();

    for i in 1..=SIZE {
        let gear_id = GearId::new(i as u16).unwrap();
        manager.add(gear_id, &P::default());
        if i % 2 == 0 {
            manager.add(gear_id, &V::default());
            gears1.push(gear_id);
        } else {
            gears2.push(gear_id);
        }
    }

    c.bench_function("component add/remove", |b| {
        b.iter(|| {
            for id in &gears2 {
                manager.add(*id, &V::default());
            }
            for id in &gears1 {
                manager.remove::<V>(*id);
            }
            std::mem::swap(&mut gears1, &mut gears2);
        })
    });
}

criterion_group!(
    benches,
    array_run,
    component_run,
    component_multirun,
    component_add_remove
);
criterion_main!(benches);