onedrop/

main.rs

//! OneDrop CLI - Command-line interface for MilkDrop visualizations

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use onedrop_engine::{EngineConfig, MeshQuality, MilkEngine, RenderConfig};
use std::path::PathBuf;

/// Parse `--mesh-size` arg: accepts named presets (`low`, `medium`,
/// `high`, `ultra`) or an explicit `COLSxROWS` form (e.g. `64x48`).
/// Returns the resolved `(cols, rows)`. Values are clamped to MD2's
/// `[2, 192] × [2, 96]` window downstream by `MilkRenderer::set_mesh_size`.
fn parse_mesh_size(s: &str) -> Result<(u32, u32), String> {
    let trimmed = s.trim();
    match trimmed.to_ascii_lowercase().as_str() {
        "low" => return Ok((32, 24)),
        "medium" | "med" => return Ok((48, 36)),
        "high" => return Ok((64, 48)),
        "ultra" => return Ok((96, 72)),
        _ => {}
    }
    let (c, r) = trimmed
        .split_once(['x', 'X', '×'])
        .ok_or_else(|| format!("expected COLSxROWS or a preset name, got {trimmed:?}"))?;
    let cols: u32 = c
        .trim()
        .parse()
        .map_err(|e| format!("invalid cols {c:?}: {e}"))?;
    let rows: u32 = r
        .trim()
        .parse()
        .map_err(|e| format!("invalid rows {r:?}: {e}"))?;
    Ok((cols, rows))
}

#[derive(Parser)]
#[command(name = "onedrop")]
#[command(author = "all3f0r1")]
#[command(version = "0.1.0")]
#[command(about = "OneDrop — pure-Rust MilkDrop 2.0d visualizer", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Enable verbose logging
    #[arg(short, long, global = true)]
    verbose: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Show information about a preset
    Info {
        /// Path to the .milk preset file
        preset: PathBuf,
    },

    /// Validate a preset file (or, with `--strict`, a directory of presets).
    Validate {
        /// Path to a `.milk` preset OR a directory containing `.milk`
        /// files. A directory is only accepted in `--strict` mode.
        preset: PathBuf,

        /// Run the full pipeline (parse + eval + warp HLSL→WGSL + comp
        /// HLSL→WGSL→naga-validate) and classify every failure by
        /// stage / kind. Emits a CSV alongside the input when run on
        /// a directory.
        #[arg(long)]
        strict: bool,

        /// CSV output path. Only used in `--strict` mode against a
        /// directory; defaults to `<dir>.validate_strict.csv` next to
        /// the input.
        #[arg(short, long)]
        output: Option<PathBuf>,
    },

    /// Render a preset to images
    Render {
        /// Path to the .milk preset file
        preset: PathBuf,

        /// Number of frames to render
        #[arg(short, long, default_value = "60")]
        frames: u32,

        /// Output directory for frames
        #[arg(short, long, default_value = "output")]
        output: PathBuf,

        /// Width of output
        #[arg(short, long, default_value = "1280")]
        width: u32,

        /// Height of output
        #[arg(short = 'H', long, default_value = "720")]
        height: u32,

        /// Warp mesh size. Accepts a preset name (`low`, `medium`,
        /// `high`, `ultra`) or an explicit `COLSxROWS` (e.g. `64x48`).
        /// Defaults to `medium` (48×36). MD2 caps at 192×96.
        #[arg(short = 'm', long, default_value = "medium", value_parser = parse_mesh_size)]
        mesh_size: (u32, u32),
    },

    /// List all presets in a directory
    List {
        /// Directory containing .milk files
        directory: PathBuf,
    },

    /// Try to compile every preset's comp shader through the user-shader
    /// pipeline (HLSL translate → WGSL wrap → naga validate). Reports
    /// success/fail counts and writes a CSV next to the directory.
    CompileShaders {
        /// Directory containing .milk files
        directory: PathBuf,

        /// Output CSV path (default: alongside the input dir).
        #[arg(short, long)]
        output: Option<PathBuf>,
    },

    /// List capture sources the active cpal host can see, with
    /// monitor / microphone / other classification. The autodetect
    /// pick (the monitor of the host's default output sink, when
    /// present) is flagged with an arrow — that's what
    /// `AudioInput::with_device(None)` opens at boot.
    ///
    /// If no monitor source shows up on a PipeWire system, load
    /// `module-loopback` (`pactl load-module module-loopback
    /// latency_msec=1`) so the sink monitor is exposed to ALSA /
    /// cpal — some distros ship a minimal PipeWire config that
    /// doesn't enable it by default.
    ListAudio,

    /// Render N frames through the full engine and report per-frame
    /// timing statistics (mean, std-dev, min, max, p50, p99). Output
    /// is on stdout — no PNGs are written, the engine runs purely
    /// for timing.
    Benchmark {
        /// Path to the .milk preset file
        preset: PathBuf,

        /// Number of frames to render. Default 1000 (roughly 16 s at
        /// 60 fps), which is enough to amortise compile / first-frame
        /// upload costs and still complete in seconds on a workstation.
        #[arg(short = 'n', long, default_value = "1000")]
        frames: u32,

        /// Render-target width.
        #[arg(short, long, default_value = "1280")]
        width: u32,

        /// Render-target height.
        #[arg(short = 'H', long, default_value = "720")]
        height: u32,

        /// Warp mesh size (see `render`'s `--mesh-size`).
        #[arg(short = 'm', long, default_value = "medium", value_parser = parse_mesh_size)]
        mesh_size: (u32, u32),
    },

    /// Emit the translated WGSL for a preset's warp and/or comp
    /// shader on stdout. Useful for debugging HLSL→WGSL translator
    /// output without standing up the renderer.
    DumpShader {
        /// Path to the .milk preset file
        preset: PathBuf,

        /// Which shader(s) to dump. `both` (default) prints warp then
        /// comp; `warp` or `comp` print only one.
        #[arg(short, long, default_value = "both", value_parser = parse_dump_kind)]
        kind: DumpKind,
    },
}

