use criterion::{criterion_group, criterion_main};
#[cfg(not(tarpaulin_include))]
mod sf {
    use criterion::{black_box, BenchmarkId, Criterion};
    use rusty_fib_facts::{UnsignedGCD, factorial, fibonacci, it_factorial, mem_fibonacci, rec_fibonacci};

    pub fn bench_factorial(c: &mut Criterion) {
        let mut group = c.benchmark_group("Factorials");

        for i in [0usize, 5, 10, 15, 20, 25, 30, 34].iter() {
            group.bench_with_input(BenchmarkId::new("Recursive naive", i), i, |b, i| {
                b.iter(|| factorial(black_box(*i)))
            });
            group.bench_with_input(BenchmarkId::new("Iterative", i), i, |b, i| {
                b.iter(|| it_factorial(black_box(*i)))
            });
        }
        group.finish();
    }

    pub fn bench_fibonacci(c: &mut Criterion) {
        let mut group = c.benchmark_group("Fibonacci");

        for i in [0usize, 10, 20, 30, 40, 50, 70, 93, 140, 186].iter() {
            group.bench_with_input(BenchmarkId::new("Recursive memoized", i), i, |b, i| {
                b.iter(|| mem_fibonacci(black_box(*i)))
            });
            group.bench_with_input(BenchmarkId::new("Iterative", i), i, |b, i| {
                b.iter(|| fibonacci(black_box(*i)))
            });
        }

        group.finish();

        let mut group = c.benchmark_group("Recursive Fibonacci");
        for i in [0usize, 10, 20, 25, 26, 27, 28, 29, 30].iter() {
            group.bench_with_input(BenchmarkId::new("Naive Recursive", i), i, |b, i| {
                b.iter(|| rec_fibonacci(black_box(*i)))
            });
        }
        group.finish();
    }

    pub fn bench_gcd(c: &mut Criterion) {
        let mut group = c.benchmark_group("GCD");

        #[derive(Debug)]
        struct Gcd {
            left: u128,
            right: u128,
            left_fib: u128,
            right_fib: u128,
        }

        impl Gcd {
            fn new(left: u128, right: u128) -> Self {
                Gcd {
                    left,
                    right,
                    left_fib: fibonacci(left as usize).unwrap(),
                    right_fib: fibonacci(right as usize).unwrap(),
                }
            }
        }

        let max = Gcd::new(185, 186);
        let med = Gcd::new(92, 93);
        let small = Gcd::new(14, 15);

        for input in [small, med, max].iter() {
            group.bench_with_input(
                BenchmarkId::new("Binary", input.left),
                input,
                |bench, input| {
                    let a = input.left_fib;
                    let b = input.right_fib;
                    bench.iter(|| u128::gcd(black_box(a), black_box(b)))
                },
            );
            group.bench_with_input(
                BenchmarkId::new("Stein", input.left),
                input,
                |bench, input| {
                    let a = input.left_fib;
                    let b = input.right_fib;
                    bench.iter(|| u128::stein_gcd(black_box(a), black_box(b)))
                },
            );
            group.bench_with_input(
                BenchmarkId::new("Euclid", input.left),
                input,
                |bench, input| {
                    let a = input.left_fib;
                    let b = input.right_fib;
                    bench.iter(|| u128::e_gcd(black_box(a), black_box(b)))
                },
            );
        }
        group.finish();
    }
}

criterion_group!(
    benches,
    sf::bench_factorial,
    sf::bench_fibonacci,
    sf::bench_gcd,
);
criterion_main!(benches);