wowlab_parsers/parsers/transform/loot/

mythic_plus.rs

use wowlab_types::{
    data::{
        KeyFloorEntry, KeyLevelRewardEntry, MythicPlusSeasonFlat, TrackedAffixEntry,
        TrackedDungeonEntry,
    },
    sim::FastSet,
};

use crate::parsers::dbc::DbcData;

const VALORSTONES_CURRENCY_ID: i32 = 3008;

// A complete season has one half-tier and four full crest tiers.
const EXPECTED_CREST_CURRENCY_COUNT: usize = 5;

fn current_mythic_plus_season_id(dbc: &DbcData) -> Option<i32> {
    dbc.mythic_plus_season_reward_levels
        .values()
        .flatten()
        .map(|row| row.MythicPlusSeasonID)
        .max()
}

fn pick_display_season_id(dbc: &DbcData, season_id: i32, expansion_level: i32) -> Option<i32> {
    let mut display_max_id: Option<i32> = None;
    let mut display_max_count: u32 = 0;

    for row in dbc.display_season.values() {
        if row.ExpansionID != expansion_level {
            continue;
        }

        match display_max_id {
            Some(curr) if curr == row.ID => {
                display_max_count += 1;
            }
            Some(curr) if row.ID > curr => {
                display_max_id = Some(row.ID);
                display_max_count = 1;
            }
            Some(_) => {}
            None => {
                display_max_id = Some(row.ID);
                display_max_count = 1;
            }
        }
    }

    let Some(display_id) = display_max_id else {
        tracing::warn!(
            season_id,
            expansion_level,
            "no DisplaySeason rows match ExpansionLevel; skipping mythic_plus_seasons emission"
        );

        return None;
    };

    if display_max_count > 1 {
        tracing::warn!(
            season_id,
            display_season_id = display_id,
            "multiple DisplaySeason rows tie at the same max ID; data corruption, skipping mythic_plus_seasons emission"
        );

        return None;
    }

    Some(display_id)
}

fn collect_crest_currencies(dbc: &DbcData, scaling_id: i32) -> (Vec<i32>, bool) {
    let mut crest_set = FastSet::default();
    let mut has_valorstones = false;

    if let Some(entries) = dbc.item_group_ilvl_scaling_entry.get(&scaling_id) {
        for entry in entries {
            if entry.CurrencyTypeID == VALORSTONES_CURRENCY_ID {
                has_valorstones = true;
                continue;
            }

            if entry.CurrencyTypeID != 0 {
                crest_set.insert(entry.CurrencyTypeID);
            }
        }
    }

    let mut crest_currencies: Vec<i32> = crest_set.into_iter().collect();

    crest_currencies.sort_by_key(|id| {
        dbc.currency_types
            .get(id)
            .map_or(i32::MAX, |c| c.OrderIndex)
    });

    (crest_currencies, has_valorstones)
}

