wowlab_engine_application/settings/

consumables.rs

// #t(file: rust_inline_test_module_size) private consumable parsing, ranking, and spell-mapping tests remain cohesive with their implementation

//! Resolves consumable settings to buff spells.

use std::collections::BTreeMap;

use wowlab_engine_domain::dbc::{ConsumableSubclass, resolve_item_budget};
use wowlab_engine_gamedata::{
    ConsumableBuff, ConsumableSpells, FoodBuff, ItemBudget, RatingMultiplierSlot,
    ResolvedGameTables,
};
use wowlab_engine_ports::{DataResolver, DynDataResolver, EngineError, SpellId, tokenize_name};
use wowlab_types::{
    constants::{
        AUGMENT_RUNE_SPELL_ID, AUGMENT_RUNE_SPELL_IDS, FLASK_ALCHEMICAL_CHAOS_SPELL_ID,
        FOOD_PRIMARY_STAT_COEFFICIENT_EFFECT_INDEX, FOOD_PRIMARY_STAT_COEFFICIENT_SPELL_ID,
        PRIMARY_FOOD_BUFF_SPELL_IDS, TEMPERED_POTION_SPELL_ID,
    },
    data::ItemDataFlat,
    game::RaceId,
};

/// Legacy `potion` value selecting the TWW default prepot.
const TEMPERED_POTION_KEY: &str = "tempered";

const TEMPERED_POTION_NAME: &str = "Tempered Potion";
const FLASK_ALCHEMICAL_CHAOS_NAME: &str = "Flask of Alchemical Chaos";
const AUGMENT_RUNE_NAME: &str = "Crystallized Augment Rune";

/// One consumable slot as written in the intent settings.
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub(crate) enum ConsumableSetting {
    Off,
    LegacyDefault,
    Named(String),
}

/// The four consumable slots parsed from intent settings, before data resolution.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct ConsumableSelection {
    pub potion: ConsumableSetting,
    pub flask: ConsumableSetting,
    pub food: ConsumableSetting,
    pub augment_rune: ConsumableSetting,
}

fn parse_bool_or_name(
    settings: &BTreeMap<String, toml::Value>,
    key: &str,
    default_on: bool,
) -> Result<ConsumableSetting, EngineError> {
    match settings.get(key) {
        None => Ok(if default_on {
            ConsumableSetting::LegacyDefault
        } else {
            ConsumableSetting::Off
        }),
        Some(toml::Value::Boolean(true)) => Ok(ConsumableSetting::LegacyDefault),
        Some(toml::Value::Boolean(false)) => Ok(ConsumableSetting::Off),
        Some(toml::Value::String(s)) => Ok(ConsumableSetting::Named(s.clone())),
        Some(other) => Err(EngineError::intent_validation(format!(
            "settings[\"{key}\"] must be a boolean or a consumable name string, got {other:?}"
        ))),
    }
}

/// Parses consumable selections, including legacy boolean settings.
pub(crate) fn parse_consumable_selection(
    settings: &BTreeMap<String, toml::Value>,
) -> Result<ConsumableSelection, EngineError> {
    let pre_pot = settings
        .get("pre_pot")
        .and_then(toml::Value::as_bool)
        .unwrap_or(false);
    let potion = match settings.get("potion") {
        _ if !pre_pot => ConsumableSetting::Off,
        None => ConsumableSetting::Off,
        Some(toml::Value::String(s)) if s == TEMPERED_POTION_KEY => {
            ConsumableSetting::LegacyDefault
        }
        Some(toml::Value::String(s)) => ConsumableSetting::Named(s.clone()),
        Some(other) => {
            return Err(EngineError::intent_validation(format!(
                "settings[\"potion\"] must be a consumable name string, got {other:?}"
            )));
        }
    };

    let food = match settings.get("food") {
        None | Some(toml::Value::Boolean(false)) => ConsumableSetting::Off,
        Some(toml::Value::String(s)) => ConsumableSetting::Named(s.clone()),
        Some(other) => {
            return Err(EngineError::intent_validation(format!(
                "settings[\"food\"] must be a consumable name string, got {other:?}"
            )));
        }
    };

    Ok(ConsumableSelection {
        potion,
        flask: parse_bool_or_name(settings, "flask", true)?,
        food,
        augment_rune: parse_bool_or_name(settings, "augment_rune", true)?,
    })
}