#[derive(Debug, Clone, Copy)]
enum DumpKind {
    Warp,
    Comp,
    Both,
}

fn parse_dump_kind(s: &str) -> Result<DumpKind, String> {
    match s.trim().to_ascii_lowercase().as_str() {
        "warp" => Ok(DumpKind::Warp),
        "comp" | "composite" => Ok(DumpKind::Comp),
        "both" | "all" => Ok(DumpKind::Both),
        other => Err(format!("expected warp|comp|both, got {other:?}")),
    }
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    // Initialize logger
    if cli.verbose {
        env_logger::Builder::from_default_env()
            .filter_level(log::LevelFilter::Debug)
            .init();
    } else {
        env_logger::Builder::from_default_env()
            .filter_level(log::LevelFilter::Info)
            .init();
    }

    match cli.command {
        Commands::Info { preset } => cmd_info(preset),
        Commands::Validate {
            preset,
            strict,
            output,
        } => cmd_validate(preset, strict, output),
        Commands::Render {
            preset,
            frames,
            output,
            width,
            height,
            mesh_size,
        } => cmd_render(preset, frames, output, width, height, mesh_size),
        Commands::List { directory } => cmd_list(directory),
        Commands::CompileShaders { directory, output } => cmd_compile_shaders(directory, output),
        Commands::ListAudio => cmd_list_audio(),
        Commands::Benchmark {
            preset,
            frames,
            width,
            height,
            mesh_size,
        } => cmd_benchmark(preset, frames, width, height, mesh_size),
        Commands::DumpShader { preset, kind } => cmd_dump_shader(preset, kind),
    }
}

fn cmd_list_audio() -> Result<()> {
    use onedrop_engine::{SourceKind, list_sources};

    let sources = list_sources();
    if sources.is_empty() {
        println!("No input devices reported by the active cpal host.");
        println!();
        println!("On PipeWire, the sink monitor may not be exposed by default.");
        println!("Try: pactl load-module module-loopback latency_msec=1");
        return Ok(());
    }

    println!("\n=== Audio capture sources ===\n");
    println!("  Arrow column legend: → autodetect pick (opened by `with_device(None)`)");
    println!("                       * host's default input (cpal-reported)");
    println!();

    let mut autodetect_seen = false;
    for s in &sources {
        let marker = match (s.is_autodetect_pick, s.is_host_default) {
            (true, _) => {
                autodetect_seen = true;
                "→"
            }
            (false, true) => "*",
            _ => " ",
        };
        let kind = match s.kind {
            SourceKind::Monitor => "monitor",
            SourceKind::Microphone => "mic    ",
            SourceKind::Other => "other  ",
        };
        println!("  {marker} [{kind}] {}", s.name);
    }

    if !autodetect_seen {
        println!();
        println!("No monitor source matched the default output sink. Autodetect will fall back to");
        println!("the first available `.monitor` device, then to the host's default input (`*`).");
        println!("On PipeWire, try `pactl load-module module-loopback latency_msec=1` to expose");
        println!("the sink monitor.");
    }

    Ok(())
}

