use super::model::{OutputColumn, ReportResult, StatKind, SummaryRow};
#[derive(Debug, Clone, PartialEq)]
pub struct StatLine {
pub label: String,
pub comparison: String,
pub baseline: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct StatBlock {
pub header: String,
pub lines: Vec<StatLine>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct TotalTime {
pub comparison: String,
pub baseline: Option<String>,
pub unit: &'static str,
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct PairedStats {
pub blocks: Vec<StatBlock>,
pub total: Option<TotalTime>,
}
impl PairedStats {
pub fn is_empty(&self) -> bool {
self.blocks.is_empty() && self.total.is_none()
}
pub fn two_sided(&self) -> bool {
self.total.as_ref().is_some_and(|t| t.baseline.is_some())
|| self
.blocks
.iter()
.any(|b| b.lines.iter().any(|l| l.baseline.is_some()))
}
}
pub fn paired_stats(
result: &ReportResult,
columns: &[OutputColumn],
extra: &[SummaryRow],
) -> PairedStats {
let rows = result.summary_rows(columns);
let paired: std::collections::HashMap<usize, usize> =
result.baseline_column_pairs(columns).into_iter().collect();
let mut blocks = Vec::new();
for (ci, col) in columns.iter().enumerate() {
if col.stats.is_empty() || col.header.starts_with("baseline.") {
continue;
}
let mut lines = Vec::new();
for r in &rows {
let Some(cell) = r.cells.get(ci).and_then(Option::as_ref) else {
continue;
};
if cell.stat == Some(StatKind::Distribution) {
continue;
}
let baseline = paired
.get(&ci)
.and_then(|bi| r.cells.get(*bi))
.and_then(Option::as_ref)
.map(|v| v.text.clone())
.or_else(|| {
extra
.iter()
.find(|e| e.label == format!("{} (baseline)", r.label))
.and_then(|e| e.cells.get(ci).and_then(Option::as_ref))
.map(|v| v.text.clone())
});
lines.push(StatLine {
label: r.label.clone(),
comparison: cell.text.clone(),
baseline,
});
}
if !lines.is_empty() {
blocks.push(StatBlock {
header: col.header.clone(),
lines,
});
}
}
let (cand_ms, base_ms) = result.side_durations_ms();
let total = (cand_ms > 0.0).then(|| {
let unit = duration_unit(cand_ms.max(base_ms.unwrap_or(0.0)));
TotalTime {
comparison: unit.render(cand_ms),
baseline: base_ms.map(|ms| unit.render(ms)),
unit: unit.suffix,
}
});
PairedStats { blocks, total }
}
struct DurationUnit {
per_ms: f64,
decimals: usize,
suffix: &'static str,
}
impl DurationUnit {
fn render(&self, ms: f64) -> String {
format!("{:.*}", self.decimals, ms / self.per_ms)
}
}
fn duration_unit(largest_ms: f64) -> DurationUnit {
if largest_ms >= 60_000.0 {
DurationUnit {
per_ms: 60_000.0,
decimals: 1,
suffix: "min",
}
} else if largest_ms >= 1_000.0 {
DurationUnit {
per_ms: 1_000.0,
decimals: 2,
suffix: "s",
}
} else {
DurationUnit {
per_ms: 1.0,
decimals: 0,
suffix: "ms",
}
}
}