wowlab_parsers/parsers/transform/loot/

item_drop_scaling.rs

use wowlab_engine_domain::dbc::{
    DungeonDifficultyFlags, GemSubclass, InventoryType, ItemBonusListGroupEntryFlags,
    ItemBonusType, ItemClass, ItemContext, RaidDifficultyFlags,
};
use wowlab_types::{
    constants::CURRENT_EXPANSION_ID,
    data::{DifficultyKey, DropSourceKind, InstanceKind, ItemDropScalingFlat},
    sim::{FastMap, FastSet, IntMap},
};

use super::journal::transform_all_journal_instances;
use crate::parsers::dbc::DbcData;

const VAULT_BR_MIN_MPL: i32 = 10;
const MYTHIC_PLUS_SHARED_BASE_SEQ: i32 = 2;
const RARE_RAID_GROUP_MOD_SET_ID: i32 = 2967;
const DEFAULT_BOSS_TIER: i32 = 1;
const INACTIVE_WORLD_STATE_EXPRESSIONS: &[i32] = &[50187];

#[rustfmt::skip]
const MYTHIC_PLUS_BUCKETS: &[(DifficultyKey, i32)] = &[
    // #t:aligned
    (DifficultyKey::MythicPlusTwoThree , 2) ,
    (DifficultyKey::MythicPlusFour     , 4) ,
    (DifficultyKey::MythicPlusFive     , 5) ,
    (DifficultyKey::MythicPlusSixSeven , 6) ,
    (DifficultyKey::MythicPlusEightNine, 8) ,
    (DifficultyKey::MythicPlusTenPlus  , 10),
];

fn list_has_type(dbc: &DbcData, list_id: i32, bonus_type: ItemBonusType) -> bool {
    dbc.item_bonus
        .get(&list_id)
        .is_some_and(|rows| rows.iter().any(|r| r.Type == bonus_type as i32))
}

fn max_regular_seq_for_group(dbc: &DbcData, group: i32) -> i32 {
    let mut max = 1;

    if let Some(entries) = dbc.item_bonus_list_group_entry.get(&group) {
        for entry in entries {
            if entry.Flags != ItemBonusListGroupEntryFlags::REGULAR.bits() {
                continue;
            }

            if !list_has_type(dbc, entry.ItemBonusListID, ItemBonusType::Upgrade) {
                continue;
            }

            if entry.SequenceValue > max {
                max = entry.SequenceValue;
            }
        }
    }

    max
}

fn walk_tree_nodes(
    dbc: &DbcData,
    tree_id: i32,
) -> Vec<&crate::parsers::dbc::rows::ItemBonusTreeNodeRow> {
    let mut out: Vec<&crate::parsers::dbc::rows::ItemBonusTreeNodeRow> = Vec::new();
    let mut seen = FastSet::default();

    seen.insert(tree_id);
    let mut stack: Vec<&crate::parsers::dbc::rows::ItemBonusTreeNodeRow> = Vec::new();

    if let Some(nodes) = dbc.item_bonus_tree_node.get(&tree_id) {
        for node in nodes.iter().rev() {
            stack.push(node);
        }
    }

    while let Some(node) = stack.pop() {
        out.push(node);
        let child = node.ChildItemBonusTreeID;

        if child > 0 && seen.insert(child) {
            if let Some(child_nodes) = dbc.item_bonus_tree_node.get(&child) {
                for child_node in child_nodes.iter().rev() {
                    stack.push(child_node);
                }
            }
        }
    }

    out
}

