//! Benchmark harness (spec §25): a repository of 10 000 files and 5 000
//! changes, then the everyday operations timed against thresholds.
//!
//! Not part of the ordinary test run. Run it with
//!
//!     cargo test --release -p oxy-core --test bench -- --ignored --nocapture
//!
//! `OXY_BENCH_FILES` and `OXY_BENCH_CHANGES` change the size and
//! `OXY_BENCH_DIR` the disk. The table it prints is what
//! `docs/benchmarks.md` records. Thresholds are for the default size on a
//! developer machine; they catch regressions of an order of magnitude,
//! not noise.

use oxy_core::repo::Repo;
use std::path::Path;
use std::time::{Duration, Instant};

fn hermetic() {
    static ONCE: std::sync::Once = std::sync::Once::new();
    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();
    ONCE.call_once(|| {
        let d = tempfile::tempdir().unwrap();
        std::env::set_var("OXY_HOME", d.path());
        DIR.set(d).ok();
    });
}

fn env_usize(name: &str, default: usize) -> usize {
    std::env::var(name)
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(default)
}

fn write(root: &Path, rel: &str, content: &str) {
    let p = root.join(rel);
    std::fs::create_dir_all(p.parent().unwrap()).unwrap();
    std::fs::write(p, content).unwrap();
}

/// Peak resident memory of this process, from /proc (Linux only).
fn peak_rss_mib() -> Option<f64> {
    let s = std::fs::read_to_string("/proc/self/status").ok()?;
    let kb: f64 = s
        .lines()
        .find(|l| l.starts_with("VmHWM:"))?
        .split_whitespace()
        .nth(1)?
        .parse()
        .ok()?;
    Some(kb / 1024.0)
}

struct Row {
    what: String,
    took: Duration,
    limit: Duration,
}

fn time<T>(
    rows: &mut Vec<Row>,
    what: impl Into<String>,
    limit_ms: u64,
    f: impl FnOnce() -> T,
) -> T {
    let t = Instant::now();
    let out = f();
    rows.push(Row {
        what: what.into(),
        took: t.elapsed(),
        limit: Duration::from_millis(limit_ms),
    });
    out
}

fn file_name(i: usize) -> String {
    format!("src/d{:03}/f{:05}.txt", i / 100, i)
}

#[test]
#[ignore]
fn bench_ten_thousand_files_five_thousand_changes() {
    hermetic();
    let files = env_usize("OXY_BENCH_FILES", 10_000);
    let changes = env_usize("OXY_BENCH_CHANGES", 5_000);
    let dir = match std::env::var_os("OXY_BENCH_DIR") {
        Some(d) => tempfile::tempdir_in(d).unwrap(),
        None => tempfile::tempdir().unwrap(),
    };
    let root = dir.path();
    let work = root.join("work");
    let repo = Repo::init(&work).unwrap().with_home(root.join("home"));
    let mut rows = Vec::new();

    // Build: one import of every file, then small changes; one file in
    // ten changes is the hot file, so blame has a long history to walk.
    for i in 0..files {
        write(
            &work,
            &file_name(i),
            &format!("file {i}\n{}", "some line of text\n".repeat(20)),
        );
    }
    write(&work, "hot.txt", "");
    time(
        &mut rows,
        format!("commit: import {files} files"),
        60_000,
        || repo.commit("import", &[]).unwrap(),
    );
    let mut hot = String::new();
    let build = Instant::now();
    for c in 1..changes {
        if c % 10 == 0 {
            hot.push_str(&format!("line added by change {c}\n"));
            write(&work, "hot.txt", &hot);
        } else {
            let i = (c * 7919) % files;
            write(
                &work,
                &file_name(i),
                &format!(
                    "file {i} edited by change {c}\n{}",
                    "some line of text\n".repeat(20)
                ),
            );
        }
        repo.commit(&format!("change {c}"), &[]).unwrap();
    }
    let per_commit = build.elapsed() / (changes.max(2) - 1) as u32;
    rows.push(Row {
        what: format!("commit: one file (mean of {})", changes - 1),
        took: per_commit,
        limit: Duration::from_millis(250),
    });

    // Everyday operations on the finished repository.
    time(
        &mut rows,
        "status: clean working copy (stat crawl)",
        2_000,
        || assert!(!repo.snapshot("oxy status").unwrap().changed),
    );
    for i in 0..10 {
        write(&work, &file_name(i * 13), &format!("ten-file edit {i}\n"));
    }
    time(&mut rows, "status: 10 files modified", 2_000, || {
        assert!(repo.snapshot("oxy status").unwrap().changed)
    });
    time(&mut rows, "commit: 10 files", 500, || {
        repo.commit("ten files", &[]).unwrap()
    });
    let log = time(&mut rows, "log: whole bookmark", 2_000, || {
        repo.log().unwrap()
    });
    assert!(log.len() >= changes, "{} entries", log.len());
    let blame = time(
        &mut rows,
        format!("blame: hot file ({} lines)", changes / 10),
        2_000,
        || repo.blame("hot.txt").unwrap(),
    );
    assert_eq!(blame.len(), (changes - 1) / 10);
    time(&mut rows, "blame: ordinary file", 1_000, || {
        repo.blame(&file_name(1)).unwrap()
    });
    time(&mut rows, "checkpoint", 10_000, || {
        repo.checkpoint().unwrap()
    });
    time(&mut rows, "status after checkpoint", 2_000, || {
        repo.snapshot("oxy status").unwrap()
    });

    // Sync over a local path: a full push into an empty hosted repository, then a clone.
    let origin = root.join("origin");
    Repo::init_bare_unbound(&origin).unwrap();
    let mut repo = repo;
    repo.config
        .set("remote.origin.url", &origin.to_string_lossy())
        .unwrap();
    repo.save_config().unwrap();
    time(
        &mut rows,
        "push: everything to an empty remote",
        60_000,
        || assert!(repo.push("origin", false).unwrap().iter().all(|r| r.ok)),
    );
    time(&mut rows, "push: up to date", 1_000, || {
        repo.push("origin", false).unwrap()
    });
    let clone = time(
        &mut rows,
        "clone: everything, with checkout",
        60_000,
        || Repo::clone(&origin.to_string_lossy(), &root.join("clone")).unwrap(),
    );
    assert_eq!(
        clone.bookmark_heads().unwrap(),
        repo.bookmark_heads().unwrap()
    );
    let rep = time(&mut rows, "fsck", 60_000, || repo.fsck().unwrap());
    assert_eq!(rep.errors(), 0, "{:?}", rep.problems);
    time(&mut rows, "gc", 60_000, || repo.gc(true).unwrap());
    time(&mut rows, "status after gc", 2_000, || {
        repo.snapshot("oxy status").unwrap()
    });

    eprintln!("\n| Operation ({files} files, {changes} changes) | Time | Threshold | |");
    eprintln!("|---|---:|---:|---|");
    for r in &rows {
        let verdict = if r.took > r.limit { "over" } else { "ok" };
        eprintln!(
            "| {} | {:.1} ms | {} ms | {verdict} |",
            r.what,
            r.took.as_secs_f64() * 1000.0,
            r.limit.as_millis()
        );
    }
    if let Some(mib) = peak_rss_mib() {
        eprintln!("\nPeak resident memory of the whole run: {mib:.0} MiB");
    }
    let slow: Vec<&Row> = rows.iter().filter(|r| r.took > r.limit).collect();
    assert!(
        slow.is_empty(),
        "over threshold: {:?}",
        slow.iter().map(|r| (&r.what, r.took)).collect::<Vec<_>>()
    );
}