use arbitrary::{Arbitrary, Unstructured};
use canvas::{Card, draw_painting};
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use rand::{Rng, rngs::StdRng};
use std::{hint::black_box, time::Duration};

use crate::random_card::RandomCard;

mod random_card;

fn criterion_benchmark(c: &mut Criterion) {
    let cards = vec![
        Card::from_dbg_string(".ttt."),
        Card::from_dbg_string("t.l.."),
        Card::from_dbg_string("ll..pt"),
    ];
    assert_eq!(draw_painting(&cards, &[]), Some([0, 1, 2]));
    c.bench_function("painting optimizer", |b| {
        b.iter(|| {
            draw_painting(&black_box(cards.clone()), &[]);
        });
    });
}

fn random_card_pool<const N: usize>(rng: &mut StdRng) -> Vec<Card> {
    <[RandomCard; N] as Arbitrary>::arbitrary(&mut Unstructured::new(&rng.random::<[u8; 32]>()))
        .unwrap()
        .map(|x| x.0)
        .to_vec()
}

fn from_elem(c: &mut Criterion) {
    use rand::SeedableRng;
    // Define a seed. This can be any value that implements the `SeedableRng` trait.
    let seed: [u8; 32] = [
        8u64.to_be_bytes(),
        8u64.to_be_bytes(),
        8u64.to_be_bytes(),
        8u64.to_be_bytes(),
    ]
    .concat()
    .try_into()
    .unwrap();

    // Create a new RNG with the specified seed.
    let mut rng: StdRng = SeedableRng::from_seed(seed);
    // Generate a random number using the seeded RNG.
    let card_pool = [
        random_card_pool::<4>(&mut rng),
        random_card_pool::<8>(&mut rng),
        random_card_pool::<16>(&mut rng),
        random_card_pool::<32>(&mut rng),
        random_card_pool::<64>(&mut rng),
        random_card_pool::<128>(&mut rng),
    ];

    let mut group = c.benchmark_group("from_elem");
    for size in card_pool.iter() {
        group.bench_with_input(BenchmarkId::from_parameter(size.len()), size, |b, size| {
            b.iter(|| {
                draw_painting(&black_box(size.clone()), &[])
            });
        });
    }
    group.finish();
}

criterion_group!(name = benches;
    config = Criterion::default()
    .warm_up_time(Duration::from_millis(100))
    .measurement_time(Duration::from_millis(500));
     targets = criterion_benchmark, from_elem);
criterion_main!(benches);