fn split_quality_rank(token: &str) -> (&str, u8) {
    match token.rsplit_once('_') {
        Some((base, rank)) if rank.len() == 1 && rank.chars().all(|c| c.is_ascii_digit()) => {
            (base, rank.parse().unwrap_or(1).max(1))
        }
        _ => (token, 1),
    }
}

/// Pick the item for `token` at crafting-quality `rank`: exact tokenized-name matches win over the shortest containing name; same-named rank variants order by item level (rank 1 = lowest), with `rank` clamped to the available variants.
fn pick_item<'a>(items: &'a [ItemDataFlat], token: &str, rank: u8) -> Option<&'a ItemDataFlat> {
    let mut group: Vec<&ItemDataFlat> = items
        .iter()
        .filter(|item| tokenize_name(&item.name) == token)
        .collect();

    if group.is_empty() {
        let best = items
            .iter()
            .filter(|item| tokenize_name(&item.name).contains(token))
            .min_by_key(|item| (item.name.len(), item.id))?;

        group = items.iter().filter(|item| item.name == best.name).collect();
    }

    group.sort_by_key(|item| (item.item_level, item.id));
    let index = usize::from(rank - 1).min(group.len() - 1);

    group.get(index).copied()
}

/// The item's on-use spell.
fn use_spell_id(item: &ItemDataFlat) -> Option<u32> {
    item.effects
        .iter()
        .find(|effect| {
            wowlab_engine_domain::dbc::ItemEffectTrigger::try_from(effect.trigger_type).ok()
                == Some(wowlab_engine_domain::dbc::ItemEffectTrigger::OnUse)
                && effect.spell_id > 0
        })
        .map(|effect| wowlab_types::numeric::i32_to_u32_nonnegative(effect.spell_id))
}

struct ResolvedItemSpell {
    spell_id: u32,
    item_name: String,
    item_level: i32,
    quality: i32,
}

async fn resolve_named_consumable(
    resolver: &DynDataResolver<'_>,
    name: &str,
    subclass: i32,
    slot: &str,
) -> Result<ResolvedItemSpell, EngineError> {
    let token = tokenize_name(name);
    let (base, rank) = split_quality_rank(&token);
    let items = resolver
        .find_consumable_items(base, subclass)
        .await
        .map_err(|e| {
            EngineError::intent_validation(format!("failed to look up {slot} '{name}': {e}"))
        })?;
    let item = pick_item(&items, base, rank).ok_or_else(|| {
        EngineError::intent_validation(format!(
            "unknown {slot} '{name}' (no consumable item matches '{base}')"
        ))
    })?;
    let spell_id = use_spell_id(item).ok_or_else(|| {
        EngineError::intent_validation(format!(
            "{slot} '{name}' (item {}) has no on-use spell",
            item.id
        ))
    })?;

    Ok(ResolvedItemSpell {
        spell_id,
        item_name: item.name.to_string(),
        item_level: item.item_level,
        quality: item.quality,
    })
}

/// Resolves the consuming item's ilvl budget; coefficient-valued consumable effects are item-budget-scaled, literal base-points effects are not.
async fn consumable_item_budget(
    resolver: &DynDataResolver<'_>,
    resolved: &ResolvedItemSpell,
) -> Result<Option<ItemBudget>, EngineError> {
    let scaling = resolver.get_scaling_data().await.map_err(|e| {
        EngineError::spec_construction(format!("failed to resolve scaling data: {e}"))
    })?;
    let tables = ResolvedGameTables::from_scaling(&scaling);
    let budget = resolve_item_budget(
        &tables,
        resolved.item_level,
        resolved.quality,
        RatingMultiplierSlot::Armor,
    )
    .ok_or_else(|| {
        EngineError::spec_construction(format!(
            "RandPropPoints missing for consumable ilvl {}",
            resolved.item_level
        ))
    })?;

    Ok(Some(budget))
}

