render.rs

//! Markdown rendering of a [`Report`] into the PR comment.
//!
//! Layout priority (from the spec): headline sentence first, one focused table,
//! the "why" callout, everything else collapsed. If the reader has to scroll to
//! learn the point, we failed.

use crate::attribute::Attribution;
use crate::compare::{Report, Status};
use std::collections::BTreeMap;
use std::fmt::Write;

/// Hidden marker so re-runs can find and PATCH the existing comment instead of
/// posting a new one each time.
pub const MARKER: &str = "<!-- bloatbot -->";

/// Format a byte count as a human-readable string using binary (KiB/MiB) units,
/// matching how `cargo bloat` reports sizes.
pub fn human_bytes(n: u64) -> String {
    const KIB: f64 = 1024.0;
    const MIB: f64 = KIB * 1024.0;
    const GIB: f64 = MIB * 1024.0;
    let f = n as f64;
    if f >= GIB {
        format!("{:.2} GiB", f / GIB)
    } else if f >= MIB {
        format!("{:.2} MiB", f / MIB)
    } else if f >= KIB {
        format!("{:.1} KiB", f / KIB)
    } else {
        format!("{n} B")
    }
}

/// Format a signed delta with an explicit sign, e.g. `+41.0 KiB`, `-80.0 KiB`, `0 B`.
pub fn human_delta(delta: i64) -> String {
    match delta {
        0 => "0 B".to_string(),
        d if d > 0 => format!("+{}", human_bytes(d as u64)),
        d => format!("-{}", human_bytes(d.unsigned_abs())),
    }
}

fn status_icon(status: Status, is_workspace: bool) -> &'static str {
    match status {
        Status::New => "🆕",
        Status::Removed => "🗑️",
        Status::Grew if is_workspace => "🔺",
        Status::Grew => "🔺",
        Status::Shrank => "🔻",
        Status::Unchanged => "▪️",
    }
}

fn pct_cell(row: &crate::compare::CrateDelta) -> String {
    match row.status {
        Status::New => "new".to_string(),
        Status::Removed => "removed".to_string(),
        _ => match row.delta_percent() {
            Some(p) => format!("{p:+.1}%"),
            None => "—".to_string(),
        },
    }
}

