forge/

talent_modifier_summary.rs

// #t(file: rust_alloc_in_loop) the bounded CLI aggregation owns diagnostic strings.
// #t(file: rust_clone_in_loop) repeated rows intentionally retain cross-spec provenance.

//! Filtered cross-spec spell-modifier DBC reporting.

use std::collections::{BTreeMap, BTreeSet};

#[cfg(test)]
use googletest::{Result as GtestResult, prelude::*};
use wowlab_common::output;
use wowlab_engine_domain::dbc::aura_subtype_semantic;
use wowlab_types::{data::SpellDataFlat, game::SpecId};

const EFFECT_CLASS_MASK_WORDS: usize = 4;

#[derive(Default)]
pub(super) struct ModifierSummaries(BTreeMap<(i32, i32), ModifierSummary>);

#[derive(Debug, Default)]
struct ModifierSummary {
    spell_name: String,
    aura_subtype: i32,
    property: i32,
    base_points: f64,
    label: i32,
    class_mask: [i32; EFFECT_CLASS_MASK_WORDS],
    is_passive: bool,
    specs: BTreeSet<String>,
}

#[derive(tabled::Tabled)]
struct ModifierSummaryRow {
    #[tabled(rename = "Owner")]
    owner: String,
    #[tabled(rename = "Effect")]
    effect: i32,
    #[tabled(rename = "Aura")]
    aura_subtype: i32,
    #[tabled(rename = "Property")]
    property: i32,
    #[tabled(rename = "Base")]
    base_points: f64,
    #[tabled(rename = "Label")]
    label: i32,
    #[tabled(rename = "Class mask")]
    class_mask: String,
    #[tabled(rename = "Passive")]
    is_passive: bool,
    #[tabled(rename = "Specs")]
    specs: usize,
    #[tabled(rename = "Spec keys")]
    spec_keys: String,
}

#[derive(tabled::Tabled)]
// #t(rust_similar_structs) each summary command owns its table schema and output section independently
struct ModifierCoverageRow {
    #[tabled(rename = "Unique rows")]
    unique_rows: usize,
    #[tabled(rename = "Observations")]
    observations: usize,
    #[tabled(rename = "Specs")]
    specs: usize,
}

#[derive(tabled::Tabled)]
// #t(rust_similar_structs) each summary command owns its per-spec table row and rendering independently
struct ModifierSpecSummaryRow {
    #[tabled(rename = "Spec")]
    spec: String,
    #[tabled(rename = "Unique rows")]
    rows: usize,
}

impl ModifierSummaries {
    pub(super) fn observe(
        &mut self,
        spec: SpecId,
        spell: &SpellDataFlat,
        property_filter: &[i32],
        aura_filter: &[i32],
    ) {
        for effect in &spell.effects {
            if !property_filter.contains(&effect.misc_value_0)
                || (!aura_filter.is_empty() && !aura_filter.contains(&effect.aura))
                || aura_subtype_semantic(effect.aura)
                    .and_then(|semantic| semantic.modifier)
                    .is_none()
            {
                continue;
            }

            let effect_index = effect.index + 1;
            let summary = self.0.entry((spell.id, effect_index)).or_default();

            summary.spell_name.clone_from(&spell.name.to_string());
            summary.aura_subtype = effect.aura;
            summary.property = effect.misc_value_0;
            summary.base_points = effect.base_points;
            summary.label = effect.misc_value_1;
            summary.class_mask = [
                effect.effect_class_mask_1,
                effect.effect_class_mask_2,
                effect.effect_class_mask_3,
                effect.effect_class_mask_4,
            ];
            summary.is_passive = spell.is_passive;
            summary.specs.insert(spec.slug().to_string());
        }
    }

    pub(super) fn print(&self, filter: &[i32]) {
        output::blank();
        output::header(&format!(
            "Cross-spec modifier-property summary ({})",
            filter
                .iter()
                .map(i32::to_string)
                .collect::<Vec<_>>()
                .join(",")
        ));
        let observations = self.0.values().map(|summary| summary.specs.len()).sum();
        let specs = self
            .0
            .values()
            .flat_map(|summary| summary.specs.iter())
            .collect::<BTreeSet<_>>()
            .len();

        output::table([ModifierCoverageRow {
            unique_rows: self.0.len(),
            observations,
            specs,
        }]);
        output::blank();
        output::table(self.0.iter().map(|(&(spell_id, effect), summary)| {
            ModifierSummaryRow {
                owner: format!("{} ({spell_id})", summary.spell_name),
                effect,
                aura_subtype: summary.aura_subtype,
                property: summary.property,
                base_points: summary.base_points,
                label: summary.label,
                class_mask: summary
                    .class_mask
                    .iter()
                    .map(i32::to_string)
                    .collect::<Vec<_>>()
                    .join("/"),
                is_passive: summary.is_passive,
                specs: summary.specs.len(),
                spec_keys: summary.specs.iter().cloned().collect::<Vec<_>>().join(","),
            }
        }));

        let mut spec_rows = BTreeMap::new();

        for summary in self.0.values() {
            for spec in &summary.specs {
                *spec_rows.entry(spec.clone()).or_default() += 1;
            }
        }

        let mut spec_rows: Vec<_> = spec_rows
            .into_iter()
            .map(|(spec, rows)| ModifierSpecSummaryRow { spec, rows })
            .collect();

        spec_rows.sort_by(|left, right| {
            right
                .rows
                .cmp(&left.rows)
                .then_with(|| left.spec.cmp(&right.spec))
        });
        output::blank();
        output::header("Filtered modifier-property incidence by spec");
        output::table(spec_rows);
    }
}

#[cfg(test)]
mod tests {
    use wowlab_types::data::SpellEffect;

    use super::*;

    #[gtest]
    fn filtered_observation_retains_operation_filter_and_spec_provenance() -> GtestResult<()> {
        let spell = SpellDataFlat {
            id: 100,
            name: "Flat label damage".into(),
            is_passive: true,
            effects: vec![SpellEffect {
                index: 2,
                aura: 219,
                base_points: 15.0,
                misc_value_0: 0,
                misc_value_1: 4137,
                ..SpellEffect::default()
            }],
            ..SpellDataFlat::default()
        };
        let mut summaries = ModifierSummaries::default();

        summaries.observe(SpecId::Arcane, &spell, &[0], &[219]);

        let summary = summaries.0.get(&(100, 3)).or_fail()?;

        verify_that!(
            summary,
            matches_pattern!(ModifierSummary {
                aura_subtype: eq(&219),
                base_points: near(15.0, f64::EPSILON),
                label: eq(&4137),
                is_passive: eq(&true),
                ..
            })
        )?;
        verify_true!(summary.specs.contains("arcane_mage"))?;

        Ok(())
    }
}