wowlab_engine_adapter_data/local/csv/

mod.rs

use std::sync::Arc;

use parking_lot::Mutex;
use wowlab_engine_domain::dbc::item_matches_consumable_query;
use wowlab_engine_ports::{
    DataResolver, EnchantmentRow, PermanentEnchantQuery, ResolverError, SpellId,
    select_permanent_enchant,
};
use wowlab_fs::path::PathBuf;
use wowlab_parsers::{
    DbcData, transform_all_content_tuning_x_difficulty, transform_all_content_tuning_x_expected,
    transform_all_content_tunings, transform_all_creature_difficulties, transform_all_creatures,
    transform_all_curve_points, transform_all_curves, transform_all_enchantments,
    transform_all_expansion_trait_trees, transform_all_expected_stat_mods,
    transform_all_expected_stats, transform_all_gem_properties, transform_all_item_bonuses,
    transform_all_item_damage_scaling, transform_all_item_offset_curves,
    transform_all_item_scaling_configs, transform_all_item_squish_eras, transform_all_items,
    transform_all_permanent_enchants, transform_all_power_types, transform_all_racial_spells,
    transform_all_rand_prop_points, transform_all_specialization_spells, transform_all_specs,
    transform_all_spells, transform_all_trait_trees, transform_challenge_mode_health,
    transform_combat_ratings, transform_combat_ratings_mult_by_ilvl, transform_hp_per_sta,
    transform_spell_scaling,
};
use wowlab_types::{
    data::{
        ChallengeModeHealthFlat, ContentTuningFlat, ContentTuningXDifficultyFlat,
        ContentTuningXExpectedFlat, CreatureDifficultyFlat, CreatureFlat, EnchantmentFlat,
        ExpansionTraitTreeFlat, ExpectedStatFlat, ExpectedStatModFlat, ItemDamageScalingFlat,
        ItemDataFlat, ItemScalingData, PermanentEnchantFlat, PowerTypeFlat, RacialSpellFlat,
        SpecDataFlat, SpecializationSpellFlat, SpellDataFlat, SpellEffect, TraitTreeFlat,
    },
    sim::{FastMap, IntMap},
};

use crate::lookup_key::ExpectedStatsKey;

type ItemDamageMap = FastMap<String, IntMap<i32, ItemDamageScalingFlat>>;

type ExpectedStatMap = FastMap<ExpectedStatsKey, ExpectedStatFlat>;

type GroupedMap<T> = IntMap<i32, Vec<T>>;

macro_rules! csv_lazy_slots {
    (
        categories {
            $(
                $category_slot:ident, $category_reader:ident: $category_value:ty
                    => $category_transform:path, $category_key:expr
            ),* $(,)?
        }
        grouped {
            $(
                $grouped_slot:ident, $grouped_reader:ident: $grouped_value:ty
                    => $grouped_transform:path, $grouped_key:expr
            ),* $(,)?
        }
        slots {
            $( $slot:ident: $value:ty ),* $(,)?
        }
    ) => {
        /// Resolver backed by lazily cached DBC-derived CSV files.
        #[derive(Debug)]
        pub struct LocalCsvResolver {
            data_dir: PathBuf,
            $(
                $category_slot: Mutex<Option<IntMap<i32, $category_value>>>,
            )*
            $(
                $grouped_slot: Mutex<Option<GroupedMap<$grouped_value>>>,
            )*
            $(
                $slot: Mutex<Option<$value>>,
            )*
        }

        impl LocalCsvResolver {
            fn empty(data_dir: PathBuf) -> Self {
                Self {
                    data_dir,
                    $(
                        $category_slot: Mutex::new(None),
                    )*
                    $(
                        $grouped_slot: Mutex::new(None),
                    )*
                    $(
                        $slot: Mutex::new(None),
                    )*
                }
            }

            $(
                fn $category_reader<R>(
                    &self,
                    access: impl FnOnce(&IntMap<i32, $category_value>) -> R,
                ) -> Result<R, ResolverError> {
                    self.read_category(
                        &self.$category_slot,
                        $category_transform,
                        $category_key,
                        access,
                    )
                }
            )*

            $(
                fn $grouped_reader<R>(
                    &self,
                    access: impl FnOnce(&GroupedMap<$grouped_value>) -> R,
                ) -> Result<R, ResolverError> {
                    self.read_grouped(
                        &self.$grouped_slot,
                        $grouped_transform,
                        $grouped_key,
                        access,
                    )
                }
            )*
        }
    };
}