fn cmd_info(preset_path: PathBuf) -> Result<()> {
    log::info!("Loading preset: {}", preset_path.display());

    let bytes = std::fs::read(&preset_path).context("Failed to read preset file")?;
    let content = String::from_utf8_lossy(&bytes).into_owned();

    let preset = onedrop_parser::parse_preset(&content).context("Failed to parse preset")?;

    println!("\n=== Preset Information ===\n");
    println!("Version: {}", preset.version);
    println!("Warp shader version: {}", preset.ps_version_warp);
    println!("Composite shader version: {}", preset.ps_version_comp);

    println!("\n--- Parameters ---");
    println!("Zoom: {}", preset.parameters.zoom);
    println!("Rotation: {}", preset.parameters.rot);
    println!("Decay: {}", preset.parameters.decay());
    println!(
        "Wave color: R={}, G={}, B={}",
        preset.parameters.wave_r, preset.parameters.wave_g, preset.parameters.wave_b
    );

    println!("\n--- Equations ---");
    println!("Per-frame equations: {}", preset.per_frame_equations.len());
    println!("Per-pixel equations: {}", preset.per_pixel_equations.len());

    if !preset.per_frame_equations.is_empty() {
        println!("\nPer-frame equations:");
        for (i, eq) in preset.per_frame_equations.iter().enumerate().take(5) {
            println!("  {}: {}", i + 1, eq);
        }
        if preset.per_frame_equations.len() > 5 {
            println!("  ... and {} more", preset.per_frame_equations.len() - 5);
        }
    }

    println!("\n--- Custom Elements ---");
    println!("Waves: {}", preset.waves.len());
    println!("Shapes: {}", preset.shapes.len());

    println!("\n--- Shaders ---");
    println!(
        "Warp shader: {}",
        if preset.warp_shader.is_some() {
            "Yes"
        } else {
            "No"
        }
    );
    println!(
        "Composite shader: {}",
        if preset.comp_shader.is_some() {
            "Yes"
        } else {
            "No"
        }
    );

    Ok(())
}

fn cmd_validate(preset_path: PathBuf, strict: bool, output: Option<PathBuf>) -> Result<()> {
    if preset_path.is_dir() {
        if !strict {
            anyhow::bail!(
                "validate <dir> requires --strict (the directory mode emits a CSV report)"
            );
        }
        return cmd_validate_strict_dir(preset_path, output);
    }

    log::info!("Validating preset: {}", preset_path.display());

    let bytes = std::fs::read(&preset_path).context("Failed to read preset file")?;
    let content = String::from_utf8_lossy(&bytes).into_owned();

    let preset = match onedrop_parser::parse_preset(&content) {
        Ok(p) => p,
        Err(e) => {
            println!("✗ Preset is invalid!");
            println!("  Error: {}", e);
            return Err(e.into());
        }
    };

    println!("✓ Preset is valid!");
    println!("  Version: {}", preset.version);
    println!(
        "  Per-frame equations: {}",
        preset.per_frame_equations.len()
    );
    println!(
        "  Per-pixel equations: {}",
        preset.per_pixel_equations.len()
    );

    if strict {
        let r = run_strict_pipeline(&preset_path, &content);
        println!("\n--- strict pipeline ---");
        report_strict_row_human(&r);
    }

    Ok(())
}

/// One row of the `validate --strict` CSV. Mirrors the fields of
/// `tools/src/sample.rs::PresetResult` so the long-tail triage workflow
/// works the same way whether you reach for the CLI or the bench tool.
#[derive(Debug, Default)]
struct StrictResult {
    name: String,
    parse_ok: bool,
    has_warp: bool,
    has_comp: bool,
    eval_ok: bool,
    eval_total: usize,
    eval_failed: usize,
    eval_first_error: String,
    warp_parse_ok: bool,
    warp_translate_ok: bool,
    warp_error: String,
    comp_compile_ok: bool,
    /// `parse` / `validate` / `translate` / `other` / "" when ok.
    comp_error_kind: String,
    comp_error: String,
    parse_error: String,
}

