forge/

talent_effect_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-effect DBC reporting.

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

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

#[derive(Default)]
pub(super) struct EffectSummaries {
    rows: BTreeMap<(i32, i32), EffectSummary>,
    spells: BTreeMap<i32, SpellShape>,
}

#[derive(Default)]
struct EffectSummary {
    spell_name: String,
    effect_type: i32,
    aura_subtype: i32,
    base_points: f64,
    misc_value_0: i32,
    trigger_spell: i32,
    specs: BTreeSet<String>,
}

#[derive(Default)]
struct SpellShape {
    name: String,
    operations: String,
}

#[derive(tabled::Tabled)]
struct EffectSummaryRow {
    #[tabled(rename = "Parent")]
    parent: String,
    #[tabled(rename = "Index")]
    effect_index: i32,
    #[tabled(rename = "SE")]
    effect_type: i32,
    #[tabled(rename = "AU")]
    aura_subtype: i32,
    #[tabled(rename = "Base")]
    base_points: f64,
    #[tabled(rename = "Misc 0")]
    misc_value_0: i32,
    #[tabled(rename = "Child")]
    child: String,
    #[tabled(rename = "Child operations")]
    child_operations: String,
    #[tabled(rename = "Specs")]
    specs: usize,
}

#[derive(tabled::Tabled)]
// #t(rust_similar_structs) each summary command owns its table schema and output section independently
struct EffectCoverageRow {
    #[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 EffectSpecSummaryRow {
    #[tabled(rename = "Spec")]
    spec: String,
    #[tabled(rename = "Unique rows")]
    rows: usize,
}

impl EffectSummaries {
    pub(super) fn observe(&mut self, spec: SpecId, spell: &SpellDataFlat, filter: &[i32]) {
        self.spells.insert(
            spell.id,
            SpellShape {
                name: spell.name.to_string(),
                operations: spell
                    .effects
                    .iter()
                    .map(|effect| {
                        format!(
                            "{}:SE{}:AU{}:base{}:misc{}",
                            effect.index + 1,
                            effect.effect,
                            effect.aura,
                            effect.base_points,
                            effect.misc_value_0
                        )
                    })
                    .collect::<Vec<_>>()
                    .join(","),
            },
        );

        for effect in &spell.effects {
            if !filter.contains(&effect.effect) {
                continue;
            }

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

            summary.spell_name.clone_from(&spell.name.to_string());
            summary.effect_type = effect.effect;
            summary.aura_subtype = effect.aura;
            summary.base_points = effect.base_points;
            summary.misc_value_0 = effect.misc_value_0;
            summary.trigger_spell = effect.trigger_spell;
            summary.specs.insert(spec.slug().to_string());
        }
    }

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

        output::table([EffectCoverageRow {
            unique_rows: self.rows.len(),
            observations,
            specs,
        }]);
        output::blank();
        output::table(
            self.rows
                .iter()
                .map(|(&(spell_id, effect_index), summary)| {
                    let child = self.spells.get(&summary.trigger_spell);

                    EffectSummaryRow {
                        parent: format!("{} ({spell_id})", summary.spell_name),
                        effect_index,
                        effect_type: summary.effect_type,
                        aura_subtype: summary.aura_subtype,
                        base_points: summary.base_points,
                        misc_value_0: summary.misc_value_0,
                        child: child.map_or_else(
                            || summary.trigger_spell.to_string(),
                            |shape| format!("{} ({})", shape.name, summary.trigger_spell),
                        ),
                        child_operations: child
                            .map_or_else(String::new, |shape| shape.operations.clone()),
                        specs: summary.specs.len(),
                    }
                }),
        );

        let mut spec_rows = BTreeMap::new();

        for summary in self.rows.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)| EffectSpecSummaryRow { 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 spell-effect incidence by spec");
        output::table(spec_rows);
    }
}

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

    use super::*;

    #[gtest]
    fn filtered_observation_joins_child_operation_shape_and_provenance() -> GtestResult<()> {
        let parent = SpellDataFlat {
            id: 100,
            name: "Parent".into(),
            effects: vec![SpellEffect {
                index: 0,
                effect: 64,
                trigger_spell: 200,
                ..SpellEffect::default()
            }],
            ..SpellDataFlat::default()
        };
        let child = SpellDataFlat {
            id: 200,
            name: "Child".into(),
            effects: vec![SpellEffect {
                index: 0,
                effect: 30,
                base_points: 8.0,
                misc_value_0: 3,
                ..SpellEffect::default()
            }],
            ..SpellDataFlat::default()
        };
        let mut summaries = EffectSummaries::default();

        summaries.observe(SpecId::Arms, &parent, &[64]);
        summaries.observe(SpecId::Arms, &child, &[64]);

        let summary = summaries.rows.get(&(100, 1)).or_fail()?;

        verify_that!(summary.trigger_spell, eq(200))?;
        verify_true!(summary.specs.contains("arms_warrior"))?;
        verify_that!(
            summaries.spells[&200].operations,
            eq("1:SE30:AU0:base8:misc3")
        )?;

        Ok(())
    }
}