forge/

render.rs

// #t(file: rust_alloc_in_loop) CLI binary, allocations are fine for readability.
// #t(file: rust_clone_in_loop) CLI binary, cloning strings in display loops is fine.

//! Comparison rendering: DPS table, spell breakdown, and timeline.

use std::collections::BTreeMap;

#[cfg(test)]
use googletest::{Result as GtestResult, prelude::*};
use tabled::Tabled;
use wowlab_common::output;
use wowlab_types::constants::HUNDRED;

use crate::provider::{CastEntry, SimOutput, SpellResult};

const MAX_SPELL_NAME_LEN: usize = 24;
const TIMELINE_MATCH_TOLERANCE: f64 = 0.05;
const TIMELINE_ORDER_SLACK: f64 = 0.001;

#[derive(Tabled)]
struct DpsRow {
    #[tabled(rename = "Source")]
    source: String,
    #[tabled(rename = "Mean DPS")]
    mean_dps: String,
}

#[derive(Tabled)]
struct SpellRow {
    #[tabled(rename = "Spell")]
    name: String,
    #[tabled(rename = "wl DPS")]
    wl_dps: String,
    #[tabled(rename = "wl casts")]
    wl_casts: String,
    #[tabled(rename = "wl hits")]
    wl_hits: String,
    #[tabled(rename = "wl %")]
    wl_pct: String,
    #[tabled(rename = "sc DPS")]
    sc_dps: String,
    #[tabled(rename = "sc casts")]
    sc_casts: String,
    #[tabled(rename = "sc hits")]
    sc_hits: String,
    #[tabled(rename = "sc %")]
    sc_pct: String,
    #[tabled(rename = "Delta")]
    delta: String,
    #[tabled(rename = "Δ%")]
    delta_pct: String,
    #[tabled(rename = "dpc Δ%")]
    dpc_delta_pct: String,
    #[tabled(rename = "dph Δ%")]
    dph_delta_pct: String,
}

#[derive(Tabled)]
struct TimelineRow {
    #[tabled(rename = "Time")]
    time: String,
    #[tabled(rename = "wowlab")]
    wl_spell: String,
    #[tabled(rename = "SimC")]
    sc_spell: String,
}

pub(crate) fn print_banner(slug: &str, parameters: crate::run::RunParameters) {
    print_encounter_banner(slug, parameters, "Patchwerk");
}

pub(crate) fn print_encounter_banner(
    slug: &str,
    parameters: crate::run::RunParameters,
    encounter: &str,
) {
    let iterations = parameters.iterations();
    let duration = parameters.fight_duration_secs();

    output::blank();
    output::header(&format!(
        "{slug} -- {iterations} iter, {duration}s {encounter}"
    ));
}

pub(crate) fn print_dps_comparison(wl: &SimOutput, sc: &SimOutput, wl_name: &str, sc_name: &str) {
    let diff = wl.dps - sc.dps;
    let pct = if sc.dps > 0.0 {
        diff / sc.dps * HUNDRED
    } else {
        0.0
    };

    output::blank();
    output::subheader("DPS Comparison");

    let rows = vec![
        DpsRow {
            source: wl_name.to_string(),
            mean_dps: format!("{:.1}", wl.dps),
        },
        DpsRow {
            source: sc_name.to_string(),
            mean_dps: format!("{:.1}", sc.dps),
        },
        DpsRow {
            source: "Delta".to_string(),
            mean_dps: format!("{diff:+.1} ({pct:+.1}%)"),
        },
    ];

    output::table(rows);
    output::blank();
}