/// Run the full pipeline against one preset, collecting per-stage status.
fn run_strict_pipeline(path: &std::path::Path, content: &str) -> StrictResult {
    let mut r = StrictResult {
        name: path
            .file_name()
            .and_then(|s| s.to_str())
            .unwrap_or("?")
            .to_string(),
        ..Default::default()
    };

    let preset = match onedrop_parser::parse_preset(content) {
        Ok(p) => {
            r.parse_ok = true;
            p
        }
        Err(e) => {
            r.parse_error = strict_first_line(&format!("{e}"));
            return r;
        }
    };

    r.has_warp = preset.warp_shader.is_some();
    r.has_comp = preset.comp_shader.is_some();

    // Eval — use the paren-balance-aware list entry point so a
    // multi-line `loop(N, …; …; …)` counts as one block, matching the
    // metric used by the corpus bench.
    {
        let mut ev = onedrop_eval::MilkEvaluator::new();
        let mut all: Vec<String> = Vec::with_capacity(
            preset.per_frame_init_equations.len()
                + preset.per_frame_equations.len()
                + preset.per_pixel_equations.len(),
        );
        all.extend(preset.per_frame_init_equations.iter().cloned());
        all.extend(preset.per_frame_equations.iter().cloned());
        all.extend(preset.per_pixel_equations.iter().cloned());
        let stats = ev.eval_equation_list(&all);
        r.eval_total = stats.total;
        r.eval_failed = stats.failed;
        r.eval_ok = stats.failed == 0;
        r.eval_first_error = strict_first_line(&stats.first_error);
    }

    if let Some(hlsl) = preset.warp_shader.as_deref() {
        match onedrop_hlsl::parse::parse_hlsl(hlsl) {
            Ok(_) => {
                r.warp_parse_ok = true;
                match onedrop_hlsl::translate_shader(hlsl) {
                    Ok(_) => r.warp_translate_ok = true,
                    Err(e) => r.warp_error = strict_first_line(&format!("translate: {e}")),
                }
            }
            Err(e) => r.warp_error = strict_first_line(&format!("parse: {}", e.message)),
        }
    }

    if let Some(hlsl) = preset.comp_shader.as_deref() {
        let mut compiler = onedrop_codegen::ShaderCompiler::new();
        match compiler.compile_user_comp_shader(hlsl) {
            Ok(_) => r.comp_compile_ok = true,
            Err(e) => {
                let s = e.to_string();
                let kind = if s.contains("WGSL parse") {
                    "parse"
                } else if s.contains("Validation") {
                    "validate"
                } else if s.contains("translate") || s.contains("HLSL→WGSL") {
                    "translate"
                } else {
                    "other"
                };
                r.comp_error_kind = kind.to_string();
                r.comp_error = strict_first_line(&s);
            }
        }
    }

    r
}

/// Strict mode against a directory: walk every `.milk` file, run the
/// pipeline, emit a CSV report, and print a stage-by-stage summary so
/// the long tail can be triaged without re-reading the CSV.
fn cmd_validate_strict_dir(directory: PathBuf, output: Option<PathBuf>) -> Result<()> {
    use std::io::Write;

    let mut presets: Vec<PathBuf> = std::fs::read_dir(&directory)
        .with_context(|| format!("Failed to read directory {}", directory.display()))?
        .filter_map(|e| e.ok().map(|e| e.path()))
        .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("milk"))
        .collect();
    presets.sort();

    if presets.is_empty() {
        println!("No .milk presets found in {}", directory.display());
        return Ok(());
    }

    let csv_path = output.unwrap_or_else(|| {
        let mut p = directory.clone();
        let stem = p
            .file_name()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string())
            .unwrap_or_else(|| "presets".into());
        p.pop();
        p.push(format!("{stem}.validate_strict.csv"));
        p
    });

    let mut csv = std::fs::File::create(&csv_path)
        .with_context(|| format!("Failed to create CSV at {}", csv_path.display()))?;
    writeln!(
        csv,
        "name,parse_ok,has_warp,has_comp,eval_ok,eval_total,eval_failed,\
         warp_parse_ok,warp_translate_ok,comp_compile_ok,comp_error_kind,\
         parse_error,eval_first_error,warp_error,comp_error"
    )?;

    let total = presets.len();
    let mut results: Vec<StrictResult> = Vec::with_capacity(total);

    for (i, path) in presets.iter().enumerate() {
        let content = match std::fs::read(path) {
            Ok(b) => String::from_utf8_lossy(&b).into_owned(),
            Err(e) => {
                let mut r = StrictResult {
                    name: path
                        .file_name()
                        .and_then(|s| s.to_str())
                        .unwrap_or("?")
                        .to_string(),
                    ..Default::default()
                };
                r.parse_error = format!("read error: {e}");
                results.push(r);
                continue;
            }
        };
        let r = run_strict_pipeline(path, &content);
        results.push(r);

        if (i + 1).is_multiple_of(50) || i + 1 == total {
            log::info!("[{:>5}/{:>5}] strict-validating presets", i + 1, total);
        }
    }

    for r in &results {
        writeln!(
            csv,
            "\"{}\",{},{},{},{},{},{},{},{},{},{},\"{}\",\"{}\",\"{}\",\"{}\"",
            r.name.replace('"', "'"),
            r.parse_ok,
            r.has_warp,
            r.has_comp,
            r.eval_ok,
            r.eval_total,
            r.eval_failed,
            r.warp_parse_ok,
            r.warp_translate_ok,
            r.comp_compile_ok,
            r.comp_error_kind,
            csv_escape(&r.parse_error),
            csv_escape(&r.eval_first_error),
            csv_escape(&r.warp_error),
            csv_escape(&r.comp_error),
        )?;
    }

    print_strict_summary(&results, total);
    println!("\nCSV written: {}", csv_path.display());
    Ok(())
}

