// SQLite、资源作用域和优化参数两侧一致；只比较生成层，不推断完整语言或 HTTP 吞吐。
use dever_runtime::{
    database::{Context as DbContext, Parameter, Registry},
    task::{Limits, Runtime, Scope},
};
use std::{
    hint::black_box,
    path::{Path, PathBuf},
    sync::Arc,
    time::Instant,
};

struct BenchDirectory(PathBuf);

impl Drop for BenchDirectory {
    fn drop(&mut self) {
        std::fs::remove_dir_all(&self.0).unwrap();
    }
}

fn directory(name: &str, extra: &str) -> (BenchDirectory, PathBuf) {
    let unique = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    let relative = format!("{name}-benchmark-{}-{unique}", std::process::id());
    let directory = BenchDirectory(
        std::env::current_exe()
            .unwrap()
            .parent()
            .unwrap()
            .join(&relative),
    );
    std::fs::create_dir(&directory.0).unwrap();
    let settings = directory.0.join("setting.json");
    std::fs::write(&settings, format!(r#"{{"database":{{"default":{{"type":"sqlite","path":"{relative}/case.db","max_connections":1,"max_page_size":2048}}}},{extra}}}"#)).unwrap();
    (directory, settings)
}

fn runtime() -> Runtime {
    Runtime::new(Limits {
        threads: 1,
        workers: 1,
        tasks: 16,
    })
    .unwrap()
}

fn smoke() -> bool {
    std::env::args().any(|value| value == "--smoke")
}

fn samples(name: &str, mut measure: impl FnMut(bool, usize) -> (u128, u64)) {
    if let Ok(selected) = std::env::var("DEVER_BENCH_CASES")
        && !selected.split(',').any(|case| case == name)
    {
        return;
    }
    let (rounds, count) = if smoke() { (1, 4) } else { (15, 2000) };
    if !smoke() {
        for generated in [true, false] {
            black_box(measure(generated, 200));
        }
    }
    for sample in 0..rounds {
        let mut order = [("dever", true), ("rust", false), ("control", true)];
        order.rotate_left(sample % 3);
        let mut expected = None;
        for (implementation, generated) in order {
            let (elapsed, checksum) = measure(generated, count);
            if let Some(expected) = expected {
                assert_eq!(checksum, expected);
            }
            expected = Some(checksum);
            if !smoke() {
                println!("{name},{sample},{implementation},{elapsed},{checksum}");
            }
        }
    }
    if smoke() {
        println!("correctness smoke passed: {name}; no performance result collected");
    }
}

fn header() {
    eprintln!(
        "Rust 1.95.0; release fat LTO; codegen-units=1; overflow-checks=true; SQLite WAL/NORMAL; one connection; one runtime worker; setup/checks excluded"
    );
    if !smoke() {
        println!("case,sample,implementation,nanoseconds,checksum");
    }
}