use divan::{Bencher, black_box};
use image::ImageReader;

const LIST_OF_SAMPLES: [&str; 4] = [
    "samples/david.png",
    "samples/karel_käos.jpg",
    "samples/jane.jpg",
    "samples/diderot_111.png",
];

fn main() {
    // Run `add` benchmark:
    divan::main();
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_burkes(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither(&mut img, dither::kernel::BURKES_KERNEL.to_vec())
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_atkinson_base(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_atkinson_base(&mut img)
    });
}
#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_atkinson(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither(&mut img, dither::kernel::ATKINSON_KERNEL.to_vec())
    });
}
#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_atkinson_ref(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::ATKINSON_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_atkinson_int(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        let kernel = dither::kernel::ATKINSON_KERNEL_INTEGER.to_vec();
        dither::dither_shift(
            &mut img,
            dither::kernel::KernelShift {
                kernel,
                bit_shift: dither::kernel::ATKINSON_KERNEL_BIT_SHIFT,
            },
        );
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_floyd_steinberg(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::FLOYD_STEINBERG_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_fedoseev(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::FEDOSEEV_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_fedoseev2(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::FEDOSEEV2_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_fedoseev3(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::FEDOSEEV3_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_fedoseev4(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::FEDOSEEV4_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_wong_allebach(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::WONG_ALLEBACH_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_jarvis_judice_ninke(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::JARVIS_JUDICE_NINKE_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_stucki(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::STUCKI_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_sierra(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::SIERRA3_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_sierra_two_rows(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::SIERRA2_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}

#[divan::bench(args = LIST_OF_SAMPLES)]
fn test_sierra_lite(bencher: Bencher, img: &str) {
    let sample_img = ImageReader::open(img)
        .unwrap()
        .decode()
        .unwrap()
        .into_rgb8();
    let kernel = dither::kernel::SIERRA_LITE_KERNEL.to_vec();

    bencher.bench_local(|| {
        let mut img = black_box(sample_img.clone());
        dither::dither_ref(&mut img, &kernel)
    });
}