csv_lazy_slots! {
    categories {
        spells, read_spells: SpellDataFlat => transform_all_spells, |row: &SpellDataFlat| row.id,
        items, read_items: ItemDataFlat => transform_all_items, |row: &ItemDataFlat| row.id,
        specs, read_specs: SpecDataFlat => transform_all_specs, |row: &SpecDataFlat| row.id,
        traits, read_traits: TraitTreeFlat => transform_all_trait_trees, |row: &TraitTreeFlat| row.spec_id,
        enchantments, read_enchantments: EnchantmentFlat => transform_all_enchantments, |row: &EnchantmentFlat| row.id,
        creatures, read_creatures: CreatureFlat => transform_all_creatures, |row: &CreatureFlat| row.id,
        content_tunings, read_content_tunings: ContentTuningFlat => transform_all_content_tunings, |row: &ContentTuningFlat| row.id,
        expected_stat_mods, read_expected_stat_mods: ExpectedStatModFlat => transform_all_expected_stat_mods, |row: &ExpectedStatModFlat| row.id,
        challenge_mode_health, read_challenge_mode_health: ChallengeModeHealthFlat => transform_challenge_mode_health, |row: &ChallengeModeHealthFlat| row.challenge_level,
    }
    grouped {
        spec_spells, read_spec_spells: SpecializationSpellFlat => transform_all_specialization_spells, |row: &SpecializationSpellFlat| row.spec_id,
        racial_spells, read_racial_spells: RacialSpellFlat => transform_all_racial_spells, |row: &RacialSpellFlat| row.race_id,
        creature_difficulties, read_creature_difficulties: CreatureDifficultyFlat => transform_all_creature_difficulties, |row: &CreatureDifficultyFlat| row.creature_id,
        content_tuning_x_difficulty, read_content_tuning_x_difficulty: ContentTuningXDifficultyFlat => transform_all_content_tuning_x_difficulty, |row: &ContentTuningXDifficultyFlat| row.content_tuning_id,
        content_tuning_x_expected, read_content_tuning_x_expected: ContentTuningXExpectedFlat => transform_all_content_tuning_x_expected, |row: &ContentTuningXExpectedFlat| row.content_tuning_id,
    }
    slots {
        dbc: Arc<DbcData>,
        expansion_traits: Vec<ExpansionTraitTreeFlat>,
        scaling_data: Arc<ItemScalingData>,
        power_types: Arc<[PowerTypeFlat]>,
        item_damage: ItemDamageMap,
        expected_stats: ExpectedStatMap,
        permanent_enchants: Arc<[PermanentEnchantFlat]>,
    }
}

impl LocalCsvResolver {
    /// Creates a resolver rooted at a directory of DBC-derived CSV files.
    #[must_use]
    pub fn new(data_dir: impl Into<PathBuf>) -> Self {
        Self::empty(data_dir.into())
    }

    fn read_category<T, R>(
        &self,
        slot: &Mutex<Option<IntMap<i32, T>>>,
        transform: fn(&DbcData) -> Vec<T>,
        key_of: fn(&T) -> i32,
        access: impl FnOnce(&IntMap<i32, T>) -> R,
    ) -> Result<R, ResolverError> {
        let mut guard = slot.lock();

        if guard.is_none() {
            let dbc = self.shared_dbc()?;
            let items = transform(&dbc);
            let mut map = IntMap::with_capacity_and_hasher(
                items.len(),
                std::hash::BuildHasherDefault::default(),
            );

            for item in items {
                map.insert(key_of(&item), item);
            }

            *guard = Some(map);
        }

        let map = guard.as_ref().ok_or_else(|| {
            ResolverError::decode(
                "category cache populated above",
                std::io::Error::other("category slot empty after populate"),
            )
        })?;

        Ok(access(map))
    }

    fn read_grouped<T, R>(
        &self,
        slot: &Mutex<Option<GroupedMap<T>>>,
        transform: fn(&DbcData) -> Vec<T>,
        key_of: fn(&T) -> i32,
        access: impl FnOnce(&GroupedMap<T>) -> R,
    ) -> Result<R, ResolverError> {
        let mut guard = slot.lock();
        let map = if let Some(map) = guard.as_ref() {
            map
        } else {
            let dbc = self.shared_dbc()?;
            let mut grouped: GroupedMap<T> = IntMap::default();

            for item in transform(&dbc) {
                grouped.entry(key_of(&item)).or_default().push(item);
            }

            guard.insert(grouped)
        };

        Ok(access(map))
    }