fn print_strict_summary(results: &[StrictResult], total: usize) {
    let pct = |n: usize, d: usize| -> f64 {
        if d == 0 {
            0.0
        } else {
            100.0 * n as f64 / d as f64
        }
    };

    let parse_ok = results.iter().filter(|r| r.parse_ok).count();
    let has_warp = results.iter().filter(|r| r.has_warp).count();
    let has_comp = results.iter().filter(|r| r.has_comp).count();
    let eval_ok = results.iter().filter(|r| r.parse_ok && r.eval_ok).count();
    let eval_partial = results
        .iter()
        .filter(|r| r.parse_ok && r.eval_failed > 0)
        .count();
    let warp_translate_ok = results
        .iter()
        .filter(|r| r.has_warp && r.warp_translate_ok)
        .count();
    let comp_compile_ok = results
        .iter()
        .filter(|r| r.has_comp && r.comp_compile_ok)
        .count();
    let all_green = results
        .iter()
        .filter(|r| {
            r.parse_ok
                && r.eval_ok
                && (!r.has_warp || r.warp_translate_ok)
                && (!r.has_comp || r.comp_compile_ok)
        })
        .count();

    println!("\n=== validate --strict summary ===");
    println!("sample size:       {}", total);
    println!(
        "parse OK:          {} ({:.1}%)",
        parse_ok,
        pct(parse_ok, total)
    );
    println!(
        "has warp:          {} ({:.1}%)",
        has_warp,
        pct(has_warp, total)
    );
    println!(
        "has comp:          {} ({:.1}%)",
        has_comp,
        pct(has_comp, total)
    );
    println!(
        "eval all-eqs OK:   {} ({:.1}% of parsed)  partial-fail: {}",
        eval_ok,
        pct(eval_ok, parse_ok),
        eval_partial
    );
    println!(
        "warp HLSL→WGSL OK: {} ({:.1}% of has_warp)",
        warp_translate_ok,
        pct(warp_translate_ok, has_warp)
    );
    println!(
        "comp compile OK:   {} ({:.1}% of has_comp)",
        comp_compile_ok,
        pct(comp_compile_ok, has_comp)
    );
    println!(
        "ALL-GREEN:         {} ({:.1}%) — parse+eval+warp+comp end-to-end",
        all_green,
        pct(all_green, total)
    );

    let mut comp_kinds: std::collections::BTreeMap<String, usize> = Default::default();
    for r in results {
        if r.has_comp && !r.comp_compile_ok {
            *comp_kinds.entry(r.comp_error_kind.clone()).or_default() += 1;
        }
    }
    if !comp_kinds.is_empty() {
        println!("\n--- comp failure stage breakdown ---");
        for (k, v) in &comp_kinds {
            println!("  {:<10} {}", k, v);
        }
    }

    let mut eval_buckets: std::collections::BTreeMap<String, usize> = Default::default();
    for r in results {
        if r.parse_ok && !r.eval_ok {
            *eval_buckets
                .entry(bucket_eval_error(&r.eval_first_error))
                .or_default() += 1;
        }
    }
    if !eval_buckets.is_empty() {
        println!("\n--- top eval error buckets ---");
        print_top_buckets(&eval_buckets, 12);
    }
}

fn print_top_buckets(m: &std::collections::BTreeMap<String, usize>, n: usize) {
    let mut v: Vec<(&String, &usize)> = m.iter().collect();
    v.sort_by(|a, b| b.1.cmp(a.1));
    for (k, c) in v.iter().take(n) {
        println!("  {:>4}  {}", c, k);
    }
}

/// Coarse-grained classification of an eval error message. Matches the
/// buckets used by `tools/src/sample.rs` so a CLI run and a bench run
/// produce comparable stats.
fn bucket_eval_error(s: &str) -> String {
    let low = s.to_lowercase();
    if low.contains("undefined") || low.contains("unknown") || low.contains("not found") {
        "undefined identifier".into()
    } else if low.contains("syntax") || low.contains("parse") {
        "syntax/parse".into()
    } else if low.contains("type") {
        "type error".into()
    } else if low.contains("division") || low.contains("divide") {
        "division".into()
    } else {
        let cut = s
            .char_indices()
            .find(|(i, c)| *i >= 24 && (*c == ':' || *c == ';' || *c == '@'))
            .map(|(i, _)| i)
            .unwrap_or_else(|| s.len().min(120));
        s[..cut].trim().to_string()
    }
}

