wowlab_sentinel/mcp/tools/

effects.rs

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use sqlx::{PgPool, Row};
use wowlab_types::{
    data::{ItemEffect, SpellEffect},
    sim::{FastMap, FastSet},
};

const MAX_IDS: usize = 50;

#[derive(Debug, Default, Deserialize, JsonSchema)]
#[schemars(
    description = "Resolve spell and/or item effects. Provide at least one of spell_ids or item_ids (max 50 total)."
)]
pub(super) struct ResolveEffectsInput {
    #[serde(default)]
    #[schemars(description = "Spell IDs to resolve effects for.")]
    pub spell_ids: Option<Vec<i32>>,
    #[serde(default)]
    #[schemars(description = "Item IDs to resolve effects for.")]
    pub item_ids: Option<Vec<i32>>,
}

#[derive(Debug, Serialize)]
pub(super) struct SpellWithEffects {
    pub id: i32,
    pub name: String,
    pub school_mask: i32,
    pub duration: i32,
    pub effects: Vec<SpellEffect>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub trigger_spells: Vec<SpellWithEffects>,
}

#[derive(Debug, Serialize)]
pub(super) struct ItemWithEffects {
    pub id: i32,
    pub name: String,
    pub effects: Vec<ItemEffect>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub effect_spells: Vec<SpellWithEffects>,
}

#[derive(Debug, Serialize)]
pub(super) struct ResolveEffectsOutput {
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub spells: Vec<SpellWithEffects>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub items: Vec<ItemWithEffects>,
}

pub(super) async fn execute(
    db: &PgPool,
    input: ResolveEffectsInput,
) -> Result<ResolveEffectsOutput, super::ToolError> {
    let spell_ids = input.spell_ids.unwrap_or_default();
    let item_ids = input.item_ids.unwrap_or_default();

    if spell_ids.is_empty() && item_ids.is_empty() {
        return Err("Provide at least one spell_id or item_id".into());
    }

    if spell_ids.len() + item_ids.len() > MAX_IDS {
        return Err(format!("Max {MAX_IDS} total IDs per request").into());
    }

    let (spell_rows, item_rows) = futures::future::try_join(
        async {
            if spell_ids.is_empty() {
                Ok(vec![])
            } else {
                fetch_spells(db, &spell_ids).await
            }
        },
        async {
            if item_ids.is_empty() {
                Ok(vec![])
            } else {
                fetch_items(db, &item_ids).await
            }
        },
    )
    .await?;

    let trigger_ids = collect_trigger_ids(&spell_ids, &spell_rows, &item_rows);
    let trigger_rows = if trigger_ids.is_empty() {
        vec![]
    } else {
        fetch_spells(db, &trigger_ids).await?
    };

    Ok(assemble_output(&spell_rows, &item_rows, &trigger_rows))
}

fn collect_trigger_ids(
    spell_ids: &[i32],
    spell_rows: &[SpellRow],
    item_rows: &[ItemRow],
) -> Vec<i32> {
    let requested: FastSet<i32> = spell_ids.iter().copied().collect();
    let mut trigger_ids = FastSet::default();

    for row in spell_rows {
        for eff in &row.effects {
            if eff.trigger_spell != 0 && !requested.contains(&eff.trigger_spell) {
                trigger_ids.insert(eff.trigger_spell);
            }
        }
    }

    for row in item_rows {
        for eff in &row.effects {
            if eff.spell_id != 0 && !requested.contains(&eff.spell_id) {
                trigger_ids.insert(eff.spell_id);
            }
        }
    }

    trigger_ids.into_iter().collect()
}

