mod utils;

use std::hint::black_box;

use criterion::{Criterion, criterion_group, criterion_main};
use utils::eval;

fn bench_non_recursive(c: &mut Criterion) {
    let mut group = c.benchmark_group("non_recursive");

    group.bench_function("simple_bindings", |b| {
        b.iter(|| eval(black_box("let x = 1; y = 2; z = x + y; in z")))
    });

    group.bench_function("many_bindings", |b| {
        b.iter(|| {
            eval(black_box(
                "let a = 1; b = 2; c = 3; d = 4; e = 5; f = 6; g = 7; h = 8; i = 9; j = 10; in a + b + c + d + e + f + g + h + i + j",
            ))
        })
    });

    group.bench_function("dependent_chain", |b| {
        b.iter(|| {
            eval(black_box(
                "let a = 1; b = a + 1; c = b + 1; d = c + 1; e = d + 1; in e",
            ))
        })
    });

    group.bench_function("rec_attrset_non_recursive", |b| {
        b.iter(|| eval(black_box("rec { a = 1; b = 2; c = 3; d = a + b + c; }.d")))
    });

    group.finish();
}

fn bench_recursive(c: &mut Criterion) {
    let mut group = c.benchmark_group("recursive");

    group.bench_function("simple_recursion", |b| {
        b.iter(|| {
            eval(black_box(
                "let f = n: if n == 0 then 0 else f (n - 1); in f 10",
            ))
        })
    });

    group.bench_function("fibonacci", |b| {
        b.iter(|| {
            eval(black_box(
                "let fib = n: if n <= 1 then 1 else fib (n - 1) + fib (n - 2); in fib 10",
            ))
        })
    });

    group.bench_function("factorial", |b| {
        b.iter(|| {
            eval(black_box(
                "let factorial = n: if n == 0 then 1 else n * factorial (n - 1); in factorial 10",
            ))
        })
    });

    group.bench_function("rec_attrset_recursive", |b| {
        b.iter(|| {
            eval(black_box(
                "rec { f = n: if n == 0 then 1 else f (n - 1); }.f 10",
            ))
        })
    });

    group.finish();
}

fn bench_mutual_recursion(c: &mut Criterion) {
    let mut group = c.benchmark_group("mutual_recursion");

    group.bench_function("two_way", |b| {
        b.iter(|| {
            eval(black_box(
                "let f = n: if n == 0 then 0 else g (n - 1); g = n: if n == 0 then 1 else f (n - 1); in f 10",
            ))
        })
    });

    group.bench_function("even_odd", |b| {
        b.iter(|| {
            eval(black_box(
                "let even = n: if n == 0 then true else odd (n - 1); odd = n: if n == 0 then false else even (n - 1); in even 20",
            ))
        })
    });

    group.bench_function("three_way", |b| {
        b.iter(|| {
            eval(black_box(
                "let a = n: if n == 0 then 1 else b (n - 1); b = n: if n == 0 then 2 else c (n - 1); c = n: if n == 0 then 3 else a (n - 1); in a 15",
            ))
        })
    });

    group.finish();
}

fn bench_mixed(c: &mut Criterion) {
    let mut group = c.benchmark_group("mixed");

    group.bench_function("recursive_with_constants", |b| {
        b.iter(|| {
            eval(black_box(
                "let x = 10; fib = n: if n <= 1 then 1 else fib (n - 1) + fib (n - 2); in fib x",
            ))
        })
    });

    group.bench_function("multiple_recursive_functions", |b| {
        b.iter(|| {
            eval(black_box(
                "let fib = n: if n <= 1 then 1 else fib (n - 1) + fib (n - 2); fact = n: if n == 0 then 1 else n * fact (n - 1); in (fib 8) + (fact 5)",
            ))
        })
    });

    group.bench_function("complex_dependency_graph", |b| {
        b.iter(|| {
            eval(black_box(
                "let a = 1; b = 2; c = a + b; fib = n: if n <= 1 then 1 else fib (n - 1) + fib (n - 2); result = c + fib 8; in result",
            ))
        })
    });

    group.finish();
}

fn bench_nested_scopes(c: &mut Criterion) {
    let mut group = c.benchmark_group("nested_scopes");

    group.bench_function("nested_let_non_recursive", |b| {
        b.iter(|| {
            eval(black_box(
                "let x = 1; in let y = x + 1; in let z = y + 1; in z",
            ))
        })
    });

    group.bench_function("nested_let_with_recursive", |b| {
        b.iter(|| {
            eval(black_box(
                "let f = n: if n == 0 then 0 else f (n - 1); in let g = m: f m; in g 10",
            ))
        })
    });

    group.bench_function("deeply_nested", |b| {
        b.iter(|| {
            eval(black_box(
                "let a = 1; in let b = a + 1; in let c = b + 1; in let d = c + 1; in let e = d + 1; in e",
            ))
        })
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_non_recursive,
    bench_recursive,
    bench_mutual_recursion,
    bench_mixed,
    bench_nested_scopes
);
criterion_main!(benches);