// #t(fn: rust_cyclomatic_complexity) one match arm per ItemContext family (raid/dungeon/M+/vault)
fn node_difficulties_and_seqs(
    node: &crate::parsers::dbc::rows::ItemBonusTreeNodeRow,
    source_kind: DropSourceKind,
    boss_tier: i32,
    rare_seq: i32,
) -> Vec<(DifficultyKey, i32)> {
    let Ok(ctx) = ItemContext::try_from(node.ItemContext) else {
        return Vec::new();
    };

    if source_kind == DropSourceKind::Raid {
        let diff = match ctx {
            ItemContext::RaidLfr => DifficultyKey::Lfr,
            ItemContext::RaidNormal => DifficultyKey::Normal,
            ItemContext::RaidHeroic => DifficultyKey::Heroic,
            ItemContext::RaidMythic => DifficultyKey::Mythic,
            _ => return Vec::new(),
        };
        let seq = if node.IblGroupPointsModSetID == RARE_RAID_GROUP_MOD_SET_ID {
            rare_seq
        } else {
            boss_tier
        };

        return vec![(diff, seq)];
    }

    match ctx {
        ItemContext::DungeonNormal => vec![(DifficultyKey::Normal, 1)],
        ItemContext::DungeonHeroic => vec![(DifficultyKey::Heroic, 1)],
        ItemContext::DungeonMythic => vec![(DifficultyKey::Mythic, 1)],
        ItemContext::MythicKeystone => {
            let min_mpl = node.MinMythicPlusLevel;
            let hi = if node.MaxMythicPlusLevel == 0 {
                i32::MAX
            } else {
                node.MaxMythicPlusLevel
            };
            let base_seq = if min_mpl == 0 {
                MYTHIC_PLUS_SHARED_BASE_SEQ
            } else {
                1
            };
            let mut out = Vec::new();
            let mut filtered_index = 0;

            for &(diff, key) in MYTHIC_PLUS_BUCKETS {
                if key >= min_mpl && key <= hi {
                    out.push((diff, base_seq + filtered_index));
                    filtered_index += 1;
                }
            }

            out
        }
        ItemContext::MythicKeystoneVault => {
            let min_mpl = node.MinMythicPlusLevel;

            if min_mpl >= VAULT_BR_MIN_MPL || (min_mpl == 0 && node.MaxMythicPlusLevel == 0) {
                vec![(DifficultyKey::MythicPlusVaultBr, 1)]
            } else {
                Vec::new()
            }
        }
        _ => Vec::new(),
    }
}

// #t(fn: rust_max_nesting) per-node candidate selection over (difficulty, sequence) pairs
// #t(fn: rust_cyclomatic_complexity) direct/group/type branching mirrors the reference resolver
fn resolve_bonuses(
    dbc: &DbcData,
    override_dests: &IntMap<i32, Vec<i32>>,
    item_id: i32,
    source_kind: DropSourceKind,
    boss_tier: i32,
) -> FastMap<DifficultyKey, (i32, i32)> {
    let Some(roots) = dbc.item_x_bonus_tree.get(&item_id) else {
        return FastMap::default();
    };

    if roots.is_empty() {
        return FastMap::default();
    }

    let normal_trees: Vec<i32> = roots.iter().map(|r| r.ItemBonusTreeID).collect();

    let override_count = normal_trees
        .iter()
        .filter_map(|tree| override_dests.get(tree))
        .map(Vec::len)
        .sum::<usize>();
    let mut all_trees = Vec::with_capacity(normal_trees.len() + override_count);

    for tree in &normal_trees {
        if let Some(dests) = override_dests.get(tree) {
            for &dest in dests {
                if !all_trees.contains(&dest) {
                    all_trees.push(dest);
                }
            }
        }
    }

    for tree in &normal_trees {
        if !all_trees.contains(tree) {
            all_trees.push(*tree);
        }
    }

    let mut upgrade_by_diff = FastMap::default();
    let mut flair_by_diff = FastMap::default();

    for tree in all_trees {
        for node in walk_tree_nodes(dbc, tree) {
            let direct = node.ChildItemBonusListID;
            let group = node.ChildItemBonusListGroupID;
            let rare_seq = if group > 0 {
                max_regular_seq_for_group(dbc, group)
            } else {
                1
            };

            for (diff, seq) in node_difficulties_and_seqs(node, source_kind, boss_tier, rare_seq) {
                let mut upgrade_candidate: Option<i32> = None;
                let mut flair_candidate: Option<i32> = None;

                if direct > 0 {
                    if list_has_type(dbc, direct, ItemBonusType::Upgrade) {
                        upgrade_candidate = Some(direct);
                    }

                    if list_has_type(dbc, direct, ItemBonusType::Flair) {
                        flair_candidate = Some(direct);
                    }
                } else if group > 0 {
                    if let Some(entries) = dbc.item_bonus_list_group_entry.get(&group) {
                        if let Some(entry) = entries.iter().find(|e| {
                            e.SequenceValue == seq
                                && list_has_type(dbc, e.ItemBonusListID, ItemBonusType::Upgrade)
                        }) {
                            upgrade_candidate = Some(entry.ItemBonusListID);
                        }
                    }
                } else {
                    continue;
                }

                if let Some(upgrade) = upgrade_candidate {
                    upgrade_by_diff.entry(diff).or_insert(upgrade);
                }

                let current_upgrade = upgrade_by_diff.get(&diff).copied();

                if let Some(flair) = flair_candidate {
                    if Some(flair) != current_upgrade && !flair_by_diff.contains_key(&diff) {
                        flair_by_diff.insert(diff, flair);
                    }
                }
            }
        }
    }

    let mut result = FastMap::default();

    result.reserve(upgrade_by_diff.len() + flair_by_diff.len());

    for (&diff, &upgrade) in &upgrade_by_diff {
        let flair = flair_by_diff.get(&diff).copied().unwrap_or(0);

        result.insert(diff, (upgrade, flair));
    }

    for (&diff, &flair) in &flair_by_diff {
        result.entry(diff).or_insert((0, flair));
    }

    result
}