    fn shared_dbc(&self) -> Result<Arc<DbcData>, ResolverError> {
        let mut guard = self.dbc.lock();

        if let Some(existing) = guard.as_ref() {
            return Ok(Arc::clone(existing));
        }

        let dbc = DbcData::load_all(&self.data_dir)
            .map_err(|error| ResolverError::decode("load DBC CSVs", error))?;
        let arc = Arc::new(dbc);

        *guard = Some(Arc::clone(&arc));

        Ok(arc)
    }

    fn ensure_scaling_data(&self) -> Result<Arc<ItemScalingData>, ResolverError> {
        let mut guard = self.scaling_data.lock();

        if let Some(existing) = guard.as_ref() {
            return Ok(Arc::clone(existing));
        }

        let dbc = self.shared_dbc()?;
        let data = Arc::new(ItemScalingData::from_flat(
            transform_all_item_bonuses(&dbc),
            transform_all_curves(&dbc),
            transform_all_curve_points(&dbc),
            transform_all_rand_prop_points(&dbc),
            transform_all_item_scaling_configs(&dbc),
            transform_all_item_offset_curves(&dbc),
            transform_all_item_squish_eras(&dbc),
            transform_combat_ratings(&dbc),
            transform_hp_per_sta(&dbc),
            transform_spell_scaling(&dbc),
            transform_combat_ratings_mult_by_ilvl(&dbc),
            transform_all_gem_properties(&dbc),
        ));

        *guard = Some(Arc::clone(&data));

        Ok(data)
    }

    fn ensure_power_types(&self) -> Result<Arc<[PowerTypeFlat]>, ResolverError> {
        let mut guard = self.power_types.lock();

        if let Some(existing) = guard.as_ref() {
            return Ok(Arc::clone(existing));
        }

        let dbc = self.shared_dbc()?;
        let data: Arc<[PowerTypeFlat]> = transform_all_power_types(&dbc).into();

        *guard = Some(Arc::clone(&data));

        Ok(data)
    }

    fn ensure_item_damage<R>(
        &self,
        access: impl FnOnce(&ItemDamageMap) -> R,
    ) -> Result<R, ResolverError> {
        let mut guard = self.item_damage.lock();
        let map = if let Some(map) = guard.as_ref() {
            map
        } else {
            let dbc = self.shared_dbc()?;
            let mut by_type: ItemDamageMap = FastMap::default();

            for mut row in transform_all_item_damage_scaling(&dbc) {
                let weapon_type = std::mem::take(&mut row.weapon_type);

                by_type
                    .entry(weapon_type)
                    .or_default()
                    .insert(row.item_level, row);
            }

            guard.insert(by_type)
        };

        Ok(access(map))
    }

    fn ensure_expected_stats<R>(
        &self,
        access: impl FnOnce(&ExpectedStatMap) -> R,
    ) -> Result<R, ResolverError> {
        let mut guard = self.expected_stats.lock();
        let map = if let Some(map) = guard.as_ref() {
            map
        } else {
            let dbc = self.shared_dbc()?;
            let mut by_key: ExpectedStatMap = FastMap::default();

            for row in transform_all_expected_stats(&dbc) {
                by_key.insert(ExpectedStatsKey::new(row.expansion_id, row.lvl), row);
            }

            guard.insert(by_key)
        };

        Ok(access(map))
    }

    fn ensure_permanent_enchants(&self) -> Result<Arc<[PermanentEnchantFlat]>, ResolverError> {
        let mut guard = self.permanent_enchants.lock();

        if let Some(existing) = guard.as_ref() {
            return Ok(Arc::clone(existing));
        }

        let dbc = self.shared_dbc()?;
        let entries: Arc<[PermanentEnchantFlat]> = transform_all_permanent_enchants(&dbc).into();

        *guard = Some(Arc::clone(&entries));

        Ok(entries)
    }
}