pub(crate) fn print_spell_comparison(wl: &SimOutput, sc: &SimOutput) {
    let wl_spells = attribution_normalized_spells(wl);
    let sc_spells = attribution_normalized_spells(sc);
    let mut all_names: Vec<String> = wl_spells.keys().chain(sc_spells.keys()).cloned().collect();

    all_names.sort();
    all_names.dedup();

    all_names.sort_by(|a, b| {
        let a_dps = wl_spells
            .get(a)
            .map_or(0.0, |s| s.dps)
            .max(sc_spells.get(a).map_or(0.0, |s| s.dps));
        let b_dps = wl_spells
            .get(b)
            .map_or(0.0, |s| s.dps)
            .max(sc_spells.get(b).map_or(0.0, |s| s.dps));

        b_dps
            .partial_cmp(&a_dps)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    output::subheader("Spell Breakdown");

    let rows: Vec<SpellRow> = all_names
        .iter()
        .map(|name| {
            let wl_s = wl_spells.get(name);
            let sc_s = sc_spells.get(name);
            let wl_dps = wl_s.map_or(0.0, |s| s.dps);
            let sc_dps = sc_s.map_or(0.0, |s| s.dps);
            let wl_casts = wl_s.map_or(0, |s| s.casts);
            let sc_casts = sc_s.map_or(0, |s| s.casts);
            let wl_hits = wl_s.map_or(0, |s| s.hits);
            let sc_hits = sc_s.map_or(0, |s| s.hits);
            let wl_pct = wl_s.map_or(0.0, |s| s.pct);
            let sc_pct = sc_s.map_or(0.0, |s| s.pct);
            let diff = wl_dps - sc_dps;
            let diff_pct = if sc_dps > 0.0 {
                diff / sc_dps * HUNDRED
            } else if wl_dps > 0.0 {
                f64::INFINITY
            } else {
                0.0
            };

            let delta_pct = if diff_pct.is_finite() {
                format!("{diff_pct:+.1}%")
            } else {
                "  -- ".to_string()
            };

            // Proc and passive rows have no meaningful damage-per-cast delta.
            let per_cast_delta_pct = per_event_delta_pct(wl_dps, wl_casts, sc_dps, sc_casts);
            // Damage per landed hit is defined where dpc is not: pet, guardian, proc and DoT rows.
            let per_hit_delta_pct = per_event_delta_pct(wl_dps, wl_hits, sc_dps, sc_hits);

            let display_name: String = name.chars().take(MAX_SPELL_NAME_LEN).collect();

            SpellRow {
                name: display_name,
                wl_dps: format!("{wl_dps:.1}"),
                wl_casts: wl_casts.to_string(),
                wl_hits: wl_hits.to_string(),
                wl_pct: format!("{:.1}%", wl_pct * HUNDRED),
                sc_dps: format!("{sc_dps:.1}"),
                sc_casts: sc_casts.to_string(),
                sc_hits: sc_hits.to_string(),
                sc_pct: format!("{:.1}%", sc_pct * HUNDRED),
                delta: format!("{diff:+.1}"),
                delta_pct,
                dpc_delta_pct: per_cast_delta_pct,
                dph_delta_pct: per_hit_delta_pct,
            }
        })
        .collect();

    output::table(rows);

    let wl_only: Vec<&String> = wl_spells
        .keys()
        .filter(|k| !sc_spells.contains_key(*k))
        .collect();
    let sc_only: Vec<&String> = sc_spells
        .keys()
        .filter(|k| !wl_spells.contains_key(*k))
        .collect();

    if !wl_only.is_empty() {
        let names: Vec<&str> = wl_only.iter().map(|s| s.as_str()).collect();

        output::detail(&format!("wowlab only: {}", names.join(", ")));
    }

    if !sc_only.is_empty() {
        let names: Vec<&str> = sc_only.iter().map(|s| s.as_str()).collect();

        output::detail(&format!("SimC only: {}", names.join(", ")));
    }

    output::blank();
}

/// `(wowlab / SimC - 1)` damage per event, or `--` when either side has no events.
fn per_event_delta_pct(wl_dps: f64, wl_events: u32, sc_dps: f64, sc_events: u32) -> String {
    if wl_events == 0 || sc_events == 0 || sc_dps <= 0.0 {
        return "  -- ".to_string();
    }

    let wowlab_per_event = wl_dps / f64::from(wl_events);
    let simc_per_event = sc_dps / f64::from(sc_events);

    format!(
        "{:+.1}%",
        (wowlab_per_event / simc_per_event - 1.0) * HUNDRED
    )
}

fn attribution_normalized_spells(output: &SimOutput) -> BTreeMap<String, SpellResult> {
    let mut normalized = BTreeMap::new();

    for (name, result) in &output.spells {
        let entry = normalized
            .entry(canonical_spell_name(name).to_string())
            .or_insert_with(SpellResult::default);

        entry.dps += result.dps;
        entry.casts = entry.casts.max(result.casts);
        entry.hits += result.hits;
    }

    let mut timeline_casts = BTreeMap::new();

    for cast in &output.timeline {
        *timeline_casts
            .entry(canonical_spell_name(&cast.spell_name))
            .or_insert(0) += 1;
    }

    for (name, casts) in timeline_casts {
        normalized.entry(name.to_string()).or_default().casts = casts;
    }

    for result in normalized.values_mut() {
        result.pct = if output.dps > 0.0 {
            result.dps / output.dps
        } else {
            0.0
        };
    }

    normalized
}

// #t(fn: rust_const_fn_candidate) string pattern matching is not const-stable on this toolchain.
// #t(fn: rust_cyclomatic_complexity) canonical attribution aliases are a flat lookup table, not branching report logic
fn canonical_spell_name(name: &str) -> &str {
    match name {
        "amplifying_poison_debuff" => "amplifying_poison",
        "auto_attack_mh" | "auto_attack_oh" => "auto_attack",
        "barbed_shot_dot" => "barbed_shot",
        "bladestorm_mh" | "bladestorm_offhand" | "bladestorm_oh" => "bladestorm",
        "bloodbath_bladestorm_unhinged" => "bloodbath",
        "bloodshed_dot" => "bloodshed",
        "bloodthirst_bladestorm_unhinged" => "bloodthirst",
        "chain_lightning_ll_rtl" | "chain_lightning_ss_rtl" => "chain_lightning",
        "execute_mainhand" | "execute_offhand" => "execute",
        "instant_poison_damage" => "instant_poison",
        "kill_command_pet" | "wildspeaker_kill_command" => "kill_command",
        "lightning_bolt_ps" | "lightning_bolt_ti" => "lightning_bolt",
        "lightning_rod_damage" => "lightning_rod",
        "mutilate_mh" | "mutilate_oh" => "mutilate",
        "pet_attack" | "pet_auto_attack_mh" | "pet_auto_attack_oh" | "infernal_melee"
        | "dreadstalker_melee" => "melee",
        "pet_bestial_wrath" => "bestial_wrath",
        "phoenix_pyroblast" | "pyroblast_pyromaniac" => "pyroblast",
        "odyns_fury_dot" | "odyns_fury_mh" | "odyns_fury_offhand" | "odyns_fury_oh" => "odyns_fury",
        "raging_blow_mh" | "raging_blow_oh" => "raging_blow",
        "rampage1" | "rampage2" | "rampage3" | "rampage4" => "rampage",
        "rend_dot" => "rend",
        "rune_of_unleashed_fire_lingering" => "rune_of_lingering",
        "stormblast_stormstrike_mh" | "stormblast_stormstrike_offhand" => "stormblast",
        "thundering_hooves" => "stomp",
        "tremor_es" => "tremor",
        "voltaic_blaze_damage" => "voltaic_blaze",
        "whirlwind_mh_first"
        | "whirlwind_mh_others"
        | "whirlwind_oh_first"
        | "whirlwind_oh_others" => "whirlwind",
        _ => name,
    }
}

pub(crate) fn print_resource_comparison(wl: &SimOutput, sc: &SimOutput) {
    #[derive(Tabled)]
    struct ResourceRow {
        #[tabled(rename = "Source")]
        name: String,
        #[tabled(rename = "wl gain")]
        wl_gain: String,
        #[tabled(rename = "wl waste")]
        wl_waste: String,
        #[tabled(rename = "sc gain")]
        sc_gain: String,
        #[tabled(rename = "sc waste")]
        sc_waste: String,
        #[tabled(rename = "Δ gain")]
        delta: String,
    }

    let mut names: Vec<&String> = wl
        .resource_gains
        .keys()
        .chain(sc.resource_gains.keys())
        .collect();

    names.sort();
    names.dedup();
    let mut rows: Vec<(f64, ResourceRow)> = names
        .into_iter()
        .map(|name| {
            let w = wl.resource_gains.get(name).copied().unwrap_or_default();
            let c = sc.resource_gains.get(name).copied().unwrap_or_default();
            let key = w.gained.max(c.gained);

            (
                key,
                ResourceRow {
                    name: name.clone(),
                    wl_gain: format!("{:.0}", w.gained),
                    wl_waste: format!("{:.0}", w.wasted),
                    sc_gain: format!("{:.0}", c.gained),
                    sc_waste: format!("{:.0}", c.wasted),
                    delta: format!("{:+.0}", w.gained - c.gained),
                },
            )
        })
        .collect();

    rows.sort_by(|(a, _), (b, _)| b.total_cmp(a));

    let wl_total: f64 = wl.resource_gains.values().map(|g| g.gained).sum();
    let sc_total: f64 = sc.resource_gains.values().map(|g| g.gained).sum();
    let wl_waste: f64 = wl.resource_gains.values().map(|g| g.wasted).sum();
    let sc_waste: f64 = sc.resource_gains.values().map(|g| g.wasted).sum();

    rows.push((
        -1.0,
        ResourceRow {
            name: "TOTAL".to_string(),
            wl_gain: format!("{wl_total:.0}"),
            wl_waste: format!("{wl_waste:.0}"),
            sc_gain: format!("{sc_total:.0}"),
            sc_waste: format!("{sc_waste:.0}"),
            delta: format!("{:+.0}", wl_total - sc_total),
        },
    ));

    output::blank();
    output::subheader("Resource Income (per iteration)");
    output::table(rows.into_iter().map(|(_, row)| row).collect::<Vec<_>>());
}

pub(crate) fn print_timeline(wl: &SimOutput, sc: &SimOutput, max_s: f64) {
    let merged = merge_timelines(&wl.timeline, &sc.timeline, max_s);

    output::subheader(&format!("Side-by-Side Cast Timeline (first {max_s:.0}s)"));

    let rows: Vec<TimelineRow> = merged
        .iter()
        .map(|(time, wl_name, sc_name)| TimelineRow {
            time: format!("{time:.3}"),
            wl_spell: wl_name.clone(),
            sc_spell: sc_name.clone(),
        })
        .collect();

    output::table(rows);

    let wl_count = wl.timeline.iter().filter(|e| e.time_secs <= max_s).count();
    let sc_count = sc.timeline.iter().filter(|e| e.time_secs <= max_s).count();

    output::detail(&format!(
        "wowlab: {wl_count} casts, SimC: {sc_count} casts in first {max_s:.0}s",
    ));
    output::blank();
}

fn merge_timelines(wl: &[CastEntry], sc: &[CastEntry], max_s: f64) -> Vec<(f64, String, String)> {
    let wl: Vec<_> = wl.iter().filter(|e| e.time_secs <= max_s).collect();
    let sc: Vec<_> = sc.iter().filter(|e| e.time_secs <= max_s).collect();

    let mut rows = Vec::new();
    let mut wi = 0;
    let mut si = 0;

    while wi < wl.len() || si < sc.len() {
        let wt = if wi < wl.len() {
            // BOUNDS: wi < wl.len() is checked in the enclosing condition
            wl[wi].time_secs
        } else {
            f64::INFINITY
        };
        let st = if si < sc.len() {
            // BOUNDS: si < sc.len() is checked in the enclosing condition
            sc[si].time_secs
        } else {
            f64::INFINITY
        };

        if wt <= st + TIMELINE_ORDER_SLACK && wi < wl.len() {
            if si < sc.len() && (st - wt).abs() < TIMELINE_MATCH_TOLERANCE {
                // BOUNDS: wi < wl.len() and si < sc.len() checked in enclosing conditions
                rows.push((wt, wl[wi].spell_name.clone(), sc[si].spell_name.clone()));
                wi += 1;
                si += 1;
            } else {
                // BOUNDS: wi < wl.len() checked in enclosing if condition
                rows.push((wt, wl[wi].spell_name.clone(), String::new()));
                wi += 1;
            }
        } else if si < sc.len() {
            // BOUNDS: si < sc.len() checked in enclosing else-if condition
            rows.push((st, String::new(), sc[si].spell_name.clone()));
            si += 1;
        } else {
            break;
        }
    }

    rows
}

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

    #[gtest]
    fn attribution_normalization_folds_child_damage_into_parent_spell() -> GtestResult<()> {
        let output = SimOutput::new(
            100.0,
            vec![
                (
                    "auto_attack_mh".to_string(),
                    SpellResult {
                        dps: 20.0,
                        casts: 10,
                        hits: 10,
                        pct: 0.2,
                    },
                ),
                (
                    "auto_attack_oh".to_string(),
                    SpellResult {
                        dps: 10.0,
                        casts: 8,
                        hits: 8,
                        pct: 0.1,
                    },
                ),
                (
                    "rampage4".to_string(),
                    SpellResult {
                        dps: 15.0,
                        casts: 0,
                        hits: 12,
                        pct: 0.15,
                    },
                ),
            ],
            Vec::new(),
        );

        let spells = attribution_normalized_spells(&output);

        verify_that!(spells.len(), eq(2))?;
        let auto_attack = spells.get("auto_attack").or_fail()?;

        verify_that!(
            auto_attack,
            matches_pattern!(SpellResult {
                casts: eq(&10),
                // hits add across the merged mainhand and offhand rows; casts do not.
                hits: eq(&18),
                dps: near(30.0, f64::EPSILON),
                pct: near(0.3, f64::EPSILON),
            })
        )?;
        verify_true!(spells.contains_key("rampage"))?;

        Ok(())
    }

    #[gtest]
    fn attribution_normalization_uses_canonical_foreground_timeline_casts() -> GtestResult<()> {
        let output = SimOutput::new(
            100.0,
            vec![
                (
                    "odyns_fury_mh".to_string(),
                    SpellResult {
                        dps: 20.0,
                        casts: 12,
                        hits: 24,
                        pct: 0.2,
                    },
                ),
                (
                    "odyns_fury_mh".to_string(),
                    SpellResult {
                        dps: 10.0,
                        casts: 12,
                        hits: 24,
                        pct: 0.1,
                    },
                ),
                (
                    "odyns_fury_dot".to_string(),
                    SpellResult {
                        dps: 30.0,
                        casts: 0,
                        hits: 48,
                        pct: 0.3,
                    },
                ),
            ],
            vec![
                CastEntry {
                    time_secs: 0.0,
                    spell_name: "odyns_fury".to_string(),
                },
                CastEntry {
                    time_secs: 45.0,
                    spell_name: "odyns_fury".to_string(),
                },
            ],
        );

        let spells = attribution_normalized_spells(&output);
        let odyns_fury = spells.get("odyns_fury").or_fail()?;

        verify_that!(
            odyns_fury,
            matches_pattern!(SpellResult {
                casts: eq(&2),
                hits: eq(&96),
                dps: near(60.0, f64::EPSILON),
                pct: near(0.6, f64::EPSILON),
            })
        )?;

        Ok(())
    }

    #[gtest]
    fn simc_omnium_lingering_name_matches_engine_attribution() -> GtestResult<()> {
        verify_that!(
            canonical_spell_name("rune_of_unleashed_fire_lingering"),
            eq("rune_of_lingering")
        )?;

        Ok(())
    }

    #[gtest]
    fn enhancement_trigger_variants_match_engine_attribution() -> GtestResult<()> {
        verify_that!(
            canonical_spell_name("chain_lightning_ss_rtl"),
            eq("chain_lightning")
        )?;
        verify_that!(
            canonical_spell_name("chain_lightning_ll_rtl"),
            eq("chain_lightning")
        )?;
        verify_that!(
            canonical_spell_name("lightning_bolt_ps"),
            eq("lightning_bolt")
        )?;
        verify_that!(
            canonical_spell_name("lightning_bolt_ti"),
            eq("lightning_bolt")
        )?;
        verify_that!(
            canonical_spell_name("stormblast_stormstrike_mh"),
            eq("stormblast")
        )?;
        verify_that!(
            canonical_spell_name("stormblast_stormstrike_offhand"),
            eq("stormblast")
        )?;
        verify_that!(canonical_spell_name("tremor_es"), eq("tremor"))?;

        verify_that!(
            canonical_spell_name("voltaic_blaze_damage"),
            eq("voltaic_blaze")
        )
    }

    #[gtest]
    fn beast_mastery_pet_payloads_match_simc_parent_attribution() -> GtestResult<()> {
        verify_that!(canonical_spell_name("barbed_shot_dot"), eq("barbed_shot"))?;
        verify_that!(canonical_spell_name("bloodshed_dot"), eq("bloodshed"))?;
        verify_that!(canonical_spell_name("kill_command_pet"), eq("kill_command"))?;
        verify_that!(
            canonical_spell_name("wildspeaker_kill_command"),
            eq("kill_command")
        )?;
        verify_that!(
            canonical_spell_name("pet_bestial_wrath"),
            eq("bestial_wrath")
        )?;

        verify_that!(canonical_spell_name("thundering_hooves"), eq("stomp"))
    }

    #[gtest]
    fn pet_and_owner_auto_attacks_keep_distinct_attribution() -> GtestResult<()> {
        verify_that!(canonical_spell_name("auto_attack_mh"), eq("auto_attack"))?;
        verify_that!(canonical_spell_name("auto_attack_oh"), eq("auto_attack"))?;
        verify_that!(canonical_spell_name("pet_auto_attack_mh"), eq("melee"))?;

        verify_that!(canonical_spell_name("pet_auto_attack_oh"), eq("melee"))
    }
}