fn build_override_dests(dbc: &DbcData) -> IntMap<i32, Vec<i32>> {
    let mut map: IntMap<i32, Vec<i32>> = IntMap::default();

    for row in dbc.challenge_mode_item_bonus_override.values() {
        let src = row.SrcItemBonusTreeID;
        let dst = row.DstItemBonusTreeID;

        if src == 0 || dst == 0 {
            continue;
        }

        let dests = map.entry(src).or_default();

        if !dests.contains(&dst) {
            dests.push(dst);
        }
    }

    map
}

fn build_excluded_item_set(dbc: &DbcData) -> FastSet<i32> {
    let mut excluded = FastSet::default();

    for item in dbc.item.values() {
        if item.ClassID == ItemClass::Gem as i32
            && item.SubclassID == GemSubclass::ArtifactRelic as i32
        {
            excluded.insert(item.ID);
            continue;
        }

        if item.InventoryType == InventoryType::NonEquippable as i32
            && item.ClassID != ItemClass::Weapon as i32
            && item.ClassID != ItemClass::Armor as i32
            && item.ClassID != ItemClass::Miscellaneous as i32
        {
            excluded.insert(item.ID);
        }
    }

    excluded
}

fn build_boss_tier_map(dbc: &DbcData) -> IntMap<i32, i32> {
    let mut map: IntMap<i32, i32> = IntMap::default();

    for row in dbc.dungeon_encounter.values() {
        if row.boss_tier > 0 {
            map.insert(row.ID, row.boss_tier);
        }
    }

    map
}

fn expand_raid_mask(mask: i32) -> Vec<DifficultyKey> {
    let flags = RaidDifficultyFlags::from_bits_retain(mask);
    let mut out = Vec::new();

    if flags.contains(RaidDifficultyFlags::LFR) {
        out.push(DifficultyKey::Lfr);
    }

    if flags.contains(RaidDifficultyFlags::NORMAL) {
        out.push(DifficultyKey::Normal);
    }

    if flags.contains(RaidDifficultyFlags::HEROIC) {
        out.push(DifficultyKey::Heroic);
    }

    if flags.contains(RaidDifficultyFlags::MYTHIC) {
        out.push(DifficultyKey::Mythic);
    }

    out
}

// Bit2 (Mythic) also unlocks every M+ bucket + Vault key (M+ brackets are runtime modifiers on Mythic).
fn expand_dungeon_mask(mask: i32) -> Vec<DifficultyKey> {
    let flags = DungeonDifficultyFlags::from_bits_retain(mask);
    let mut out = Vec::new();

    if flags.contains(DungeonDifficultyFlags::NORMAL) {
        out.push(DifficultyKey::Normal);
    }

    if flags.contains(DungeonDifficultyFlags::HEROIC) {
        out.push(DifficultyKey::Heroic);
    }

    if flags.contains(DungeonDifficultyFlags::MYTHIC) {
        out.extend_from_slice(&[
            DifficultyKey::Mythic,
            DifficultyKey::MythicPlusTwoThree,
            DifficultyKey::MythicPlusFour,
            DifficultyKey::MythicPlusFive,
            DifficultyKey::MythicPlusSixSeven,
            DifficultyKey::MythicPlusEightNine,
            DifficultyKey::MythicPlusTenPlus,
            DifficultyKey::MythicPlusVaultBr,
        ]);
    }

    out
}

#[cfg(test)]
#[expect(
    clippy::items_after_test_module,
    reason = "private helper tests remain adjacent to the resolver helpers they exercise"
)]
mod tests {
    use googletest::prelude::*;
    use rstest::rstest;