impl DataResolver for LocalCsvResolver {
    async fn get_spell(&self, spell_id: SpellId) -> Result<SpellDataFlat, ResolverError> {
        self.read_spells(|map| map.get(&spell_id.as_i32()).cloned())?
            .ok_or_else(|| ResolverError::spell_not_found(spell_id))
    }

    async fn get_spells(&self, spell_ids: &[SpellId]) -> Result<Vec<SpellDataFlat>, ResolverError> {
        self.read_spells(|map| {
            let mut result = Vec::with_capacity(spell_ids.len());

            for &id in spell_ids {
                let spell = map
                    .get(&id.as_i32())
                    .cloned()
                    .ok_or_else(|| ResolverError::spell_not_found(id))?;

                result.push(spell);
            }

            Ok(result)
        })?
    }

    async fn get_spell_effect(
        &self,
        spell_id: SpellId,
        effect_index: u8,
    ) -> Result<SpellEffect, ResolverError> {
        self.read_spells(|map| {
            let spell = map
                .get(&spell_id.as_i32())
                .ok_or_else(|| ResolverError::spell_not_found(spell_id))?;

            crate::rows::validate_effect_index(spell_id, effect_index, &spell.effects)
        })?
    }

    async fn get_spell_effects(
        &self,
        spell_id: SpellId,
    ) -> Result<Vec<SpellEffect>, ResolverError> {
        self.read_spells(|map| {
            map.get(&spell_id.as_i32())
                .map(|spell| spell.effects.clone())
                .ok_or_else(|| ResolverError::spell_not_found(spell_id))
        })?
    }

    async fn get_item(&self, item_id: i32) -> Result<ItemDataFlat, ResolverError> {
        self.read_items(|map| map.get(&item_id).cloned())?
            .ok_or_else(|| ResolverError::item_not_found(item_id))
    }

    async fn find_consumable_items(
        &self,
        name_token: &str,
        subclass: i32,
    ) -> Result<Vec<ItemDataFlat>, ResolverError> {
        self.read_items(|map| {
            map.values()
                .filter(|item| item_matches_consumable_query(item, name_token, subclass))
                .cloned()
                .collect()
        })
    }

    async fn get_scaling_data(&self) -> Result<Arc<ItemScalingData>, ResolverError> {
        self.ensure_scaling_data()
    }

    async fn get_item_damage_scaling(
        &self,
        item_level: i32,
        weapon_type: &str,
    ) -> Result<ItemDamageScalingFlat, ResolverError> {
        self.ensure_item_damage(|by_type| {
            by_type
                .get(weapon_type)
                .and_then(|by_ilvl| by_ilvl.get(&item_level))
                .cloned()
        })?
        .ok_or_else(|| ResolverError::item_damage_scaling_not_found(weapon_type, item_level))
    }

    async fn get_expected_stats(
        &self,
        expansion_id: i32,
        lvl: i32,
    ) -> Result<ExpectedStatFlat, ResolverError> {
        self.ensure_expected_stats(|by_key| {
            by_key
                .get(&ExpectedStatsKey::new(expansion_id, lvl))
                .cloned()
        })?
        .ok_or_else(|| ResolverError::expected_stats_not_found(expansion_id, lvl))
    }

    async fn get_enchantment(&self, enchantment_id: i32) -> Result<EnchantmentRow, ResolverError> {
        self.read_enchantments(|map| map.get(&enchantment_id).map(crate::rows::enchantment_row))?
            .ok_or_else(|| ResolverError::enchantment_not_found(enchantment_id))
    }

    async fn find_permanent_enchant(
        &self,
        query: &PermanentEnchantQuery,
    ) -> Result<Option<PermanentEnchantFlat>, ResolverError> {
        let entries = self.ensure_permanent_enchants()?;

        Ok(select_permanent_enchant(&entries, query))
    }

    async fn get_power_types(&self) -> Result<Vec<PowerTypeFlat>, ResolverError> {
        Ok(self.ensure_power_types()?.to_vec())
    }

    async fn get_spec(&self, spec_id: i32) -> Result<SpecDataFlat, ResolverError> {
        self.read_specs(|map| map.get(&spec_id).cloned())?
            .ok_or_else(|| ResolverError::spec_not_found(spec_id))
    }

    async fn get_trait_tree(&self, spec_id: i32) -> Result<TraitTreeFlat, ResolverError> {
        self.read_traits(|map| map.get(&spec_id).cloned())?
            .ok_or_else(|| ResolverError::trait_tree_not_found(spec_id))
    }

