//! Compile-Budget-Benchmark (Instant-Compile-Anforderung, PLAN.md):
//! Projekt mit ~50.000 Zeilen < 1 s, einzelnes Modul (~500 Zeilen) < 50 ms
//! (Release-Build). Eigener Harness (kein Criterion — keine
//! Fremdabhängigkeit nötig); Lauf mit `cargo bench -p tb-vm`.

use std::fmt::Write as _;
use std::time::Instant;

/// Realistisch gemischtes Modul mit `n_blocks` Codeblöcken
/// (~10 Zeilen je Block) plus Prozeduren.
fn generate_module(n_blocks: usize, seed: usize) -> String {
    let mut src = String::new();
    let _ = writeln!(src, "' Generiertes Benchmark-Modul {seed}");
    let _ = writeln!(src, "DIM feld{seed}%(100)");
    for i in 0..n_blocks {
        let v = format!("v{seed}x{i}");
        let _ = writeln!(src, "{v}% = {i} MOD 100");
        let _ = writeln!(src, "{v}tot# = {v}% * 1.5 + SQR({v}% + 1)");
        let _ = writeln!(src, "IF {v}% > 50 THEN");
        let _ = writeln!(src, "  {v}s$ = \"gross\" + STR$({v}%)");
        let _ = writeln!(src, "ELSE");
        let _ = writeln!(src, "  {v}s$ = LEFT$(\"klein\", 3)");
        let _ = writeln!(src, "END IF");
        let _ = writeln!(src, "FOR {v}i% = 1 TO 10");
        let _ = writeln!(src, "  feld{seed}%({v}i% MOD 100) = {v}i%");
        let _ = writeln!(src, "NEXT");
    }
    // Prozeduren am Modulende
    for p in 0..(n_blocks / 20).max(1) {
        let _ = writeln!(src, "SUB Tu{seed}p{p} (a%, b#)");
        let _ = writeln!(src, "  b# = a% * 2 + b#");
        let _ = writeln!(src, "END SUB");
    }
    src
}

fn compile_all(sources: &[(String, String)]) -> usize {
    let mut total = 0;
    for (name, src) in sources {
        let m = tb_vm::compile_source(name, src).expect("Benchmark-Quelle muss kompilieren");
        total += m.procs.iter().map(|p| p.code.len()).sum::<usize>();
    }
    total
}

fn main() {
    // Einzelnes Modul: ~500 Zeilen (Budget < 50 ms).
    let single = generate_module(50, 0);
    let single_lines = single.lines().count();

    // Projekt: ~50.000 Zeilen über 20 Module (Budget < 1 s).
    let modules: Vec<(String, String)> = (0..20)
        .map(|i| (format!("MOD{i}"), generate_module(245, i)))
        .collect();
    let project_lines: usize = modules.iter().map(|(_, s)| s.lines().count()).sum();

    // Aufwärmen
    let _ = compile_all(&[("WARM".into(), single.clone())]);

    let t = Instant::now();
    let mut best_single = f64::MAX;
    for _ in 0..10 {
        let t1 = Instant::now();
        let _ = compile_all(&[("EINZEL".into(), single.clone())]);
        best_single = best_single.min(t1.elapsed().as_secs_f64());
    }
    let _ = t;

    let t2 = Instant::now();
    let instrs = compile_all(&modules);
    let project_secs = t2.elapsed().as_secs_f64();

    println!("Compile-Budget-Benchmark (Release):");
    println!(
        "  Einzelmodul: {single_lines} Zeilen in {:.2} ms  (Budget 50 ms) {}",
        best_single * 1000.0,
        if best_single < 0.050 {
            "OK"
        } else {
            "VERFEHLT"
        }
    );
    println!(
        "  Projekt:     {project_lines} Zeilen in {:.0} ms  (Budget 1000 ms) {} — {instrs} Instruktionen",
        project_secs * 1000.0,
        if project_secs < 1.0 { "OK" } else { "VERFEHLT" }
    );
    let lps = project_lines as f64 / project_secs;
    println!("  Durchsatz:   {:.0} Zeilen/s", lps);
    assert!(best_single < 0.050, "Einzelmodul-Budget verfehlt");
    assert!(project_secs < 1.0, "Projekt-Budget verfehlt");
}