    use super::*;
    use crate::parsers::{
        dbc::rows::ItemBonusTreeNodeRow,
        transform::fixtures::{challenge_override_row, dbc, item_bonus_row, item_row},
    };

    type NodeDifficultyCase = (
        i32,
        i32,
        i32,
        i32,
        DropSourceKind,
        i32,
        i32,
        Vec<(DifficultyKey, i32)>,
    );

    fn node(ctx: i32, mod_set: i32, min: i32, max: i32) -> ItemBonusTreeNodeRow {
        ItemBonusTreeNodeRow {
            ID: 1,
            ItemContext: ctx,
            ChildItemBonusTreeID: 0,
            ChildItemBonusListID: 0,
            ChildItemBonusListGroupID: 0,
            IblGroupPointsModSetID: mod_set,
            MinMythicPlusLevel: min,
            MaxMythicPlusLevel: max,
            ParentItemBonusTreeID: 0,
        }
    }

    #[gtest]
    #[rstest]
    #[case::all_bits(-1, vec![
        DifficultyKey::Lfr,
        DifficultyKey::Normal,
        DifficultyKey::Heroic,
        DifficultyKey::Mythic,
    ])]
    #[case::none(0, vec![])]
    #[case::lfr_only(1, vec![DifficultyKey::Lfr])]
    #[case::heroic_mythic(0b1100, vec![DifficultyKey::Heroic, DifficultyKey::Mythic])]
    fn expand_raid_mask_cases(
        #[case] mask: i32,
        #[case] expected: Vec<DifficultyKey>,
    ) -> Result<()> {
        verify_that!(expand_raid_mask(mask), eq(&expected))
    }

    #[gtest]
    #[rstest]
    #[case::normal(1, vec![DifficultyKey::Normal])]
    #[case::heroic(2, vec![DifficultyKey::Heroic])]
    #[case::mythic_expands(4, vec![
        DifficultyKey::Mythic,
        DifficultyKey::MythicPlusTwoThree,
        DifficultyKey::MythicPlusFour,
        DifficultyKey::MythicPlusFive,
        DifficultyKey::MythicPlusSixSeven,
        DifficultyKey::MythicPlusEightNine,
        DifficultyKey::MythicPlusTenPlus,
        DifficultyKey::MythicPlusVaultBr,
    ])]
    #[case::all_bits(-1, vec![
        DifficultyKey::Normal,
        DifficultyKey::Heroic,
        DifficultyKey::Mythic,
        DifficultyKey::MythicPlusTwoThree,
        DifficultyKey::MythicPlusFour,
        DifficultyKey::MythicPlusFive,
        DifficultyKey::MythicPlusSixSeven,
        DifficultyKey::MythicPlusEightNine,
        DifficultyKey::MythicPlusTenPlus,
        DifficultyKey::MythicPlusVaultBr,
    ])]
    fn expand_dungeon_mask_cases(
        #[case] mask: i32,
        #[case] expected: Vec<DifficultyKey>,
    ) -> Result<()> {
        verify_that!(expand_dungeon_mask(mask), eq(&expected))
    }

    #[gtest]
    #[rstest]
    #[case::raid_normal_boss_tier((3, 0, 0, 0, DropSourceKind::Raid, 2, 9, vec![(DifficultyKey::Normal, 2)]))]
    #[case::raid_rare_uses_rare_seq((6, 2967, 0, 0, DropSourceKind::Raid, 2, 9, vec![(DifficultyKey::Mythic, 9)]))]
    #[case::raid_unknown_ctx((99, 0, 0, 0, DropSourceKind::Raid, 2, 9, vec![]))]
    #[case::dungeon_heroic((2, 0, 0, 0, DropSourceKind::Dungeon, 1, 1, vec![(DifficultyKey::Heroic, 1)]))]
    #[case::keystone_full_range((16, 0, 0, 0, DropSourceKind::Dungeon, 1, 1, vec![
        (DifficultyKey::MythicPlusTwoThree, 2),
        (DifficultyKey::MythicPlusFour, 3),
        (DifficultyKey::MythicPlusFive, 4),
        (DifficultyKey::MythicPlusSixSeven, 5),
        (DifficultyKey::MythicPlusEightNine, 6),
        (DifficultyKey::MythicPlusTenPlus, 7),
    ]))]
    #[case::keystone_min_five((16, 0, 5, 0, DropSourceKind::Dungeon, 1, 1, vec![
        (DifficultyKey::MythicPlusFive, 1),
        (DifficultyKey::MythicPlusSixSeven, 2),
        (DifficultyKey::MythicPlusEightNine, 3),
        (DifficultyKey::MythicPlusTenPlus, 4),
    ]))]
    #[case::keystone_capped((16, 0, 0, 5, DropSourceKind::Dungeon, 1, 1, vec![
        (DifficultyKey::MythicPlusTwoThree, 2),
        (DifficultyKey::MythicPlusFour, 3),
        (DifficultyKey::MythicPlusFive, 4),
    ]))]
    #[case::vault_high((35, 0, 10, 0, DropSourceKind::Dungeon, 1, 1, vec![(DifficultyKey::MythicPlusVaultBr, 1)]))]
    #[case::vault_zero_zero((35, 0, 0, 0, DropSourceKind::Dungeon, 1, 1, vec![(DifficultyKey::MythicPlusVaultBr, 1)]))]
    #[case::vault_low((35, 0, 4, 8, DropSourceKind::Dungeon, 1, 1, vec![]))]
    #[case::unknown_ctx((7, 0, 0, 0, DropSourceKind::Dungeon, 1, 1, vec![]))]
    fn node_difficulties_and_seqs_cases(#[case] case: NodeDifficultyCase) -> Result<()> {
        let (ctx, mod_set, min, max, source, boss_tier, rare_seq, expected) = case;
        let node = node(ctx, mod_set, min, max);

        verify_that!(
            node_difficulties_and_seqs(&node, source, boss_tier, rare_seq),
            eq(&expected)
        )
    }

    #[gtest]
    fn list_has_type_matches_only_present_type() -> Result<()> {
        let mut dbc = dbc();

        dbc.item_bonus
            .insert(5, vec![item_bonus_row(5, ItemBonusType::Upgrade as i32)]);

        verify_that!(list_has_type(&dbc, 5, ItemBonusType::Upgrade), eq(true))?;
        verify_that!(list_has_type(&dbc, 5, ItemBonusType::Flair), eq(false))?;

        verify_that!(list_has_type(&dbc, 99, ItemBonusType::Upgrade), eq(false))
    }

    #[gtest]
    fn build_override_dests_skips_and_dedups() -> Result<()> {
        let mut dbc = dbc();

        dbc.challenge_mode_item_bonus_override
            .insert(1, challenge_override_row(1, 5, 7));
        dbc.challenge_mode_item_bonus_override
            .insert(2, challenge_override_row(2, 0, 9));
        dbc.challenge_mode_item_bonus_override
            .insert(3, challenge_override_row(3, 5, 7));

        let dests = build_override_dests(&dbc);

        verify_that!(dests.get(&5), some(eq(&vec![7])))?;

        verify_that!(dests.get(&0), none())
    }

    #[gtest]
    fn build_excluded_item_set_classifies_items() -> Result<()> {
        let mut dbc = dbc();

        dbc.item.insert(
            1,
            item_row(
                1,
                ItemClass::Gem as i32,
                GemSubclass::ArtifactRelic as i32,
                InventoryType::NonEquippable as i32,
            ),
        );
        dbc.item.insert(
            2,
            item_row(
                2,
                ItemClass::Weapon as i32,
                0,
                InventoryType::NonEquippable as i32,
            ),
        );
        dbc.item.insert(
            3,
            item_row(
                3,
                ItemClass::TradeGoods as i32,
                0,
                InventoryType::NonEquippable as i32,
            ),
        );
        dbc.item.insert(
            4,
            item_row(4, ItemClass::Weapon as i32, 0, InventoryType::Head as i32),
        );

        let excluded = build_excluded_item_set(&dbc);

        verify_that!(excluded.contains(&1), eq(true))?;
        verify_that!(excluded.contains(&2), eq(false))?;
        verify_that!(excluded.contains(&3), eq(true))?;

        verify_that!(excluded.contains(&4), eq(false))
    }
}