/// Single-preset strict report renderer for `validate --strict <file>`.
fn report_strict_row_human(r: &StrictResult) {
    println!("  parse:    {}", if r.parse_ok { "ok" } else { "FAIL" });
    if !r.parse_error.is_empty() {
        println!("    error:  {}", r.parse_error);
    }
    println!(
        "  eval:     {}{}",
        if r.eval_ok { "ok" } else { "FAIL" },
        if r.eval_total > 0 {
            format!(" ({} eqs, {} failed)", r.eval_total, r.eval_failed)
        } else {
            String::new()
        }
    );
    if !r.eval_first_error.is_empty() {
        println!("    error:  {}", r.eval_first_error);
    }
    if r.has_warp {
        println!(
            "  warp:     parse={} translate={}",
            if r.warp_parse_ok { "ok" } else { "FAIL" },
            if r.warp_translate_ok { "ok" } else { "FAIL" }
        );
        if !r.warp_error.is_empty() {
            println!("    error:  {}", r.warp_error);
        }
    }
    if r.has_comp {
        println!(
            "  comp:     compile={}{}",
            if r.comp_compile_ok { "ok" } else { "FAIL" },
            if r.comp_error_kind.is_empty() {
                String::new()
            } else {
                format!(" (kind={})", r.comp_error_kind)
            }
        );
        if !r.comp_error.is_empty() {
            println!("    error:  {}", r.comp_error);
        }
    }
}

fn strict_first_line(s: &str) -> String {
    s.lines()
        .next()
        .unwrap_or("")
        .chars()
        .take(240)
        .collect::<String>()
        .replace('"', "'")
}

fn cmd_render(
    preset_path: PathBuf,
    frames: u32,
    output_dir: PathBuf,
    width: u32,
    height: u32,
    mesh_size: (u32, u32),
) -> Result<()> {
    log::info!("Rendering preset: {}", preset_path.display());
    log::info!("Output: {} frames to {}", frames, output_dir.display());
    log::info!("Resolution: {}x{}", width, height);
    let mesh_label = MeshQuality::from_size(mesh_size.0, mesh_size.1)
        .map(|q| q.label().to_string())
        .unwrap_or_else(|| format!("Custom ({}×{})", mesh_size.0, mesh_size.1));
    log::info!("Mesh: {}", mesh_label);

    // Create output directory
    std::fs::create_dir_all(&output_dir).context("Failed to create output directory")?;

    // Create engine
    let config = EngineConfig {
        render_config: RenderConfig {
            width,
            height,
            mesh_cols: mesh_size.0,
            mesh_rows: mesh_size.1,
            ..Default::default()
        },
        ..Default::default()
    };

    let mut engine =
        pollster::block_on(MilkEngine::new(config)).context("Failed to create engine")?;

    // Load preset
    engine
        .load_preset(&preset_path)
        .context("Failed to load preset")?;

    println!("Rendering {} frames...", frames);

    let (rt_w, rt_h) = engine.renderer().render_size();

    // Render frames
    for frame in 0..frames {
        // Generate some audio (sine wave for demo)
        let audio_samples: Vec<f32> = (0..1024)
            .map(|i| {
                let t = (frame * 1024 + i) as f32 * 0.001;
                (t * 2.0 * std::f32::consts::PI * 60.0).sin() * 0.5
            })
            .collect();

        // Update engine
        engine
            .update(&audio_samples, 0.016)
            .context("Failed to update engine")?;

        // Read back the display texture (always RGBA8) and write a PNG.
        // The renderer-side helper is a synchronous CPU stall — fine
        // for offline render, catastrophic in the live path.
        let bytes = engine
            .renderer()
            .read_render_texture()
            .context("Failed to read back display texture")?;
        let path = output_dir.join(format!("frame_{frame:05}.png"));
        image::save_buffer(&path, &bytes, rt_w, rt_h, image::ExtendedColorType::Rgba8)
            .with_context(|| format!("Failed to write {}", path.display()))?;

        // Progress indicator
        if frame % 10 == 0 || frame == frames - 1 {
            println!(
                "  Frame {}/{} ({:.1}%)",
                frame + 1,
                frames,
                (frame + 1) as f32 / frames as f32 * 100.0
            );
        }
    }

    println!("\n✓ Rendering complete!");
    println!("  Output: {}", output_dir.display());

    Ok(())
}

fn cmd_list(directory: PathBuf) -> Result<()> {
    log::info!("Listing presets in: {}", directory.display());

    let entries = std::fs::read_dir(&directory).context("Failed to read directory")?;

    let mut presets = Vec::new();

    for entry in entries {
        let entry = entry?;
        let path = entry.path();

        if path.extension().and_then(|s| s.to_str()) == Some("milk") {
            presets.push(path);
        }
    }

    if presets.is_empty() {
        println!("No .milk presets found in {}", directory.display());
        return Ok(());
    }

    presets.sort();

    println!("\n=== Presets in {} ===\n", directory.display());
    println!("Found {} preset(s):\n", presets.len());

    for (i, preset) in presets.iter().enumerate() {
        println!(
            "  {}. {}",
            i + 1,
            preset.file_name().unwrap().to_string_lossy()
        );
    }

    Ok(())
}