/// Build the single-row `MythicPlusSeasonFlat` list for the current M+ season.
// #t(fn: rust_max_fn_lines) season aggregation pulls together M+ rewards, display season, scaling, currencies, dungeons, affixes, and floors in one pass
pub fn transform_all_mythic_plus_seasons(dbc: &DbcData) -> Vec<MythicPlusSeasonFlat> {
    let Some(season_id) = current_mythic_plus_season_id(dbc) else {
        return Vec::new();
    };
    let mut rewards: Vec<&crate::parsers::dbc::rows::MythicPlusSeasonRewardLevelsRow> = dbc
        .mythic_plus_season_reward_levels
        .get(&season_id)
        .map(|v| v.iter().collect())
        .unwrap_or_default();

    rewards.sort_by_key(|r| r.DifficultyLevel);

    let key_rewards: Vec<KeyLevelRewardEntry> = rewards
        .into_iter()
        .map(|r| KeyLevelRewardEntry {
            key_level: r.DifficultyLevel,
            activity_tier_id: r.ActivityTierID,
            weekly_reward_level: r.WeeklyRewardLevel,
            end_of_run_reward_level: r.EndOfRunRewardLevel,
        })
        .collect();

    let Some(header) = dbc.mythic_plus_season.get(&season_id) else {
        tracing::warn!(
            season_id,
            "MythicPlusSeason header row missing; skipping mythic_plus_seasons emission"
        );

        return Vec::new();
    };

    let Some(display_season_id) = pick_display_season_id(dbc, season_id, header.ExpansionLevel)
    else {
        return Vec::new();
    };
    let Some(display_season) = dbc.display_season.get(&display_season_id) else {
        tracing::warn!(
            season_id,
            display_season_id,
            "DisplaySeason row vanished between scan and lookup; skipping mythic_plus_seasons emission"
        );

        return Vec::new();
    };
    let display_season_name = display_season.display_name_lang.clone().unwrap_or_default();
    let display_season_index = display_season.Season;
    let delves_season_id = display_season.DelvesSeasonID;

    let Some(item_group_ilvl_scaling_id) = dbc
        .item_bonus_list_group
        .values()
        .filter(|row| row.SequenceSpellID != 0)
        .map(|row| row.ItemGroupIlvlScalingID)
        .max()
    else {
        tracing::warn!(
            season_id,
            "no ItemBonusListGroup rows with SequenceSpellID != 0; skipping mythic_plus_seasons emission"
        );

        return Vec::new();
    };

    let mut bonus_list_groups: Vec<i32> = dbc
        .item_bonus_list_group
        .values()
        .filter(|row| row.ItemGroupIlvlScalingID == item_group_ilvl_scaling_id)
        .map(|row| row.ID)
        .collect();

    bonus_list_groups.sort_unstable();

    let (crest_currencies, has_valorstones) =
        collect_crest_currencies(dbc, item_group_ilvl_scaling_id);

    if crest_currencies.len() != EXPECTED_CREST_CURRENCY_COUNT {
        tracing::warn!(
            season_id,
            item_group_ilvl_scaling_id,
            count = crest_currencies.len(),
            expected = EXPECTED_CREST_CURRENCY_COUNT,
            "unexpected number of crest currencies; skipping mythic_plus_seasons emission"
        );

        return Vec::new();
    }

    let valorstones_currency_id = if has_valorstones {
        VALORSTONES_CURRENCY_ID
    } else {
        0
    };

    let tracked_dungeons: Vec<TrackedDungeonEntry> = dbc
        .mythic_plus_season_tracked_map
        .get(&display_season_id)
        .map(|entries| {
            entries
                .iter()
                .filter_map(|tracked| {
                    let challenge = dbc.map_challenge_mode.get(&tracked.MapChallengeModeID)?;
                    let map_id = challenge.MapID;
                    let instance = dbc
                        .journal_instance
                        .values()
                        .find(|inst| inst.MapID == map_id)?;

                    Some(TrackedDungeonEntry {
                        map_challenge_mode_id: tracked.MapChallengeModeID,
                        map_id,
                        instance_name: instance.Name_lang.clone().unwrap_or_default(),
                    })
                })
                .collect()
        })
        .unwrap_or_default();

    let tracked_affixes: Vec<TrackedAffixEntry> = dbc
        .mythic_plus_season_tracked_affix
        .get(&display_season_id)
        .map(|entries| {
            entries
                .iter()
                .map(|row| TrackedAffixEntry {
                    keystone_affix_id: row.KeystoneAffixID,
                    bonus_rating: row.BonusRating,
                })
                .collect()
        })
        .unwrap_or_default();

    let key_floors: Vec<KeyFloorEntry> = dbc
        .mythic_plus_season_key_floor
        .get(&display_season_id)
        .map(|entries| {
            entries
                .iter()
                .map(|row| KeyFloorEntry {
                    key_floor: row.KeyFloor,
                    player_condition_id: row.PlayerConditionID,
                })
                .collect()
        })
        .unwrap_or_default();

    vec![MythicPlusSeasonFlat {
        id: season_id,
        milestone_season: header.MilestoneSeason,
        start_time_event: header.StartTimeEvent,
        expansion_level: header.ExpansionLevel,
        heroic_lfg_dungeon_min_gear: header.HeroicLFGDungeonMinGear,
        display_season_id,
        display_season_name,
        display_season_index,
        delves_season_id,
        item_group_ilvl_scaling_id,
        bonus_list_groups,
        crest_currencies,
        valorstones_currency_id,
        tracked_dungeons,
        tracked_affixes,
        key_floors,
        key_rewards,
    }]
}