    async fn get_expansion_trait_tree(
        &self,
        expansion_id: i32,
        system: &str,
    ) -> Result<ExpansionTraitTreeFlat, ResolverError> {
        let mut guard = self.expansion_traits.lock();

        if guard.is_none() {
            let dbc = self.shared_dbc()?;

            *guard = Some(transform_all_expansion_trait_trees(&dbc));
        }

        guard
            .as_ref()
            .and_then(|trees| {
                trees
                    .iter()
                    .find(|tree| tree.expansion_id == expansion_id && tree.system == system)
            })
            .cloned()
            .ok_or_else(|| ResolverError::expansion_trait_tree_not_found(expansion_id, system))
    }

    async fn get_spell_overrides(
        &self,
        spec_id: i32,
    ) -> Result<Vec<(SpellId, SpellId)>, ResolverError> {
        self.read_spec_spells(|map| {
            crate::rows::spell_override_pairs(
                map.get(&spec_id)
                    .into_iter()
                    .flatten()
                    .map(|r| (r.overrides_spell_id, r.spell_id)),
            )
        })
    }

    async fn get_specialization_spells(&self, spec_id: i32) -> Result<Vec<SpellId>, ResolverError> {
        self.read_spec_spells(|map| {
            map.get(&spec_id)
                .into_iter()
                .flatten()
                .map(|r| SpellId::new(r.spell_id))
                .collect()
        })
    }

    async fn get_racial_spells(
        &self,
        race_id: i32,
        class_id: i32,
    ) -> Result<Vec<SpellId>, ResolverError> {
        self.read_racial_spells(|map| {
            crate::rows::racial_spell_ids(
                map.get(&race_id)
                    .into_iter()
                    .flatten()
                    .map(|r| (r.spell_id, r.class_mask)),
                class_id,
            )
        })
    }

    async fn get_creature(&self, creature_id: i32) -> Result<CreatureFlat, ResolverError> {
        self.read_creatures(|map| map.get(&creature_id).cloned())?
            .ok_or_else(|| ResolverError::creature_not_found(creature_id))
    }

    async fn get_creature_difficulties(
        &self,
        creature_id: i32,
    ) -> Result<Vec<CreatureDifficultyFlat>, ResolverError> {
        self.read_creature_difficulties(|map| map.get(&creature_id).cloned().unwrap_or_default())
    }

    async fn get_content_tuning(
        &self,
        content_tuning_id: i32,
    ) -> Result<ContentTuningFlat, ResolverError> {
        self.read_content_tunings(|map| map.get(&content_tuning_id).cloned())?
            .ok_or_else(|| ResolverError::content_tuning_not_found(content_tuning_id))
    }

    async fn get_content_tuning_x_difficulty(
        &self,
        content_tuning_id: i32,
    ) -> Result<Vec<ContentTuningXDifficultyFlat>, ResolverError> {
        self.read_content_tuning_x_difficulty(|map| {
            map.get(&content_tuning_id).cloned().unwrap_or_default()
        })
    }

    async fn get_content_tuning_x_expected(
        &self,
        content_tuning_id: i32,
    ) -> Result<Vec<ContentTuningXExpectedFlat>, ResolverError> {
        self.read_content_tuning_x_expected(|map| {
            map.get(&content_tuning_id).cloned().unwrap_or_default()
        })
    }

    async fn get_expected_stat_mod(
        &self,
        expected_stat_mod_id: i32,
    ) -> Result<ExpectedStatModFlat, ResolverError> {
        self.read_expected_stat_mods(|map| map.get(&expected_stat_mod_id).cloned())?
            .ok_or_else(|| ResolverError::expected_stat_mod_not_found(expected_stat_mod_id))
    }

    async fn get_challenge_mode_health(
        &self,
        keystone_level: i32,
    ) -> Result<ChallengeModeHealthFlat, ResolverError> {
        self.read_challenge_mode_health(|map| map.get(&keystone_level).cloned())?
            .ok_or_else(|| ResolverError::challenge_mode_health_not_found(keystone_level))
    }

    async fn get_rotation_script(&self, rotation_id: &str) -> Result<String, ResolverError> {
        super::read_rotation_from_disk(&self.data_dir, rotation_id)
    }
}

#[cfg(test)]
mod tests;