/// Resolve per-difficulty Upgrade/Flair `BonusIDs` per journal-dropped item, one row per `(item_id, source_kind, difficulty_key)`.
// #t(fn: rust_max_nesting) instance -> encounter -> item -> difficulty iteration is inherent to the journal shape
// #t(fn: rust_cyclomatic_complexity) per-row filtering (world state, exclusion, legacy strip, baseline) lives here
#[must_use]
pub fn transform_all_item_drop_scaling(dbc: &DbcData) -> Vec<ItemDropScalingFlat> {
    type DiffScalingMap = FastMap<DifficultyKey, (i32, i32)>;

    let override_dests = build_override_dests(dbc);
    let excluded = build_excluded_item_set(dbc);
    let boss_tier_map = build_boss_tier_map(dbc);

    let mut items_by_encounter: IntMap<
        i32,
        Vec<&crate::parsers::dbc::rows::JournalEncounterItemRow>,
    > = IntMap::default();

    for items in dbc.journal_encounter_item.values() {
        for item in items {
            items_by_encounter
                .entry(item.JournalEncounterID)
                .or_default()
                .push(item);
        }
    }

    let instances = transform_all_journal_instances(dbc);

    let mut by_item: FastMap<(i32, DropSourceKind), DiffScalingMap> = FastMap::default();

    for instance in &instances {
        let source_kind = match instance.kind {
            InstanceKind::Raid => DropSourceKind::Raid,
            InstanceKind::Dungeon => DropSourceKind::Dungeon,
            _ => continue,
        };
        let expansion = dbc.map.get(&instance.map_id).map_or(0, |m| m.ExpansionID);
        let strip_legacy = source_kind == DropSourceKind::Dungeon
            && i64::from(expansion) < i64::from(CURRENT_EXPANSION_ID);

        for encounter in &instance.encounters {
            let boss_tier = boss_tier_map
                .get(&encounter.dungeon_encounter_id)
                .copied()
                .unwrap_or(DEFAULT_BOSS_TIER);
            let Some(items) = items_by_encounter.get(&encounter.id) else {
                continue;
            };

            for item in items {
                if INACTIVE_WORLD_STATE_EXPRESSIONS.contains(&item.WorldStateExpressionID) {
                    continue;
                }

                let item_id = item.ItemID;

                if item_id <= 0 || excluded.contains(&item_id) {
                    continue;
                }

                let mut expected = match source_kind {
                    DropSourceKind::Raid => expand_raid_mask(item.DifficultyMask),
                    DropSourceKind::Dungeon => expand_dungeon_mask(item.DifficultyMask),
                    _ => continue,
                };

                if strip_legacy {
                    expected.retain(|diff| {
                        *diff != DifficultyKey::Normal && *diff != DifficultyKey::Heroic
                    });
                }

                if expected.is_empty() {
                    continue;
                }

                let resolved =
                    resolve_bonuses(dbc, &override_dests, item_id, source_kind, boss_tier);
                let entry = by_item.entry((item_id, source_kind)).or_default();

                for diff in expected {
                    let mut pair = if source_kind == DropSourceKind::Dungeon
                        && diff == DifficultyKey::Normal
                    {
                        (0, 0)
                    } else {
                        resolved.get(&diff).copied().unwrap_or((0, 0))
                    };

                    if pair.0 == 0 {
                        pair.1 = 0;
                    }

                    match entry.get(&diff) {
                        None => {
                            entry.insert(diff, pair);
                        }
                        Some(&(cur_upgrade, cur_flair)) => {
                            let cur_empty = cur_upgrade == 0 && cur_flair == 0;
                            let new_content = pair.0 != 0 || pair.1 != 0;

                            if cur_empty && new_content {
                                entry.insert(diff, pair);
                            }
                        }
                    }
                }
            }
        }
    }

    let mut entries: Vec<((i32, DropSourceKind), DiffScalingMap)> = by_item.into_iter().collect();

    entries.sort_by(|a, b| {
        a.0.0
            .cmp(&b.0.0)
            .then_with(|| a.0.1.as_str().cmp(b.0.1.as_str()))
    });

    let mut out: Vec<ItemDropScalingFlat> = Vec::new();

    for ((item_id, source_kind), diffs) in entries {
        if !diffs.values().any(|(upgrade, _)| *upgrade != 0) {
            continue;
        }

        let mut diff_list: Vec<(DifficultyKey, (i32, i32))> = diffs.into_iter().collect();

        diff_list.sort_by_key(|(diff, _)| diff.order());

        for (difficulty_key, (upgrade_id, flair_id)) in diff_list {
            out.push(ItemDropScalingFlat {
                id: 0,
                item_id,
                source_kind,
                difficulty_key,
                upgrade_id,
                flair_id,
            });
        }
    }

    out
}