fn assemble_output(
    spell_rows: &[SpellRow],
    item_rows: &[ItemRow],
    trigger_rows: &[SpellRow],
) -> ResolveEffectsOutput {
    let mut trigger_map: FastMap<i32, &SpellRow> = spell_rows.iter().map(|r| (r.id, r)).collect();

    for r in trigger_rows {
        trigger_map.entry(r.id).or_insert(r);
    }

    let spells = spell_rows
        .iter()
        .map(|row| to_spell_with_effects(row, &trigger_map))
        .collect();

    let items = item_rows
        .iter()
        .map(|row| {
            let mut seen = FastSet::default();
            let unique_effects = row
                .effects
                .iter()
                .filter(|e| e.spell_id != 0 && seen.insert(e.spell_id))
                .filter_map(|e| trigger_map.get(&e.spell_id));
            let effect_spells = unique_effects.map(|t| to_spell_leaf(t)).collect();

            ItemWithEffects {
                id: row.id,
                name: row.name.clone(),
                effects: row.effects.clone(),
                effect_spells,
            }
        })
        .collect();

    ResolveEffectsOutput { spells, items }
}

fn to_spell_with_effects(
    row: &SpellRow,
    trigger_map: &FastMap<i32, &SpellRow>,
) -> SpellWithEffects {
    let mut seen = FastSet::default();
    let unique_triggers = row
        .effects
        .iter()
        .filter(|e| e.trigger_spell != 0 && seen.insert(e.trigger_spell))
        .filter_map(|e| trigger_map.get(&e.trigger_spell));
    let trigger_spells = unique_triggers.map(|t| to_spell_leaf(t)).collect();

    SpellWithEffects {
        id: row.id,
        name: row.name.clone(),
        school_mask: row.school_mask,
        duration: row.duration,
        effects: row.effects.clone(),
        trigger_spells,
    }
}

fn to_spell_leaf(row: &SpellRow) -> SpellWithEffects {
    SpellWithEffects {
        id: row.id,
        name: row.name.clone(),
        school_mask: row.school_mask,
        duration: row.duration,
        effects: row.effects.clone(),
        trigger_spells: vec![],
    }
}

// #t(rust_similar_structs) database spell rows omit recursive trigger output owned by the MCP response DTO
struct SpellRow {
    id: i32,
    name: String,
    school_mask: i32,
    duration: i32,
    effects: Vec<SpellEffect>,
}

struct ItemRow {
    id: i32,
    name: String,
    effects: Vec<ItemEffect>,
}

async fn fetch_spells(db: &PgPool, ids: &[i32]) -> Result<Vec<SpellRow>, super::ToolError> {
    let rows = sqlx::query(
        "SELECT id, name, school_mask, duration, effects FROM game.spells WHERE id = ANY($1)",
    )
    .bind(ids)
    .fetch_all(db)
    .await
    .map_err(|e| e.to_string())?;

    rows.iter()
        .map(|r| {
            let effects_json: Value = r
                .try_get("effects")
                .unwrap_or_else(|_| Value::Array(vec![]));
            let effects: Vec<SpellEffect> =
                serde_json::from_value(effects_json).unwrap_or_default();

            Ok(SpellRow {
                id: r.try_get("id").map_err(|e| e.to_string())?,
                name: r.try_get("name").map_err(|e| e.to_string())?,
                school_mask: r.try_get("school_mask").unwrap_or(0),
                duration: r.try_get("duration").unwrap_or(0),
                effects,
            })
        })
        .collect()
}

async fn fetch_items(db: &PgPool, ids: &[i32]) -> Result<Vec<ItemRow>, super::ToolError> {
    let rows = sqlx::query("SELECT id, name, effects FROM game.items WHERE id = ANY($1)")
        .bind(ids)
        .fetch_all(db)
        .await
        .map_err(|e| e.to_string())?;

    rows.iter()
        .map(|r| {
            let effects_json: Value = r
                .try_get("effects")
                .unwrap_or_else(|_| Value::Array(vec![]));
            let effects: Vec<ItemEffect> = serde_json::from_value(effects_json).unwrap_or_default();

            Ok(ItemRow {
                id: r.try_get("id").map_err(|e| e.to_string())?,
                name: r.try_get("name").map_err(|e| e.to_string())?,
                effects,
            })
        })
        .collect()
}

pub(super) async fn handle(
    db: &PgPool,
    params: ResolveEffectsInput,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
    let result = execute(db, params)
        .await
        .map_err(|e| crate::mcp::mcp_error(crate::telemetry::McpTool::ResolveEffects, &e))?;

    Ok(crate::mcp::json_result(result))
}