//! JSON report writer. One file per workload run, under `report_dir`
//! (`./runs/` by default). Schema v2: run metadata, workload verdict,
//! and the perf score. No sensor fields — aldermon owns sensors; this
//! report only records what the workload itself produced.
//!
//! Incremental flush: the whole file is rewritten on each call. A v2
//! report is small (no per-tick samples), so we only flush once at
//! `finish()` — partial runs leave a JSON file with verdict=null +
//! score=null, which is parseable.
//!
//! Zero-dep: hand-rolled JSON. The schema is flat enough that serde_json
//! would be one dep for little gain; revisit if the schema nests deeper.

#![allow(dead_code)] // consumed by run.rs + main.rs — not yet wired

use std::fs::{self, File};
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};

use crate::workload::{Score, Verdict};

/// The data captured for one workload run. The run loop owns this,
/// feeds it the verdict + score when the workload completes, and calls
/// `finish()` to flush.
pub struct Report {
    pub schema_version: u32,
    pub workload: String,
    pub params: String,
    /// Unix timestamp (seconds) when the run started.
    pub started: u64,
    /// ISA class — "integer", "sse", "avx2", "mixed", or "other".
    /// Inferred from the workload name (see `isa_class`).
    pub isa_class: &'static str,
    /// Set by `finish()`. None until the workload completes.
    pub verdict: Option<Verdict>,
    /// Set by `finish()`. None for stability-only workloads (stress-ng),
    /// or until the workload completes.
    pub score: Option<Score>,
    /// Path the report will be written to (set at construction).
    path: PathBuf,
}

impl Report {
    /// Construct a new report for a workload. Creates `report_dir` if
    /// missing. The filename is `<unix-seconds>-<workload>.json`.
    pub fn new(report_dir: &Path, workload: &str, params: &str) -> io::Result<Self> {
        fs::create_dir_all(report_dir)?;
        let started = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map(|d| d.as_secs())
            .unwrap_or(0);
        // Sanitize the workload name for the filename (replace chars that
        // are hostile to filesystems).
        let safe = workload.replace(['/', ' ', ':'], "_");
        let path = report_dir.join(format!("{started}-{safe}.json"));
        Ok(Report {
            schema_version: 2,
            workload: workload.to_string(),
            params: params.to_string(),
            started,
            isa_class: isa_class(workload),
            verdict: None,
            score: None,
            path,
        })
    }

    /// Mark the run complete + flush the final state with the verdict +
    /// score. Called once, after the workload has exited and its score
    /// has been parsed. The score is stored verbatim — `Score::None` is
    /// kept (so `human_summary` can distinguish "stability-only workload"
    /// from "not finished"), and `json_score` renders it as `null`.
    pub fn finish(&mut self, verdict: Verdict, score: Score) -> io::Result<()> {
        self.verdict = Some(verdict);
        self.score = Some(score);
        self.flush()
    }

    /// Where the report is being written. The run loop may want this for
    /// the TUI / stdout summary.
    pub fn path(&self) -> &Path {
        &self.path
    }

    fn flush(&self) -> io::Result<()> {
        let mut f = File::create(&self.path)?;
        f.write_all(self.to_json().as_bytes())?;
        f.sync_all().ok(); // best-effort; don't fail the run on sync error
        Ok(())
    }

    /// Serialize to a JSON string. Used by `flush()` and by the
    /// `--report <path>` printer in main.rs.
    pub fn to_json(&self) -> String {
        let mut out = String::with_capacity(1024);
        out.push('{');
        out.push_str(&format!("\"schema_version\":{},", self.schema_version));
        out.push_str(&format!("\"workload\":{},", json_str(&self.workload)));
        out.push_str(&format!("\"params\":{},", json_str(&self.params)));
        out.push_str(&format!("\"started\":{},", self.started));
        out.push_str(&format!("\"isa_class\":{},", json_str(self.isa_class)));
        out.push_str(&format!("\"verdict\":{},", json_verdict(&self.verdict)));
        out.push_str(&format!("\"score\":{}", json_score(&self.score)));
        out.push('}');
        out
    }
}