async fn resolve_buff_slot(
    resolver: &DynDataResolver<'_>,
    setting: &ConsumableSetting,
    subclass: i32,
    slot: &str,
    legacy: (u32, &str),
) -> Result<Option<ConsumableBuff>, EngineError> {
    match setting {
        ConsumableSetting::Off => Ok(None),
        ConsumableSetting::LegacyDefault => Ok(Some(ConsumableBuff {
            spell_id: legacy.0,
            name: legacy.1.to_string(),
            item_budget: None,
        })),
        ConsumableSetting::Named(name) => {
            let resolved = resolve_named_consumable(resolver, name, subclass, slot).await?;
            let item_budget = consumable_item_budget(resolver, &resolved).await?;

            Ok(Some(ConsumableBuff {
                spell_id: resolved.spell_id,
                name: resolved.item_name,
                item_budget,
            }))
        }
    }
}

async fn resolve_augment_rune_slot(
    resolver: &DynDataResolver<'_>,
    setting: &ConsumableSetting,
) -> Result<Option<ConsumableBuff>, EngineError> {
    let name = match setting {
        ConsumableSetting::Off => return Ok(None),
        ConsumableSetting::LegacyDefault => {
            return Ok(Some(ConsumableBuff {
                spell_id: AUGMENT_RUNE_SPELL_ID,
                name: AUGMENT_RUNE_NAME.to_string(),
                item_budget: None,
            }));
        }
        ConsumableSetting::Named(name) => name,
    };
    let token = tokenize_name(name);
    let matching_spell = AUGMENT_RUNE_SPELL_IDS
        .iter()
        .find(|(fragment, _)| token.contains(fragment))
        .map(|(_, id)| *id);
    let spell_id = matching_spell
        .ok_or_else(|| EngineError::intent_validation(format!("unknown augment rune '{name}'")))?;
    let display_name = resolver
        .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
            spell_id,
        )))
        .await
        .map_or_else(|_| name.clone(), |s| s.name.to_string());

    Ok(Some(ConsumableBuff {
        spell_id,
        name: display_name,
        item_budget: None,
    }))
}

const PANDAREN_FOOD_MULTIPLIER: f64 = 2.0;

const fn food_amount_multiplier(race: RaceId) -> f64 {
    match race {
        RaceId::PandarenA | RaceId::PandarenH => PANDAREN_FOOD_MULTIPLIER,
        _ => 1.0,
    }
}

fn food_buff_for_use_spell(use_spell: u32, name: String, race: RaceId) -> Option<FoodBuff> {
    let (_, buff_spell) = PRIMARY_FOOD_BUFF_SPELL_IDS
        .iter()
        .find(|(use_id, _)| *use_id == use_spell)?;

    Some(FoodBuff {
        spell_id: *buff_spell,
        name,
        coeff_spell_id: FOOD_PRIMARY_STAT_COEFFICIENT_SPELL_ID,
        coeff_effect: FOOD_PRIMARY_STAT_COEFFICIENT_EFFECT_INDEX,
        amount_multiplier: food_amount_multiplier(race),
    })
}

async fn resolve_food_slot(
    resolver: &DynDataResolver<'_>,
    setting: &ConsumableSetting,
    race: RaceId,
) -> Result<Option<FoodBuff>, EngineError> {
    let name = match setting {
        ConsumableSetting::Off => return Ok(None),
        ConsumableSetting::LegacyDefault => {
            return Err(EngineError::intent_validation(
                "settings[\"food\"] has no boolean default; pass a food name".to_string(),
            ));
        }
        ConsumableSetting::Named(name) => name,
    };
    let resolved =
        resolve_named_consumable(resolver, name, ConsumableSubclass::Food as i32, "food").await?;
    let food = food_buff_for_use_spell(resolved.spell_id, resolved.item_name, race);

    if food.is_none() {
        tracing::warn!(
            food = name,
            use_spell = resolved.spell_id,
            "food is not in the modelled primary-stat food table; skipping its Well Fed buff"
        );
    }

    Ok(food)
}

