use backend::hash::LedHash256;
use criterion::{criterion_group, criterion_main, Criterion, Throughput};

//----

fn hash_10b(c: &mut Criterion) {
    let size = 10;

    let mut group = c.benchmark_group("hash_10b");
    let data: Vec<u8> = b"abcdefghijklmnopqrstuvwxyz"
        .iter()
        .copied()
        .cycle()
        .take(size)
        .collect();
    group.throughput(Throughput::Bytes(size as u64));

    group.bench_function("led256", |bench| {
        bench.iter(|| {
            let mut hash = LedHash256::new();
            hash.update(&data);
            hash.finish();
        })
    });

    group.bench_function("blake3", |bench| {
        bench.iter(|| {
            let mut hash = blake3::Hasher::new();
            hash.update(&data);
            hash.finalize();
        })
    });
}

fn hash_1kb(c: &mut Criterion) {
    let size = 1000;

    let mut group = c.benchmark_group("hash_1kb");
    let data: Vec<u8> = b"abcdefghijklmnopqrstuvwxyz"
        .iter()
        .copied()
        .cycle()
        .take(size)
        .collect();
    group.throughput(Throughput::Bytes(size as u64));

    group.bench_function("led256", |bench| {
        bench.iter(|| {
            let mut hash = LedHash256::new();
            hash.update(&data);
            hash.finish();
        })
    });

    group.bench_function("blake3", |bench| {
        bench.iter(|| {
            let mut hash = blake3::Hasher::new();
            hash.update(&data);
            hash.finalize();
        })
    });
}

fn hash_100kb(c: &mut Criterion) {
    let size = 100_000;

    let mut group = c.benchmark_group("hash_100kb");
    let data: Vec<u8> = b"abcdefghijklmnopqrstuvwxyz"
        .iter()
        .copied()
        .cycle()
        .take(size)
        .collect();
    group.throughput(Throughput::Bytes(size as u64));

    group.bench_function("led256_1k_chunk", |bench| {
        bench.iter(|| {
            let mut hash = LedHash256::new();
            for chunk in data.chunks(1000) {
                hash.update(chunk);
            }
            hash.finish();
        })
    });

    group.bench_function("led256_10k_chunk", |bench| {
        bench.iter(|| {
            let mut hash = LedHash256::new();
            for chunk in data.chunks(10000) {
                hash.update(chunk);
            }
            hash.finish();
        })
    });

    group.bench_function("blake3_1k_chunk", |bench| {
        bench.iter(|| {
            let mut hash = blake3::Hasher::new();
            for chunk in data.chunks(1000) {
                hash.update(chunk);
            }
            hash.finalize();
        })
    });

    group.bench_function("blake3_10k_chunk", |bench| {
        bench.iter(|| {
            let mut hash = blake3::Hasher::new();
            for chunk in data.chunks(10000) {
                hash.update(chunk);
            }
            hash.finalize();
        })
    });
}

//----

criterion_group!(benches, hash_10b, hash_1kb, hash_100kb);
criterion_main!(benches);