/// JSON-encode a string. Escapes the minimal set (quote, backslash,
/// control chars). Assumes UTF-8 input (Rust strings are).
fn json_str(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 2);
    out.push('"');
    for c in s.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            c => out.push(c),
        }
    }
    out.push('"');
    out
}

/// JSON-encode the verdict. None (run not finished) → `null`; otherwise
/// an object with `kind` + optional `detail`.
fn json_verdict(v: &Option<Verdict>) -> String {
    match v {
        None => "null".to_string(),
        Some(Verdict::Clean) => "{\"kind\":\"clean\"}".to_string(),
        Some(Verdict::Failed(msg)) => format!("{{\"kind\":\"failed\",\"detail\":{}}}", json_str(msg)),
        Some(Verdict::Stopped) => "{\"kind\":\"stopped\"}".to_string(),
        Some(Verdict::Error(msg)) => format!("{{\"kind\":\"error\",\"detail\":{}}}", json_str(msg)),
    }
}

/// JSON-encode a Score. None (no score / not finished) → `null`.
/// Otherwise an object with `kind` + the per-kind fields.
fn json_score(s: &Option<Score>) -> String {
    match s {
        None => "null".to_string(),
        Some(Score::None) => "null".to_string(),
        Some(Score::SevenZip {
            rating_mips,
            r_u_mips,
            usage_pct,
            compress_mips,
            decompress_mips,
        }) => format!(
            "{{\"kind\":\"7zip\",\"rating_mips\":{rating_mips},\"r_u_mips\":{r_u_mips},\
             \"usage_pct\":{usage_pct},\"compress_mips\":{compress_mips},\
             \"decompress_mips\":{decompress_mips}}}"
        ),
        Some(Score::YCruncher { tests }) => {
            let mut out = String::from("{\"kind\":\"y-cruncher\",\"tests\":[");
            for (i, t) in tests.iter().enumerate() {
                if i > 0 {
                    out.push(',');
                }
                out.push_str(&format!(
                    "{{\"tag\":{},\"passed\":{},\"bits_per_sec\":{}}}",
                    json_str(&t.tag),
                    t.passed,
                    t.bits_per_sec
                ));
            }
            out.push_str("]}");
            out
        }
    }
}

/// Infer the ISA class from the workload name. Used for the report's
/// `isa_class` field so sweeps can be grouped/diffed by rail.
pub fn isa_class(workload: &str) -> &'static str {
    match workload {
        "stress-ng-cpu" => "integer",
        "y-cruncher-sse" => "sse",
        "y-cruncher-avx2" => "avx2",
        "7zip-bench" => "mixed",
        "c2c-latency" | "dram-latency" => "other",
        _ => "other",
    }
}