/// Resolve a parsed [`ConsumableSelection`] to buff spells via the data resolver.
pub(crate) async fn resolve_consumable_spells(
    resolver: &DynDataResolver<'_>,
    selection: &ConsumableSelection,
    race: RaceId,
) -> Result<ConsumableSpells, EngineError> {
    Ok(ConsumableSpells {
        potion: resolve_buff_slot(
            resolver,
            &selection.potion,
            ConsumableSubclass::Potion as i32,
            "potion",
            (TEMPERED_POTION_SPELL_ID, TEMPERED_POTION_NAME),
        )
        .await?,
        flask: resolve_buff_slot(
            resolver,
            &selection.flask,
            ConsumableSubclass::Flask as i32,
            "flask",
            (FLASK_ALCHEMICAL_CHAOS_SPELL_ID, FLASK_ALCHEMICAL_CHAOS_NAME),
        )
        .await?,
        food: resolve_food_slot(resolver, &selection.food, race).await?,
        augment_rune: resolve_augment_rune_slot(resolver, &selection.augment_rune).await?,
    })
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use rstest::rstest;
    use wowlab_engine_domain::dbc::{SpellAttributeKind, spell_attribute_is};

    use super::*;

    fn settings(pairs: Vec<(&str, toml::Value)>) -> BTreeMap<String, toml::Value> {
        pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect()
    }

    #[gtest]
    fn defaults_are_legacy_flask_and_rune_no_potion_no_food() -> Result<()> {
        let sel = parse_consumable_selection(&settings(vec![]))?;

        verify_that!(
            sel,
            matches_pattern!(ConsumableSelection {
                potion: eq(&ConsumableSetting::Off),
                flask: eq(&ConsumableSetting::LegacyDefault),
                food: eq(&ConsumableSetting::Off),
                augment_rune: eq(&ConsumableSetting::LegacyDefault),
            })
        )
    }

    #[gtest]
    #[rstest]
    #[case::tempered_prepot(Some("tempered"), true, ConsumableSetting::LegacyDefault)]
    #[case::named_prepot(
        Some("lights_potential_2"),
        true,
        ConsumableSetting::Named("lights_potential_2".to_string())
    )]
    #[case::no_prepot(Some("lights_potential_2"), false, ConsumableSetting::Off)]
    #[case::prepot_without_potion_stays_off(None, true, ConsumableSetting::Off)]
    fn potion_gated_on_pre_pot(
        #[case] potion: Option<&str>,
        #[case] pre_pot: bool,
        #[case] expected: ConsumableSetting,
    ) -> Result<()> {
        let mut pairs = vec![("pre_pot", toml::Value::Boolean(pre_pot))];

        if let Some(p) = potion {
            pairs.push(("potion", toml::Value::String(p.to_string())));
        }

        let sel = parse_consumable_selection(&settings(pairs))?;

        verify_that!(sel.potion, eq(&expected))
    }

    #[gtest]
    #[rstest]
    #[case::bool_false(toml::Value::Boolean(false), ConsumableSetting::Off)]
    #[case::bool_true(toml::Value::Boolean(true), ConsumableSetting::LegacyDefault)]
    #[case::named(
        toml::Value::String("flask_of_the_shattered_sun_2".to_string()),
        ConsumableSetting::Named("flask_of_the_shattered_sun_2".to_string())
    )]
    fn flask_accepts_bool_or_name(
        #[case] value: toml::Value,
        #[case] expected: ConsumableSetting,
    ) -> Result<()> {
        let sel = parse_consumable_selection(&settings(vec![("flask", value)]))?;

        verify_that!(sel.flask, eq(&expected))
    }

    #[gtest]
    fn flask_rejects_non_bool_non_string() -> Result<()> {
        let result =
            parse_consumable_selection(&settings(vec![("flask", toml::Value::Integer(1))]));

        verify_that!(result, err(anything()))
    }

    #[gtest]
    fn food_rejects_boolean_true() -> Result<()> {
        let result =
            parse_consumable_selection(&settings(vec![("food", toml::Value::Boolean(true))]));

        verify_that!(result, err(anything()))
    }

    #[gtest]
    #[rstest]
    #[case::rank_stripped("flask_of_the_shattered_sun_2", "flask_of_the_shattered_sun")]
    #[case::rank_three("lights_potential_3", "lights_potential")]
    #[case::no_rank("void_touched", "void_touched")]
    #[case::trailing_word_not_rank("royal_roast", "royal_roast")]
    fn split_quality_rank_arms(#[case] input: &str, #[case] expected: &str) -> Result<()> {
        verify_that!(split_quality_rank(input).0, eq(expected))
    }

    fn item(id: i32, name: &str, use_spell: i32) -> ItemDataFlat {
        ItemDataFlat {
            id,
            name: name.into(),
            effects: vec![wowlab_types::data::ItemEffect {
                spell_id: use_spell,
                trigger_type: 0,
                charges: 0,
                cooldown: 0,
                category_cooldown: 0,
            }],
            ..ItemDataFlat::default()
        }
    }

    fn item_at_ilvl(id: i32, name: &str, use_spell: i32, item_level: i32) -> ItemDataFlat {
        ItemDataFlat {
            item_level,
            ..item(id, name, use_spell)
        }
    }

    #[gtest]
    fn pick_item_prefers_exact_token_over_fleeting_variant() -> Result<()> {
        let items = vec![
            item(245_928, "Fleeting Flask of the Shattered Sun", 1_235_111),
            item(241_326, "Flask of the Shattered Sun", 1_235_111),
        ];
        let picked = pick_item(&items, "flask_of_the_shattered_sun", 1).or_fail()?;

        verify_that!(picked.id, eq(241_326))
    }

    #[gtest]
    fn pick_item_rank_selects_by_item_level() -> Result<()> {
        let items = vec![
            item_at_ilvl(241_326, "Flask of the Shattered Sun", 1_235_111, 295),
            item_at_ilvl(241_327, "Flask of the Shattered Sun", 1_235_111, 278),
        ];
        let rank1 = pick_item(&items, "flask_of_the_shattered_sun", 1).or_fail()?;
        let rank2 = pick_item(&items, "flask_of_the_shattered_sun", 2).or_fail()?;
        let rank9 = pick_item(&items, "flask_of_the_shattered_sun", 9).or_fail()?;

        verify_that!(rank1.item_level, eq(278))?;
        verify_that!(rank2.item_level, eq(295))?;

        verify_that!(rank9.item_level, eq(295))
    }

    #[gtest]
    fn pick_item_falls_back_to_shortest_containing_name() -> Result<()> {
        let items = vec![
            item(2, "Quel'dorei Medley Deluxe", 11),
            item(1, "Quel'dorei Medley", 10),
        ];
        let picked = pick_item(&items, "medley", 1).or_fail()?;

        verify_that!(picked.id, eq(1))
    }

    #[gtest]
    fn pick_item_no_match_is_none() -> Result<()> {
        let items = vec![item(1, "Flask of the Magisters", 5)];

        verify_that!(pick_item(&items, "lights_potential", 1), none())
    }

    #[gtest]
    #[rstest]
    #[case::rank_two("flask_of_the_shattered_sun_2", 2)]
    #[case::no_rank("void_touched", 1)]
    fn split_quality_rank_parses_rank(#[case] input: &str, #[case] expected: u8) -> Result<()> {
        verify_that!(split_quality_rank(input).1, eq(expected))
    }

    #[gtest]
    fn scale_ilevel_attribute_uses_shared_registry_coordinates() -> Result<()> {
        let mut attributes = vec![0i32; 16];

        verify_that!(
            spell_attribute_is(&attributes, SpellAttributeKind::ScalesWithCastingItemLevel),
            eq(false)
        )?;
        let kind = SpellAttributeKind::ScalesWithCastingItemLevel;

        attributes[kind.block()] = kind.mask();

        verify_that!(spell_attribute_is(&attributes, kind), eq(true))
    }

    #[gtest]
    fn food_buff_map_covers_harandar_and_misses_unknown() -> Result<()> {
        let food =
            food_buff_for_use_spell(1_259_658, "Harandar Celebration".to_string(), RaceId::Human)
                .or_fail()?;

        verify_that!(
            food,
            matches_pattern!(FoodBuff {
                spell_id: eq(&1_232_582),
                coeff_spell_id: eq(&FOOD_PRIMARY_STAT_COEFFICIENT_SPELL_ID),
                coeff_effect: eq(&FOOD_PRIMARY_STAT_COEFFICIENT_EFFECT_INDEX),
                amount_multiplier: near(1.0, 1e-12),
                ..
            })
        )?;

        verify_that!(
            food_buff_for_use_spell(999, "x".to_string(), RaceId::Human),
            none()
        )
    }

    #[gtest]
    fn pandaren_food_is_doubled() -> Result<()> {
        let food = food_buff_for_use_spell(
            1_259_658,
            "Harandar Celebration".to_string(),
            RaceId::PandarenA,
        )
        .or_fail()?;

        verify_that!(food.amount_multiplier, near(2.0, 1e-12))
    }
}