/// Iterate `.milk` files in `directory`, attempt to compile each preset's
/// `comp_shader` HLSL through the user-shader pipeline, and write a CSV
/// report (`name,has_comp_shader,parse_ok,compile_ok,error_kind,error_excerpt`).
///
/// Acceptance criterion: with the post-naga AST translator, ≥30% of
/// in-the-wild presets should compile. With the current regex-based
/// translator the rate is much lower; this command makes the gap
/// quantifiable and locks a baseline.
fn cmd_compile_shaders(directory: PathBuf, output: Option<PathBuf>) -> Result<()> {
    use onedrop_codegen::ShaderCompiler;
    use std::io::Write;

    let mut presets: Vec<PathBuf> = std::fs::read_dir(&directory)?
        .filter_map(|e| e.ok().map(|e| e.path()))
        .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("milk"))
        .collect();
    presets.sort();

    if presets.is_empty() {
        println!("No .milk presets found in {}", directory.display());
        return Ok(());
    }

    let csv_path = output.unwrap_or_else(|| {
        let mut p = directory.clone();
        p.set_extension("compile_report.csv");
        p
    });

    let mut csv = std::fs::File::create(&csv_path)
        .with_context(|| format!("Failed to create CSV at {}", csv_path.display()))?;
    writeln!(
        csv,
        "name,has_comp_shader,parse_ok,compile_ok,error_kind,error_excerpt"
    )?;

    let mut compiler = ShaderCompiler::new();
    let total = presets.len();
    let mut parse_ok = 0;
    let mut has_comp = 0;
    let mut compile_ok = 0;

    for path in &presets {
        let name = path
            .file_name()
            .and_then(|s| s.to_str())
            .unwrap_or("?")
            .to_string();
        let raw = match std::fs::read(path) {
            Ok(b) => String::from_utf8_lossy(&b).into_owned(),
            Err(e) => {
                writeln!(
                    csv,
                    "\"{name}\",unknown,false,false,read_error,\"{}\"",
                    csv_escape(&e.to_string())
                )?;
                continue;
            }
        };
        let preset = match onedrop_parser::parse_preset(&raw) {
            Ok(p) => {
                parse_ok += 1;
                p
            }
            Err(e) => {
                writeln!(
                    csv,
                    "\"{name}\",unknown,false,false,parse_error,\"{}\"",
                    csv_escape(&e.to_string())
                )?;
                continue;
            }
        };

        let Some(comp_hlsl) = preset.comp_shader.as_deref() else {
            writeln!(csv, "\"{name}\",false,true,false,no_comp_shader,")?;
            continue;
        };
        has_comp += 1;

        match compiler.compile_user_comp_shader(comp_hlsl) {
            Ok(_) => {
                compile_ok += 1;
                writeln!(csv, "\"{name}\",true,true,true,,")?;
            }
            Err(e) => {
                let s = e.to_string();
                let (kind, excerpt) = if s.contains("WGSL parse") {
                    ("parse", first_line(&s))
                } else if s.contains("Validation") {
                    ("validate", first_line(&s))
                } else {
                    ("translate", first_line(&s))
                };
                writeln!(
                    csv,
                    "\"{name}\",true,true,false,{kind},\"{}\"",
                    csv_escape(&excerpt)
                )?;
            }
        }
    }

    println!("\n=== Comp shader compile report ===");
    println!("Directory:           {}", directory.display());
    println!("Presets scanned:     {total}");
    println!("Parse OK:            {parse_ok}");
    println!(
        "Has comp_shader:     {has_comp} ({:.1}%)",
        if total > 0 {
            100.0 * has_comp as f64 / total as f64
        } else {
            0.0
        }
    );
    println!(
        "Compile OK:          {compile_ok} ({:.1}% of total, {:.1}% of those with shader)",
        if total > 0 {
            100.0 * compile_ok as f64 / total as f64
        } else {
            0.0
        },
        if has_comp > 0 {
            100.0 * compile_ok as f64 / has_comp as f64
        } else {
            0.0
        }
    );
    println!("CSV written to:      {}", csv_path.display());

    Ok(())
}

fn csv_escape(s: &str) -> String {
    // Replace double quotes (terminator) and commas (separator) with safe
    // single-character substitutes so the field stays in one CSV cell.
    s.replace('"', "'").replace(',', ";")
}

fn first_line(s: &str) -> String {
    s.lines().next().unwrap_or("").chars().take(140).collect()
}

