wowlab_parsers/parsers/spell_desc/renderer/

render.rs

use wowlab_types::spell_desc::SpellDescFragment;

use super::{
    MAX_EMBED_DEPTH, RenderContext, build_misc_key, build_spell_level_key, capitalize_if_needed,
    evaluate::{format_effect_value, format_rendered_number},
    merge_text_fragments, parse_duration_ms,
};
use crate::parsers::spell_desc::{
    parser::parse,
    resolver::SpellDescResolver,
    types::{
        AtVariableNode, ConditionalNode, GenderNode, PluralizationNode, SpellDescriptionNode,
        VariableNode,
    },
};

impl<R> RenderContext<'_, R>
where
    R: SpellDescResolver,
{
    pub(super) fn render_nodes(
        &mut self,
        nodes: &[SpellDescriptionNode],
    ) -> Vec<SpellDescFragment> {
        let mut fragments = Vec::new();

        for node in nodes {
            fragments.extend(self.render_node(node));
        }

        merge_text_fragments(&mut fragments);

        fragments
    }

    fn render_node(&mut self, node: &SpellDescriptionNode) -> Vec<SpellDescFragment> {
        match node {
            SpellDescriptionNode::Text(text) => {
                // WHY: strip carriage returns so `\r\n` paragraph breaks collapse to the kept `\n`.
                vec![SpellDescFragment::Text {
                    value: text.value().replace('\r', ""),
                }]
            }

            SpellDescriptionNode::ColorCode(color) => {
                if color.code() == "r" {
                    vec![SpellDescFragment::ColorEnd]
                } else {
                    vec![SpellDescFragment::ColorStart {
                        color: color.code().to_owned(),
                    }]
                }
            }

            SpellDescriptionNode::Variable(var) => self.render_variable(var),

            SpellDescriptionNode::ExpressionBlock(block) => {
                let value = self.evaluate_expression(&block.expression);

                self.last_number = Some(value);

                vec![SpellDescFragment::Value {
                    value: format_rendered_number(value, block.decimal_places),
                    raw: value,
                }]
            }

            SpellDescriptionNode::Conditional(cond) => self.render_conditional(cond),

            SpellDescriptionNode::Pluralization(plural) => self.render_pluralization(plural),

            SpellDescriptionNode::Gender(gender) => self.render_gender(gender),
        }
    }

    // #t(fn: rust_cyclomatic_complexity, rust_max_fn_lines) exhaustive variable rendering keeps resolve/fallback behavior adjacent per variant
    fn render_variable(&mut self, var: &VariableNode) -> Vec<SpellDescFragment> {
        match var {
            VariableNode::Effect(effect) => {
                if let Some(value) = self.resolver.get_effect_value(
                    self.self_spell_id,
                    effect.effect_index,
                    &effect.var_type,
                ) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_effect_value(value, &effect.var_type),
                        raw: value,
                    }]
                } else {
                    let token = format!("${}{}", effect.var_type, effect.effect_index);

                    self.warn(format!("Unresolved effect variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::SpellLevel(spell_level) => {
                let key = build_spell_level_key(&spell_level.var_type, spell_level.index);

                if let Some(value) = self.resolver.get_spell_value(self.self_spell_id, &key) {
                    if let Ok(num) = value.split_whitespace().next().unwrap_or("").parse::<f64>() {
                        self.last_number = Some(num);
                    }

                    if spell_level.var_type == "d" {
                        if let Some(raw_ms) = parse_duration_ms(&value) {
                            return vec![SpellDescFragment::Duration { value, raw_ms }];
                        }
                    }

                    vec![SpellDescFragment::Text { value }]
                } else {
                    let token = format!("${key}");

                    self.warn(format!("Unresolved spell-level variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::Player(player) => {
                if let Some(value) = self.resolver.get_player_stat(player.var_name()) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_rendered_number(value, None),
                        raw: value,
                    }]
                } else {
                    let token = format!("${}", player.var_name());

                    self.warn(format!("Unresolved player stat: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::CrossSpell(cross) => {
                if let Some(idx) = cross.effect_index {
                    if let Some(value) =
                        self.resolver
                            .get_effect_value(cross.spell_id, idx, &cross.var_type)
                    {
                        self.last_number = Some(value);

                        vec![SpellDescFragment::Value {
                            value: format_effect_value(value, &cross.var_type),
                            raw: value,
                        }]
                    } else {
                        let token = format!("${}{}{}", cross.spell_id, cross.var_type, idx);

                        self.warn(format!("Unresolved cross-spell effect: {token}"));

                        vec![SpellDescFragment::Unresolved { token }]
                    }
                } else if let Some(value) = self
                    .resolver
                    .get_spell_value(cross.spell_id, &cross.var_type)
                {
                    vec![SpellDescFragment::Text { value }]
                } else {
                    let token = format!("${}{}", cross.spell_id, cross.var_type);

                    self.warn(format!("Unresolved cross-spell value: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::Custom(custom) => {
                if let Some(value) = self.resolver.get_custom_var(custom.var_name()) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_rendered_number(value, None),
                        raw: value,
                    }]
                } else {
                    let token = format!("$<{}>", custom.var_name());

                    self.warn(format!("Unresolved custom variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::At(at) => self.render_at_variable(at),

            VariableNode::Enchant(enchant) => {
                if let Some(value) = self
                    .resolver
                    .get_spell_value(self.self_spell_id, enchant.var_type())
                {
                    vec![SpellDescFragment::Text { value }]
                } else if let Some(value) = self.resolver.get_player_stat(enchant.var_type()) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_rendered_number(value, None),
                        raw: value,
                    }]
                } else {
                    let token = format!("${}", enchant.var_type());

                    self.warn(format!("Unresolved enchant variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            VariableNode::Misc(misc) => {
                let key = build_misc_key(&misc.var_name, misc.id);

                if let Some(value) = self.resolver.get_spell_value(self.self_spell_id, &key) {
                    vec![SpellDescFragment::Text { value }]
                } else if let Some(value) = self.resolver.get_player_stat(&key) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_rendered_number(value, None),
                        raw: value,
                    }]
                } else {
                    let token = format!("${key}");

                    self.warn(format!("Unresolved misc variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }
        }
    }

    // #t(rust_cyclomatic_complexity) @ variable dispatch: spelldesc/spellname/spellicon/player stats
    fn render_at_variable(&mut self, at: &AtVariableNode) -> Vec<SpellDescFragment> {
        match at.var_type.as_str() {
            "spelldesc" => {
                if self.embed_depth >= MAX_EMBED_DEPTH {
                    self.warn(format!(
                        "Max embed depth ({MAX_EMBED_DEPTH}) exceeded for @spelldesc"
                    ));

                    return vec![SpellDescFragment::Text {
                        value: "[...]".to_string(),
                    }];
                }

                if let Some(spell_id) = at.spell_id {
                    if let Some(desc) = self.resolver.get_spell_description(spell_id) {
                        let saved_spell_id = self.self_spell_id;

                        self.self_spell_id = spell_id;
                        self.embed_depth += 1;
                        let parsed = parse(&desc);
                        let fragments = self.render_nodes(&parsed.ast.nodes);

                        self.embed_depth -= 1;
                        self.self_spell_id = saved_spell_id;

                        vec![SpellDescFragment::Embedded {
                            spell_id,
                            fragments,
                        }]
                    } else {
                        let token = format!("@spelldesc{spell_id}");

                        self.warn(format!("Could not fetch embedded spell: {spell_id}"));

                        vec![SpellDescFragment::Unresolved { token }]
                    }
                } else {
                    vec![SpellDescFragment::Unresolved {
                        token: "@spelldesc".to_string(),
                    }]
                }
            }

            "spellname" => {
                if let Some(spell_id) = at.spell_id {
                    if let Some(name) = self.resolver.get_spell_name(spell_id) {
                        vec![SpellDescFragment::SpellName { spell_id, name }]
                    } else {
                        let token = format!("@spellname{spell_id}");

                        self.warn(format!("Could not fetch spell name: {spell_id}"));

                        vec![SpellDescFragment::Unresolved { token }]
                    }
                } else {
                    vec![SpellDescFragment::Unresolved {
                        token: "@spellname".to_string(),
                    }]
                }
            }

            "spellicon" => {
                if let Some(spell_id) = at.spell_id {
                    if let Some(path) = self.resolver.get_spell_icon(spell_id) {
                        vec![SpellDescFragment::Icon { spell_id, path }]
                    } else {
                        let token = format!("@spellicon{spell_id}");

                        self.warn(format!("Could not fetch spell icon: {spell_id}"));

                        vec![SpellDescFragment::Unresolved { token }]
                    }
                } else {
                    vec![SpellDescFragment::Unresolved {
                        token: "@spellicon".to_string(),
                    }]
                }
            }

            "versadmg" | "versaheal" | "versatility" => {
                if let Some(value) = self.resolver.get_player_stat(&at.var_type) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format!("{}%", format_rendered_number(value, Some(1))),
                        raw: value,
                    }]
                } else {
                    let token = format!("@{}", at.var_type);

                    self.warn(format!("Unresolved @ variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }

            _ => {
                if let Some(value) = self.resolver.get_player_stat(&at.var_type) {
                    self.last_number = Some(value);

                    vec![SpellDescFragment::Value {
                        value: format_rendered_number(value, None),
                        raw: value,
                    }]
                } else {
                    let token = format!("@{}", at.var_type);

                    self.warn(format!("Unresolved @ variable: {token}"));

                    vec![SpellDescFragment::Unresolved { token }]
                }
            }
        }
    }

    fn render_conditional(&mut self, cond: &ConditionalNode) -> Vec<SpellDescFragment> {
        for branch in &cond.conditions {
            if self.evaluate_predicate(&branch.predicate) {
                return self.render_nodes(&branch.content);
            }
        }

        if let Some(else_branch) = &cond.else_branch {
            self.render_nodes(else_branch)
        } else {
            Vec::new()
        }
    }

    fn render_pluralization(&self, plural: &PluralizationNode) -> Vec<SpellDescFragment> {
        let is_singular = self
            .last_number
            .is_some_and(|n| (n - 1.0).abs() < f64::EPSILON);

        let result = if is_singular {
            &plural.singular
        } else {
            &plural.plural
        };

        let value = capitalize_if_needed(result, plural.capitalized);

        vec![SpellDescFragment::Text { value }]
    }

    fn render_gender(&self, gender: &GenderNode) -> Vec<SpellDescFragment> {
        let result = if self.resolver.is_male() {
            &gender.male
        } else {
            &gender.female
        };

        let value = capitalize_if_needed(result, gender.capitalized);

        vec![SpellDescFragment::Text { value }]
    }
}