/// Render the full sticky comment body.
///
/// `attributions` maps crate name -> cause attribution (lock-diff + dependency
/// chain). It is optional so the core diff still renders when attribution is off
/// or unavailable (e.g. fork PRs).
pub fn render(report: &Report, attributions: &BTreeMap<String, Attribution>) -> String {
    let mut out = String::new();
    let _ = writeln!(out, "{MARKER}");

    // ---- Headline -----------------------------------------------------------
    let delta = report.file_delta();
    let pct = report
        .file_delta_percent()
        .map(|p| format!(" ({p:+.1}%)"))
        .unwrap_or_default();
    let verb = if delta > 0 {
        "grew"
    } else if delta < 0 {
        "shrank"
    } else {
        "is unchanged"
    };
    if delta == 0 {
        let _ = writeln!(out, "### 📦 Binary size: `{}` is unchanged", report.binary);
    } else {
        let _ = writeln!(
            out,
            "### 📦 Binary size: `{}` {} {}{}",
            report.binary,
            verb,
            human_delta(delta),
            pct
        );
    }
    let _ = writeln!(out);
    let _ = writeln!(
        out,
        "**{} → {}**, gzip **{} → {}**",
        human_bytes(report.base_file_bytes),
        human_bytes(report.head_file_bytes),
        human_bytes(report.base_gzip_bytes),
        human_bytes(report.head_gzip_bytes),
    );
    let _ = writeln!(out);

    // ---- "Your code" vs dependencies split ---------------------------------
    let (yours, deps): (Vec<_>, Vec<_>) = report.significant_rows().partition(|r| r.is_workspace);
    let yours_delta: i64 = yours.iter().map(|r| r.delta).sum();
    let deps_delta: i64 = deps.iter().map(|r| r.delta).sum();
    if !yours.is_empty() || !deps.is_empty() {
        let _ = writeln!(
            out,
            "`.text` attribution: **{} from dependencies**, **{} from your code**.",
            human_delta(deps_delta),
            human_delta(yours_delta),
        );
        let _ = writeln!(out);
    }
    // Reconcile the headline (whole-file) against what per-crate `.text` attribution
    // can explain. The remainder is data/rodata/padding that `cargo bloat --crates`
    // doesn't break down — surface it rather than let the numbers appear not to add up.
    let unattributed = report.unattributed_delta();
    if unattributed.unsigned_abs() >= report.noise_floor {
        let _ = writeln!(
            out,
            "_{} of the file change is outside `.text` (data/rodata/padding), which \
             `cargo bloat` can't attribute per-crate._",
            human_delta(unattributed),
        );
        let _ = writeln!(out);
    }

    // ---- Focused table: the top movers -------------------------------------
    let significant: Vec<_> = report.significant_rows().collect();
    if significant.is_empty() {
        let _ = writeln!(
            out,
            "_No crate changed by more than the {} noise floor._",
            human_bytes(report.noise_floor)
        );
        let _ = writeln!(out);
    } else {
        const TOP_N: usize = 8;
        let _ = writeln!(out, "| Crate | Base | Head | Δ | Δ% |");
        let _ = writeln!(out, "|-------|-----:|-----:|-----:|-----:|");
        for row in significant.iter().take(TOP_N) {
            let label = if row.is_workspace {
                format!("{} (you)", row.name)
            } else {
                row.name.clone()
            };
            let _ = writeln!(
                out,
                "| {} {} | {} | {} | {} | {} |",
                status_icon(row.status, row.is_workspace),
                label,
                human_bytes(row.base),
                human_bytes(row.head),
                human_delta(row.delta),
                pct_cell(row),
            );
        }
        if significant.len() > TOP_N {
            let _ = writeln!(
                out,
                "\n_…and {} more changed crate(s) — see full breakdown below._",
                significant.len() - TOP_N
            );
        }
        let _ = writeln!(out);
    }

    // ---- The "why" callout: cause attribution ------------------------------
    let new_deps: Vec<_> = report.new_dependencies().collect();
    if !new_deps.is_empty() {
        let _ = writeln!(out, "**New dependencies introduced by this PR:**");
        let _ = writeln!(out);
        for row in &new_deps {
            let attr = attributions.get(&row.name);
            let chain = attr
                .and_then(|a| a.chain.as_ref())
                .map(|c| c.join(" → "))
                .unwrap_or_else(|| row.name.clone());
            let lock_note = match attr.map(|a| a.newly_in_lock) {
                Some(true) => " (added in `Cargo.lock`)",
                _ => "",
            };
            let _ = writeln!(
                out,
                "- `{}` (+{}) — pulled in via `{}`{}",
                row.name,
                human_bytes(row.head),
                chain,
                lock_note,
            );
        }
        let _ = writeln!(out);
    }

    // ---- Collapsed full breakdown ------------------------------------------
    let _ = writeln!(
        out,
        "<details><summary>Full breakdown ({} crates)</summary>\n",
        report.rows.len()
    );
    let _ = writeln!(out, "| Crate | Base | Head | Δ |");
    let _ = writeln!(out, "|-------|-----:|-----:|-----:|");
    for row in &report.rows {
        let label = if row.is_workspace {
            format!("{} (you)", row.name)
        } else {
            row.name.clone()
        };
        let _ = writeln!(
            out,
            "| {} | {} | {} | {} |",
            label,
            human_bytes(row.base),
            human_bytes(row.head),
            human_delta(row.delta),
        );
    }
    if report.below_floor_count > 0 {
        let _ = writeln!(
            out,
            "\n_{} crate(s) changed by less than the {} floor ({} net)._",
            report.below_floor_count,
            human_bytes(report.noise_floor),
            human_delta(report.below_floor_net),
        );
    }
    let _ = writeln!(out, "\n</details>");
    let _ = writeln!(out);

    // ---- Footer -------------------------------------------------------------
    if report.toolchain_mismatch() {
        let _ = writeln!(
            out,
            "> ⚠️ Toolchain mismatch: base built with `{}`, head with `{}`. \
             Part of this delta may be compiler noise.",
            report.base_toolchain, report.head_toolchain
        );
        let _ = writeln!(out);
    }
    let _ = writeln!(
        out,
        "_Base `{}` · head `{}` · toolchain `{}`. Noise floor {}. Measured by [bloatbot](https://github.com/Asuddle/BloatBot)._",
        report.base_ref,
        report.head_ref,
        report.head_toolchain,
        human_bytes(report.noise_floor),
    );

    out
}

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

    #[test]
    fn human_bytes_units() {
        assert_eq!(human_bytes(512), "512 B");
        assert_eq!(human_bytes(1024), "1.0 KiB");
        assert_eq!(human_bytes(41_984), "41.0 KiB");
        assert_eq!(human_bytes(1_603_200), "1.53 MiB");
    }

    #[test]
    fn human_delta_signs() {
        assert_eq!(human_delta(0), "0 B");
        assert_eq!(human_delta(41_984), "+41.0 KiB");
        assert_eq!(human_delta(-1024), "-1.0 KiB");
    }
}