/// Human-readable one-line summary of a finished report. Printed to
/// stdout after the TUI exits, one per workload in the sweep.
pub fn human_summary(r: &Report) -> String {
    let verdict = match &r.verdict {
        Some(Verdict::Clean) => "CLEAN".to_string(),
        Some(Verdict::Failed(msg)) => format!("FAILED ({msg})"),
        Some(Verdict::Stopped) => "STOPPED".to_string(),
        Some(Verdict::Error(msg)) => format!("ERROR ({msg})"),
        None => "(not finished)".to_string(),
    };
    let score = match &r.score {
        None => "(no score)".to_string(),
        Some(Score::None) => "(stability only)".to_string(),
        Some(Score::SevenZip { rating_mips, .. }) => format!("rating={rating_mips} MIPS"),
        Some(Score::YCruncher { tests }) => {
            if tests.len() == 1 {
                let t = &tests[0];
                let gbps = t.bits_per_sec / 1e9;
                format!("{} {:.2} Gb/s", t.tag, gbps)
            } else {
                format!("{} tests", tests.len())
            }
        }
    };
    format!(
        "{:<18} {:<8} {:<24} verdict={}",
        r.workload, r.isa_class, score, verdict
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::workload::YCruncherTest;

    /// Unique dir per test (by test name) so tests don't race on a shared
    /// directory when one test's `remove_dir_all` wipes another's parent.
    fn test_dir(name: &str) -> std::path::PathBuf {
        std::path::PathBuf::from("/tmp/opencode/test-reports").join(name)
    }

    fn sample_report() -> Report {
        let mut r = Report::new(&test_dir("sample_report"), "y-cruncher-avx2", "60s cores=0-15 FFTv4")
            .unwrap();
        r.finish(
            Verdict::Clean,
            Score::YCruncher {
                tests: vec![YCruncherTest {
                    tag: "FFTv4".to_string(),
                    passed: true,
                    bits_per_sec: 8.94e8,
                }],
            },
        )
        .unwrap();
        r
    }

    #[test]
    fn isa_class_infers_from_name() {
        assert_eq!(isa_class("stress-ng-cpu"), "integer");
        assert_eq!(isa_class("y-cruncher-sse"), "sse");
        assert_eq!(isa_class("y-cruncher-avx2"), "avx2");
        assert_eq!(isa_class("7zip-bench"), "mixed");
        assert_eq!(isa_class("c2c-latency"), "other");
        assert_eq!(isa_class("unknown-future"), "other");
    }

    #[test]
    fn json_escapes_strings() {
        assert_eq!(json_str("hello"), "\"hello\"");
        assert_eq!(json_str("a\"b"), "\"a\\\"b\"");
        assert_eq!(json_str("a\\b"), "\"a\\\\b\"");
        assert_eq!(json_str("a\nb"), "\"a\\nb\"");
        assert_eq!(json_str(""), "\"\"");
    }

    #[test]
    fn json_verdict_variants() {
        assert_eq!(json_verdict(&None), "null");
        assert_eq!(json_verdict(&Some(Verdict::Clean)), "{\"kind\":\"clean\"}");
        assert_eq!(json_verdict(&Some(Verdict::Stopped)), "{\"kind\":\"stopped\"}");
        assert!(json_verdict(&Some(Verdict::Failed("oops".to_string()))).contains("\"kind\":\"failed\""));
        assert!(json_verdict(&Some(Verdict::Failed("oops".to_string()))).contains("\"detail\":\"oops\""));
    }

    #[test]
    fn json_score_null_for_none() {
        assert_eq!(json_score(&None), "null");
        assert_eq!(json_score(&Some(Score::None)), "null");
    }

    #[test]
    fn json_score_7zip_round_trips() {
        let s = Score::SevenZip {
            rating_mips: 66259,
            r_u_mips: 4653,
            usage_pct: 1431,
            compress_mips: 5346,
            decompress_mips: 3961,
        };
        let j = json_score(&Some(s));
        assert!(j.contains("\"kind\":\"7zip\""));
        assert!(j.contains("\"rating_mips\":66259"));
        assert!(j.contains("\"r_u_mips\":4653"));
        assert!(j.contains("\"usage_pct\":1431"));
        assert!(j.contains("\"compress_mips\":5346"));
        assert!(j.contains("\"decompress_mips\":3961"));
    }

    #[test]
    fn json_score_ycruncher_round_trips() {
        let s = Score::YCruncher {
            tests: vec![
                YCruncherTest { tag: "FFTv4".to_string(), passed: true, bits_per_sec: 8.94e8 },
                YCruncherTest { tag: "BKT".to_string(), passed: true, bits_per_sec: 9.49e9 },
            ],
        };
        let j = json_score(&Some(s));
        assert!(j.contains("\"kind\":\"y-cruncher\""));
        assert!(j.contains("\"tag\":\"FFTv4\""));
        assert!(j.contains("\"passed\":true"));
        assert!(j.contains("\"bits_per_sec\":894000000"));
        assert!(j.contains("\"tag\":\"BKT\""));
    }

    #[test]
    fn finish_stores_score_and_verdict() {
        let mut r = Report::new(&test_dir("finish_stores_score_and_verdict"), "test", "test").unwrap();
        r.finish(
            Verdict::Clean,
            Score::SevenZip {
                rating_mips: 1000,
                r_u_mips: 500,
                usage_pct: 1500,
                compress_mips: 700,
                decompress_mips: 300,
            },
        )
        .unwrap();
        assert_eq!(r.verdict, Some(Verdict::Clean));
        assert!(matches!(r.score, Some(Score::SevenZip { .. })));
    }

    #[test]
    fn finish_keeps_none_score_for_summary() {
        let mut r = Report::new(&test_dir("finish_keeps_none_score_for_summary"), "test", "test").unwrap();
        r.finish(Verdict::Clean, Score::None).unwrap();
        // Stored as Some(Score::None) so human_summary can distinguish
        // "stability only" from "not finished". JSON still renders null.
        assert_eq!(r.score, Some(Score::None));
        assert!(r.to_json().contains("\"score\":null"));
    }

    #[test]
    fn to_json_has_schema_v2() {
        let r = sample_report();
        let j = r.to_json();
        assert!(j.contains("\"schema_version\":2"));
        assert!(!j.contains("\"samples\"")); // v1 field, gone
        assert!(!j.contains("\"peak_clock_khz\"")); // v1 field, gone
    }

    #[test]
    fn to_json_is_valid_structure() {
        let r = sample_report();
        let j = r.to_json();
        assert!(j.starts_with('{'));
        assert!(j.ends_with('}'));
        assert!(j.contains("\"workload\":\"y-cruncher-avx2\""));
        assert!(j.contains("\"isa_class\":\"avx2\""));
        assert!(j.contains("\"verdict\":{\"kind\":\"clean\"}"));
        assert!(j.contains("\"kind\":\"y-cruncher\""));
        assert!(j.contains("\"tag\":\"FFTv4\""));
        assert!(j.contains("\"bits_per_sec\":894000000"));
    }

    #[test]
    fn flush_writes_readable_file() {
        let dir = test_dir("flush_writes_readable_file");
        let _ = fs::remove_dir_all(&dir);
        let mut r = Report::new(&dir, "flush-test", "30s cores=0-15").unwrap();
        r.finish(Verdict::Clean, Score::None).unwrap();
        let written = fs::read_to_string(r.path()).unwrap();
        assert!(written.contains("\"workload\":\"flush-test\""));
        assert!(written.contains("\"verdict\":{\"kind\":\"clean\"}"));
        assert!(written.contains("\"score\":null"));
        assert!(r.path().file_name().unwrap().to_str().unwrap().contains("flush-test.json"));
    }

    #[test]
    fn human_summary_formats_one_line() {
        let r = sample_report();
        let s = human_summary(&r);
        assert!(s.contains("y-cruncher-avx2"));
        assert!(s.contains("avx2"));
        assert!(s.contains("CLEAN"));
        assert!(s.contains("FFTv4"));
        assert!(s.contains("Gb/s"));
    }

    #[test]
    fn human_summary_for_7zip() {
        let mut r = Report::new(&test_dir("human_summary_for_7zip"), "7zip-bench", "60s").unwrap();
        r.finish(
            Verdict::Clean,
            Score::SevenZip {
                rating_mips: 66259,
                r_u_mips: 4653,
                usage_pct: 1431,
                compress_mips: 5346,
                decompress_mips: 3961,
            },
        )
        .unwrap();
        let s = human_summary(&r);
        assert!(s.contains("66259 MIPS"));
        assert!(s.contains("mixed"));
    }

    #[test]
    fn human_summary_for_stability_only() {
        let mut r = Report::new(&test_dir("human_summary_for_stability_only"), "stress-ng-cpu", "60s").unwrap();
        r.finish(Verdict::Clean, Score::None).unwrap();
        let s = human_summary(&r);
        assert!(s.contains("(stability only)"));
        assert!(s.contains("integer"));
        assert!(s.contains("CLEAN"));
    }

    #[test]
    fn filename_sanitizes_workload_name() {
        let dir = test_dir("filename_sanitizes_workload_name");
        let _ = fs::remove_dir_all(&dir);
        let r = Report::new(&dir, "workload/with:spaces", "test").unwrap();
        let name = r.path().file_name().unwrap().to_str().unwrap();
        assert!(!name.contains('/'));
        assert!(!name.contains(':'));
        assert!(!name.contains(' '));
    }
}