wowlab_engine_domain/rotation/

check.rs

//! Extracts referenced spell/aura/talent names and checks them against a spec resolver.

use std::collections::BTreeSet;

use wowlab_types::sim::{Condition, FieldRead, Rotation, RotationAction as Action};

use super::{condition::KeyCategory, resolver::SpecResolver};

wowlab_engine_macros::define_error! {
/// Failure to extract referenced names from a rotation JSON document.
#[derive(Debug)]
#[non_exhaustive]
pub struct NameExtractionError {
    kind: NameExtractionErrorKind,
}

#[derive(Debug, thiserror::Error)]
enum NameExtractionErrorKind {
    #[error("Failed to parse rotation: {0}")]
    Json(#[source] serde_json::Error),
}
}

impl From<serde_json::Error> for NameExtractionError {
    fn from(source: serde_json::Error) -> Self {
        Self {
            kind: NameExtractionErrorKind::Json(source),
        }
    }
}

/// All spell, aura, and talent names referenced by a parsed rotation.
#[derive(Debug, Default)]
pub struct ReferencedNames {
    pub spells: BTreeSet<String>,
    pub auras: BTreeSet<String>,
    pub talents: BTreeSet<String>,
}

/// Outcome of checking referenced names against a spec resolver.
#[derive(Debug)]
pub struct CheckResult {
    pub supported_spells: BTreeSet<String>,
    pub missing_spells: BTreeSet<String>,
    pub supported_auras: BTreeSet<String>,
    pub missing_auras: BTreeSet<String>,
    pub supported_talents: BTreeSet<String>,
    pub missing_talents: BTreeSet<String>,
}

impl CheckResult {
    /// Total missing names across all categories.
    #[must_use]
    pub fn total_missing(&self) -> usize {
        self.missing_spells.len() + self.missing_auras.len() + self.missing_talents.len()
    }

    /// True when every referenced name resolved.
    #[must_use]
    pub fn is_clean(&self) -> bool {
        self.total_missing() == 0
    }
}

/// Parses `json` as a [`Rotation`] and collects every referenced name.
///
/// # Errors
/// Returns the JSON parse failure as a diagnostic string.
pub fn extract_names(json: &str) -> Result<ReferencedNames, NameExtractionError> {
    let rotation: Rotation = serde_json::from_str(json)?;

    Ok(extract_names_from_rotation(&rotation))
}

/// Walks a parsed [`Rotation`] and collects every referenced name.
#[must_use]
pub fn extract_names_from_rotation(rotation: &Rotation) -> ReferencedNames {
    let mut names = ReferencedNames::default();

    for cond in rotation.variables.values() {
        walk_condition(cond, &mut names);
    }

    for action in &rotation.actions {
        walk_action(action, &mut names);
    }

    for actions in rotation.lists.values() {
        for action in actions {
            walk_action(action, &mut names);
        }
    }

    names
}

/// Partitions each referenced name into supported/missing against `resolver`.
#[must_use]
pub fn check(names: &ReferencedNames, resolver: &SpecResolver) -> CheckResult {
    let (supported_spells, missing_spells) = partition(&names.spells, |n| resolver.has_spell(n));
    let (supported_auras, missing_auras) = partition(&names.auras, |n| resolver.has_aura(n));
    let (supported_talents, missing_talents) =
        partition(&names.talents, |n| resolver.knows_talent(n));

    CheckResult {
        supported_spells,
        missing_spells,
        supported_auras,
        missing_auras,
        supported_talents,
        missing_talents,
    }
}

fn partition(
    set: &BTreeSet<String>,
    predicate: impl Fn(&str) -> bool,
) -> (BTreeSet<String>, BTreeSet<String>) {
    let mut supported = BTreeSet::new();
    let mut missing = BTreeSet::new();

    // #t(block: rust_clone_in_loop) partitioning borrowed set into two new sets requires cloning
    for name in set {
        if predicate(name) {
            supported.insert(name.clone());
        } else {
            missing.insert(name.clone());
        }
    }

    (supported, missing)
}

fn walk_action(action: &Action, names: &mut ReferencedNames) {
    if let Action::Cast { spell, .. } = action {
        names.spells.insert(spell.clone());
    }

    for cond in action.conditions() {
        walk_condition(cond, names);
    }
}

fn walk_condition(root: &Condition, names: &mut ReferencedNames) {
    for field in root.field_reads() {
        extract_field_names(field, names);
    }
}

fn extract_field_names(field: &FieldRead, names: &mut ReferencedNames) {
    let Some(key) = &field.key else { return };

    match KeyCategory::for_domain(&field.domain) {
        Some(KeyCategory::Spell) => {
            names.spells.insert(key.clone());
        }
        Some(KeyCategory::Aura) => {
            names.auras.insert(key.clone());
        }
        Some(KeyCategory::Named)
            if field.domain == super::condition::domain::TALENT
                || field.domain == super::condition::domain::HERO_TREE =>
        {
            names.talents.insert(key.clone());
        }
        _ => {}
    }
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    #[gtest]
    fn extract_names_from_simple_rotation() -> Result<()> {
        let json = r#"{
            "version": 1,
            "name": "Test",
            "variables": {},
            "actions": [{ "type": "call", "list": "main" }],
            "lists": {
                "main": [
                    {
                        "type": "cast",
                        "spell": "kill_command",
                        "condition": { "type": "read", "domain": "cooldown", "name": "is_ready", "key": "kill_command" }
                    },
                    {
                        "type": "cast",
                        "spell": "cobra_shot",
                        "condition": { "type": "compare", "op": "gte", "left": { "type": "read", "domain": "resource", "name": "current", "key": "focus" }, "right": { "type": "int", "value": 50 } }
                    },
                    {
                        "type": "cast",
                        "spell": "barbed_shot",
                        "condition": { "type": "read", "domain": "aura", "name": "is_active", "key": "frenzy" }
                    }
                ]
            }
        }"#;

        let names = extract_names(json).unwrap();

        verify_that!(names.spells, contains(eq("kill_command")))?;
        verify_that!(names.spells, contains(eq("cobra_shot")))?;
        verify_that!(names.spells, contains(eq("barbed_shot")))?;
        verify_that!(names.auras, contains(eq("frenzy")))?;
        verify_that!(names.talents, is_empty())?;

        Ok(())
    }

    #[gtest]
    fn extract_names_with_target_auras_and_talents() -> Result<()> {
        let json = r#"{
            "version": 1,
            "name": "Test",
            "variables": {
                "use_dot": { "type": "read", "domain": "aura", "name": "is_refreshable", "key": "serpent_sting", "on": "target" }
            },
            "actions": [],
            "lists": {
                "main": [
                    {
                        "type": "cast",
                        "spell": "aimed_shot",
                        "condition": { "type": "read", "domain": "talent", "name": "is_enabled", "key": "careful_aim" }
                    }
                ]
            }
        }"#;

        let names = extract_names(json).unwrap();

        verify_that!(names.spells, contains(eq("aimed_shot")))?;
        verify_that!(names.auras, contains(eq("serpent_sting")))?;
        verify_that!(names.talents, contains(eq("careful_aim")))?;

        Ok(())
    }

    #[gtest]
    fn check_against_resolver() -> Result<()> {
        let resolver = SpecResolver::new("test")
            .spell("kill_command", 1)
            .spell("cobra_shot", 2)
            .aura("frenzy", 100)
            .talent("killer_instinct", true);

        let mut names = ReferencedNames::default();

        names.spells.insert("kill_command".to_string());
        names.spells.insert("cobra_shot".to_string());
        names.spells.insert("unknown_spell".to_string());
        names.auras.insert("frenzy".to_string());
        names.auras.insert("unknown_buff".to_string());
        names.talents.insert("killer_instinct".to_string());
        names.talents.insert("unknown_talent".to_string());

        let result = check(&names, &resolver);

        verify_that!(result.supported_spells.len(), eq(2))?;
        verify_that!(result.missing_spells.len(), eq(1))?;
        verify_that!(result.missing_spells, contains(eq("unknown_spell")))?;
        verify_that!(result.supported_auras.len(), eq(1))?;
        verify_that!(result.missing_auras.len(), eq(1))?;
        verify_that!(result.missing_auras, contains(eq("unknown_buff")))?;
        verify_that!(result.supported_talents.len(), eq(1))?;
        verify_that!(result.missing_talents.len(), eq(1))?;
        verify_that!(result.total_missing(), eq(3))?;
        verify_that!(result.is_clean(), eq(false))?;

        Ok(())
    }

    #[gtest]
    fn clean_result() -> Result<()> {
        let resolver = SpecResolver::new("test")
            .spell("kill_command", 1)
            .aura("frenzy", 100);

        let mut names = ReferencedNames::default();

        names.spells.insert("kill_command".to_string());
        names.auras.insert("frenzy".to_string());

        let result = check(&names, &resolver);

        verify_that!(result.is_clean(), eq(true))?;
        verify_that!(result.total_missing(), eq(0))?;

        Ok(())
    }

    #[gtest]
    fn spell_referenced_multiple_ways_deduplicates() -> Result<()> {
        let json = r#"{
            "version": 1,
            "name": "Test",
            "variables": {},
            "actions": [],
            "lists": {
                "main": [
                    {
                        "type": "cast",
                        "spell": "bestial_wrath",
                        "condition": {
                            "type": "and",
                            "operands": [
                                { "type": "read", "domain": "spell", "name": "is_usable", "key": "bestial_wrath" },
                                { "type": "read", "domain": "cooldown", "name": "is_ready", "key": "bestial_wrath" }
                            ]
                        }
                    }
                ]
            }
        }"#;

        let names = extract_names(json).unwrap();

        verify_that!(names.spells, contains(eq("bestial_wrath")))?;
        verify_that!(names.spells.len(), eq(1))?;

        Ok(())
    }

    #[gtest]
    fn target_aura_resolves_via_dot_lookup() -> Result<()> {
        let resolver = SpecResolver::new("test").dot("serpent_sting", 200);

        let mut names = ReferencedNames::default();

        names.auras.insert("serpent_sting".to_string());

        let result = check(&names, &resolver);

        verify_that!(result.supported_auras.len(), eq(1))?;
        verify_that!(result.supported_auras, contains(eq("serpent_sting")))?;
        verify_that!(result.is_clean(), eq(true))?;

        Ok(())
    }

    #[gtest]
    fn hero_tree_extracted_as_talent() -> Result<()> {
        let json = r#"{
            "version": 1,
            "name": "Test",
            "variables": {},
            "actions": [],
            "lists": {
                "main": [
                    {
                        "type": "cast",
                        "spell": "kill_command",
                        "condition": { "type": "read", "domain": "hero_tree", "name": "is_active", "key": "pack_leader" }
                    }
                ]
            }
        }"#;

        let names = extract_names(json).unwrap();

        verify_that!(names.talents, contains(eq("pack_leader")))?;
        verify_that!(names.spells, contains(eq("kill_command")))?;

        Ok(())
    }
}