/// Run `frames` frames through the engine and print per-frame timing
/// statistics. The first frame is excluded from the summary (compile +
/// upload one-shot costs would skew the mean).
fn cmd_benchmark(
    preset_path: PathBuf,
    frames: u32,
    width: u32,
    height: u32,
    mesh_size: (u32, u32),
) -> Result<()> {
    log::info!("Benchmarking preset: {}", preset_path.display());
    log::info!("Frames: {}, resolution: {}x{}", frames, width, height);

    let config = EngineConfig {
        render_config: RenderConfig {
            width,
            height,
            mesh_cols: mesh_size.0,
            mesh_rows: mesh_size.1,
            ..Default::default()
        },
        ..Default::default()
    };
    let mut engine =
        pollster::block_on(MilkEngine::new(config)).context("Failed to create engine")?;
    engine
        .load_preset(&preset_path)
        .context("Failed to load preset")?;

    let frame_count = frames.max(2) as usize;
    let mut frame_us: Vec<f64> = Vec::with_capacity(frame_count);

    let audio_samples: Vec<f32> = (0..1024)
        .map(|i| {
            let t = i as f32 * 0.001;
            (t * 2.0 * std::f32::consts::PI * 60.0).sin() * 0.5
        })
        .collect();

    println!("Running {frame_count} frames...");
    for _ in 0..frame_count {
        let t0 = std::time::Instant::now();
        engine
            .update(&audio_samples, 1.0 / 60.0)
            .context("Failed to update engine")?;
        let dt = t0.elapsed().as_secs_f64() * 1_000.0; // ms
        frame_us.push(dt);
    }

    // Skip the first frame from the summary — pipeline / cache warm-up
    // dominates it on every run and biases the mean upward.
    let warmed: Vec<f64> = frame_us.iter().skip(1).copied().collect();
    let n = warmed.len() as f64;
    let mean = warmed.iter().sum::<f64>() / n;
    let var = warmed.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / n;
    let stddev = var.sqrt();
    let min = warmed.iter().cloned().fold(f64::INFINITY, f64::min);
    let max = warmed.iter().cloned().fold(f64::NEG_INFINITY, f64::max);

    let mut sorted = warmed.clone();
    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let p = |q: f64| -> f64 {
        let idx = ((sorted.len() as f64 - 1.0) * q).round() as usize;
        sorted[idx.min(sorted.len() - 1)]
    };

    let warmup_ms = frame_us[0];
    let total_s: f64 = warmed.iter().sum::<f64>() / 1_000.0;
    let avg_fps = if mean > 0.0 { 1_000.0 / mean } else { 0.0 };

    println!();
    println!("=== Benchmark summary ===");
    println!("  Preset:       {}", preset_path.display());
    println!("  Frames:       {} (1 warm-up excluded)", frame_count);
    println!("  Warm-up:      {:>8.3} ms (frame 0)", warmup_ms);
    println!("  Mean:         {:>8.3} ms  ({:.1} fps avg)", mean, avg_fps);
    println!("  Std-dev:      {:>8.3} ms", stddev);
    println!("  Min:          {:>8.3} ms", min);
    println!("  p50:          {:>8.3} ms", p(0.50));
    println!("  p99:          {:>8.3} ms", p(0.99));
    println!("  Max:          {:>8.3} ms", max);
    println!("  Wall time:    {:>8.3} s", total_s);
    Ok(())
}

/// Run a preset's `warp_shader` / `comp_shader` HLSL through the
/// translator and print the resulting WGSL on stdout. Failures print
/// the translator's error to stderr and continue (so `--kind=both`
/// still emits the other shader). Exit code is non-zero only when
/// nothing at all could be emitted.
fn cmd_dump_shader(preset_path: PathBuf, kind: DumpKind) -> Result<()> {
    let content = std::fs::read_to_string(&preset_path)
        .with_context(|| format!("Failed to read {}", preset_path.display()))?;
    let preset = onedrop_parser::parse_preset(&content).context("Failed to parse preset")?;

    let mut compiler = onedrop_codegen::ShaderCompiler::new();
    let mut emitted_any = false;

    if matches!(kind, DumpKind::Warp | DumpKind::Both) {
        if let Some(hlsl) = preset.warp_shader.as_deref() {
            println!("// ===== WARP SHADER =====");
            match compiler.compile_user_warp_shader(hlsl) {
                Ok(c) => {
                    println!("{}", c.source);
                    emitted_any = true;
                }
                Err(e) => {
                    eprintln!("warp: translation failed: {e}");
                }
            }
        } else if matches!(kind, DumpKind::Warp) {
            eprintln!("warp: preset has no `warp_shader` block");
        }
    }

    if matches!(kind, DumpKind::Comp | DumpKind::Both) {
        if let Some(hlsl) = preset.comp_shader.as_deref() {
            if matches!(kind, DumpKind::Both) {
                println!();
            }
            println!("// ===== COMP SHADER =====");
            match compiler.compile_user_comp_shader(hlsl) {
                Ok(c) => {
                    println!("{}", c.source);
                    emitted_any = true;
                }
                Err(e) => {
                    eprintln!("comp: translation failed: {e}");
                }
            }
        } else if matches!(kind, DumpKind::Comp) {
            eprintln!("comp: preset has no `comp_shader` block");
        }
    }

    if !emitted_any {
        anyhow::bail!("nothing emitted — preset has no shader of the requested kind");
    }
    Ok(())
}