wowlab_common/sim/

derive.rs

// #t(file: rust_inline_test_module_size) tests exercise private derivation helpers and legacy equivalence fixtures

//! Single source of truth for the `(base, payload, kind)` work-expansion mapping called by sentinel and node.

use wowlab_types::{
    game::{GearEntry, GearSlot},
    proto::TournamentPayload,
};

use crate::{
    runtime::RuntimeWorkItemKind,
    sim::intent::{IntentConfigError, SimConfigIntent, serialize_sim_config},
};

wowlab_engine_macros::define_error! {
/// Errors from deriving a work-unit sim config.
#[derive(Debug)]
#[non_exhaustive]
pub struct DeriveError {
    #[source]
    kind: DeriveErrorKind,
}

#[derive(Debug, thiserror::Error)]
enum DeriveErrorKind {
    #[error("slot index {slot_idx} out of range ({len} slots)")]
    SlotOutOfRange { slot_idx: usize, len: usize },
    #[error("item index {item_idx} out of range in slot {slot_idx} ({len} items)")]
    ItemOutOfRange {
        slot_idx: usize,
        item_idx: usize,
        len: usize,
    },
    #[error("unknown gear slot slug: {0}")]
    UnknownSlot(String),
    #[error("sim config serialization failed: {0}")]
    Serialize(#[source] IntentConfigError),
}
}

impl DeriveError {
    const fn slot_out_of_range(slot_idx: usize, len: usize) -> Self {
        Self {
            kind: DeriveErrorKind::SlotOutOfRange { slot_idx, len },
        }
    }

    const fn item_out_of_range(slot_idx: usize, item_idx: usize, len: usize) -> Self {
        Self {
            kind: DeriveErrorKind::ItemOutOfRange {
                slot_idx,
                item_idx,
                len,
            },
        }
    }

    fn unknown_slot(slot: String) -> Self {
        Self {
            kind: DeriveErrorKind::UnknownSlot(slot),
        }
    }

    fn serialize(error: IntentConfigError) -> Self {
        Self {
            kind: DeriveErrorKind::Serialize(error),
        }
    }

    /// Return the unknown slot slug, when this error describes an unsupported slot.
    #[must_use]
    pub fn unknown_slot_slug(&self) -> Option<&str> {
        match &self.kind {
            DeriveErrorKind::UnknownSlot(slot) => Some(slot),
            _ => None,
        }
    }
}

impl From<IntentConfigError> for DeriveError {
    fn from(source: IntentConfigError) -> Self {
        Self::serialize(source)
    }
}

/// Decode a permutation index into per-slot item picks `(slot_idx, item_idx)`; mixed-radix, least-significant slot last.
#[must_use]
pub fn permutation_picks(payload: &TournamentPayload, perm_idx: u32) -> Vec<(usize, usize)> {
    let mut remaining = u64::from(perm_idx);
    let mut picks: Vec<(usize, usize)> = vec![(0, 0); payload.slot_candidates.len()];

    for (i, sc) in payload.slot_candidates.iter().enumerate().rev() {
        let radix = sc.items.len().max(1) as u64;
        let choice = usize::try_from(remaining % radix).unwrap_or(usize::MAX);

        remaining /= radix;
        // BOUNDS: i from enumerate() matches picks indices (same length)
        picks[i] = (i, choice);
    }

    picks
}

/// Derive the concrete sim config for one work item; only Tournament items apply gear overrides, the rest run the base config.
///
/// # Errors
///
/// Returns [`DeriveError`] for an unknown tournament slot or a serialization failure.
pub fn derive_work_unit_config(
    base_intent: &SimConfigIntent,
    payload: &TournamentPayload,
    kind: &RuntimeWorkItemKind,
) -> Result<String, DeriveError> {
    match kind {
        RuntimeWorkItemKind::Tournament { perm_idx } => {
            derive_tournament_config(base_intent, payload, *perm_idx)
        }
        RuntimeWorkItemKind::Base
        | RuntimeWorkItemKind::FactorialMain { .. }
        | RuntimeWorkItemKind::FactorialInteraction { .. } => {
            Ok(serialize_sim_config(base_intent)?)
        }
    }
}

fn derive_tournament_config(
    base_intent: &SimConfigIntent,
    payload: &TournamentPayload,
    perm_idx: u32,
) -> Result<String, DeriveError> {
    let picks = permutation_picks(payload, perm_idx);
    let mut intent = SimConfigIntent {
        intent_version: base_intent.intent_version.clone(),
        spec: base_intent.spec,
        rotation_id: base_intent.rotation_id.clone(),
        loadout: base_intent.loadout.clone(),
        expansion_talents: base_intent.expansion_talents.clone(),
        player_level: base_intent.player_level,
        player_expansion_id: base_intent.player_expansion_id,
        encounter: base_intent.encounter.clone(),
        settings: base_intent.settings.clone(),
        gear: base_intent.gear.clone(),
    };

    // #t(fn: rust_clone_in_loop) owned GearEntry requires owned bonus_ids/gem_ids per iteration

    for (slot_idx, item_idx) in picks {
        let sc = payload.slot_candidates.get(slot_idx).ok_or_else(|| {
            DeriveError::slot_out_of_range(slot_idx, payload.slot_candidates.len())
        })?;
        let item = sc
            .items
            .get(item_idx)
            .ok_or_else(|| DeriveError::item_out_of_range(slot_idx, item_idx, sc.items.len()))?;
        let gear_slot = GearSlot::from_slug(&sc.slot)
            .ok_or_else(|| DeriveError::unknown_slot(sc.slot.clone()))?;
        let entry = GearEntry {
            slot: gear_slot,
            id: item.item_id,
            bonus_ids: if item.bonus_ids.is_empty() {
                None
            } else {
                Some(item.bonus_ids.clone())
            },
            enchant_id: if item.enchant_id == 0 {
                None
            } else {
                Some(item.enchant_id)
            },
            gem_ids: if item.gem_ids.is_empty() {
                None
            } else {
                Some(item.gem_ids.clone())
            },
            crafted_stats: None,
            crafting_quality: None,
            drop_level: None,
            ilevel: None,
        };

        if let Some(existing) = intent.gear.iter_mut().find(|g| g.slot == gear_slot) {
            *existing = entry;
        } else {
            intent.gear.push(entry);
        }
    }

    Ok(serialize_sim_config(&intent)?)
}

#[cfg(test)]
mod tests {
    use std::{collections::BTreeMap, error::Error as _};

    use googletest::prelude::*;
    use wowlab_types::proto::{CandidateItem, SlotCandidates};

    use super::*;

    fn legacy_apply_gear_overrides(
        base_intent: &SimConfigIntent,
        payload: &TournamentPayload,
        perm_idx: u32,
    ) -> Option<String> {
        let picks = permutation_picks(payload, perm_idx);
        let mut intent = SimConfigIntent {
            intent_version: base_intent.intent_version.clone(),
            spec: base_intent.spec,
            rotation_id: base_intent.rotation_id.clone(),
            loadout: base_intent.loadout.clone(),
            expansion_talents: base_intent.expansion_talents.clone(),
            player_level: base_intent.player_level,
            player_expansion_id: base_intent.player_expansion_id,
            encounter: base_intent.encounter.clone(),
            settings: base_intent.settings.clone(),
            gear: base_intent.gear.clone(),
        };

        for (slot_idx, item_idx) in picks {
            let sc = payload.slot_candidates.get(slot_idx)?;
            let item = sc.items.get(item_idx)?;
            let gear_slot = GearSlot::from_slug(&sc.slot)?;
            let entry = GearEntry {
                slot: gear_slot,
                id: item.item_id,
                bonus_ids: if item.bonus_ids.is_empty() {
                    None
                } else {
                    Some(item.bonus_ids.clone())
                },
                enchant_id: if item.enchant_id == 0 {
                    None
                } else {
                    Some(item.enchant_id)
                },
                gem_ids: if item.gem_ids.is_empty() {
                    None
                } else {
                    Some(item.gem_ids.clone())
                },
                crafted_stats: None,
                crafting_quality: None,
                drop_level: None,
                ilevel: None,
            };

            if let Some(existing) = intent.gear.iter_mut().find(|g| g.slot == gear_slot) {
                *existing = entry;
            } else {
                intent.gear.push(entry);
            }
        }

        serialize_sim_config(&intent).ok()
    }

    fn base_intent() -> SimConfigIntent {
        let settings = BTreeMap::new();

        SimConfigIntent {
            intent_version: "v2".into(),
            spec: 253,
            rotation_id: "rot-1".into(),
            loadout: None,
            expansion_talents: BTreeMap::new(),
            player_level: 80,
            player_expansion_id: 11,
            encounter: wowlab_types::sim::EncounterDefinition::patchwerk(300.0, 80, 11)
                .expect("valid patchwerk"),
            settings,
            gear: vec![GearEntry {
                slot: GearSlot::Head,
                id: 1,
                bonus_ids: None,
                enchant_id: None,
                gem_ids: None,
                crafted_stats: None,
                crafting_quality: None,
                drop_level: None,
                ilevel: None,
            }],
        }
    }

    fn mixed_radix_payload() -> TournamentPayload {
        let mk = |slot: &str, ids: &[u32]| SlotCandidates {
            slot: slot.into(),
            items: ids
                .iter()
                .map(|&item_id| CandidateItem {
                    item_id,
                    bonus_ids: vec![],
                    enchant_id: 0,
                    gem_ids: vec![],
                })
                .collect(),
        };

        TournamentPayload {
            slot_candidates: vec![
                mk("head", &[100, 101, 102]),
                mk("trinket1", &[200, 201]),
                mk("chest", &[300, 301, 302, 303]),
            ],
        }
    }

    #[gtest]
    fn permutation_picks_mixed_radix() -> Result<()> {
        let payload = mixed_radix_payload();

        verify_that!(
            permutation_picks(&payload, 0),
            container_eq([(0, 0), (1, 0), (2, 0)])
        )?;
        verify_that!(
            permutation_picks(&payload, 1),
            container_eq([(0, 0), (1, 0), (2, 1)])
        )?;
        verify_that!(
            permutation_picks(&payload, 4),
            container_eq([(0, 0), (1, 1), (2, 0)])
        )?;

        verify_that!(
            permutation_picks(&payload, 8),
            container_eq([(0, 1), (1, 0), (2, 0)])
        )
    }

    #[gtest]
    fn derive_work_unit_config_tournament_byte_identical_to_legacy() -> Result<()> {
        let intent = base_intent();
        let payload = mixed_radix_payload();
        let total = 3 * 2 * 4;

        for perm_idx in 0..total {
            let derived = derive_work_unit_config(
                &intent,
                &payload,
                &RuntimeWorkItemKind::Tournament { perm_idx },
            )
            .or_fail()?;
            let legacy = legacy_apply_gear_overrides(&intent, &payload, perm_idx).or_fail()?;

            scoped_trace!("permutation index: {perm_idx}");
            verify_that!(derived, eq(&legacy))?;
        }

        Ok(())
    }

    #[gtest]
    fn derive_work_unit_config_tournament_overrides_slots() -> Result<()> {
        let intent = base_intent();
        let payload = mixed_radix_payload();
        let config = derive_work_unit_config(
            &intent,
            &payload,
            &RuntimeWorkItemKind::Tournament { perm_idx: 8 },
        )
        .or_fail()?;
        let parsed = crate::sim::intent::parse_sim_config(&config).or_fail()?;
        let head = parsed
            .gear
            .iter()
            .find(|g| g.slot == GearSlot::Head)
            .or_fail()?;

        verify_that!(head.id, eq(101))?;
        let chest = parsed
            .gear
            .iter()
            .find(|g| g.slot == GearSlot::Chest)
            .or_fail()?;

        verify_that!(chest.id, eq(300))
    }

    #[gtest]
    fn derive_work_unit_config_factorial_returns_base_config() -> Result<()> {
        let intent = base_intent();
        let payload = mixed_radix_payload();
        let base = serialize_sim_config(&intent).or_fail()?;

        let main = derive_work_unit_config(
            &intent,
            &payload,
            &RuntimeWorkItemKind::FactorialMain {
                slot_index: 1,
                item_idx: 1,
            },
        )
        .or_fail()?;

        verify_that!(main, eq(&base))?;

        let interaction = derive_work_unit_config(
            &intent,
            &payload,
            &RuntimeWorkItemKind::FactorialInteraction {
                slot_a: 0,
                item_a: 1,
                slot_b: 2,
                item_b: 1,
            },
        )
        .or_fail()?;

        verify_that!(interaction, eq(&base))?;

        let tournament = derive_work_unit_config(
            &intent,
            &payload,
            &RuntimeWorkItemKind::Tournament { perm_idx: 5 },
        )
        .or_fail()?;

        verify_that!(tournament, not(eq(&base)))
    }

    #[gtest]
    fn derive_work_unit_config_invalid_slot_errors() -> Result<()> {
        let intent = base_intent();
        let payload = TournamentPayload {
            slot_candidates: vec![SlotCandidates {
                slot: "not_a_slot".into(),
                items: vec![CandidateItem {
                    item_id: 1,
                    bonus_ids: vec![],
                    enchant_id: 0,
                    gem_ids: vec![],
                }],
            }],
        };
        let err = derive_work_unit_config(
            &intent,
            &payload,
            &RuntimeWorkItemKind::Tournament { perm_idx: 0 },
        )
        .err()
        .or_fail()?;

        verify_that!(err.unknown_slot_slug(), some(eq("not_a_slot")))
    }

    #[gtest]
    fn derive_serialization_error_preserves_intent_config_source() -> Result<()> {
        let mut intent = base_intent();

        intent.intent_version = "v1".to_string();

        let error = derive_work_unit_config(
            &intent,
            &TournamentPayload::default(),
            &RuntimeWorkItemKind::Base,
        )
        .err()
        .or_fail()?;

        verify_true!(
            error
                .source()
                .and_then(std::error::Error::source)
                .is_some_and(<dyn std::error::Error>::is::<IntentConfigError>)
        )?;

        verify_that!(
            error.to_string(),
            starts_with("sim config serialization failed: unsupported intent version \"v1\"")
        )
    }

    #[gtest]
    fn derive_work_unit_config_is_deterministic() -> Result<()> {
        let intent = base_intent();
        let payload = mixed_radix_payload();
        let kind = RuntimeWorkItemKind::Tournament { perm_idx: 7 };
        let first = derive_work_unit_config(&intent, &payload, &kind).or_fail()?;
        let second = derive_work_unit_config(&intent, &payload, &kind).or_fail()?;

        verify_that!(first, eq(&second))
    }
}