forge/

simc.rs

// #t(file: rust_alloc_in_loop) CLI binary, allocations are fine for readability.
// #t(file: rust_forbidden_deps) forge is CLI-only, never targets WASM.

#![expect(
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    reason = "SimC reports non-negative bounded mean cast counts as JSON floating-point values"
)]

//! `SimcProvider`: shells out to the `SimC` binary and parses json2 output.

use std::{collections::BTreeSet, process::Command};

use anyhow::{Context, Result, bail};
use wowlab_common::output;
use wowlab_fs::{
    directory::{self, EntryKind},
    file,
    path::{Path, PathBuf},
    temporary,
};
use wowlab_types::game::SpecId;

use crate::provider::{CastEntry, ComparisonConfig, SimOutput, SimProvider, SpellResult};

const SIMC_STDERR_TRUNCATE: usize = 500;

const DEFAULT_BUILD_JOBS: usize = 4;

#[rustfmt::skip]
const SIMC_SKIP: &[&str] = &[
    // tidy-alphabetical-start
    "augmentation",
    "flask",
    "food",
    "potion",
    "snapshot_stats",
    "use_items",
    // tidy-alphabetical-end
];

#[derive(Debug)]
pub(crate) struct SimcProvider;

impl SimProvider for SimcProvider {
    fn name(&self) -> &'static str {
        "SimC"
    }

    fn run(&self, config: &ComparisonConfig) -> Result<SimOutput> {
        run_simc(config)
    }
}

fn simc_dir() -> PathBuf {
    crate::constants::workspace_parent().join("simc")
}

fn simc_binary() -> PathBuf {
    simc_dir().join("build/simc")
}

fn ensure_simc_binary() -> Result<PathBuf> {
    let binary = simc_binary();

    match directory::inspect(&binary)
        .with_context(|| format!("failed to inspect SimC binary {}", binary.display()))?
    {
        Some(entry) if entry.kind() == EntryKind::File => return Ok(binary),
        Some(_) => bail!(
            "SimC binary path is not a regular file: {}",
            binary.display()
        ),
        None => {}
    }

    let dir = simc_dir();

    match directory::inspect(&dir)
        .with_context(|| format!("failed to inspect SimC repository {}", dir.display()))?
    {
        Some(entry) if entry.kind() == EntryKind::Directory => {}
        Some(_) => bail!("SimC repository path is not a directory: {}", dir.display()),
        None => {
            bail!(
                "SimC repo not found at {0}. Clone it next to this workspace: \
                 git clone git@github.com:simulationcraft/simc.git {0}",
                dir.display(),
            );
        }
    }

    let build_dir = dir.join("build");

    directory::ensure(&build_dir)
        .with_context(|| format!("failed to create {}", build_dir.display()))?;

    let jobs = std::thread::available_parallelism()
        .map_or(DEFAULT_BUILD_JOBS, std::num::NonZeroUsize::get);

    output::detail(&format!(
        "SimC binary missing; building in {} (-j{jobs})...",
        build_dir.display(),
    ));

    run_build_step(
        &build_dir,
        "cmake",
        &["..".to_string(), "-DBUILD_GUI=OFF".to_string()],
    )?;
    run_build_step(&build_dir, "make", &[format!("-j{jobs}")])?;

    match directory::inspect(&binary)
        .with_context(|| format!("failed to inspect SimC binary {}", binary.display()))?
    {
        Some(entry) if entry.kind() == EntryKind::File => {}
        Some(_) => bail!(
            "SimC build finished but binary path is not a regular file: {}",
            binary.display(),
        ),
        None => bail!(
            "SimC build finished but binary still missing at {}",
            binary.display(),
        ),
    }

    Ok(binary)
}

fn run_build_step(cwd: &Path, program: &str, args: &[String]) -> Result<()> {
    let status = Command::new(program)
        .current_dir(cwd)
        .args(args)
        .status()
        .with_context(|| format!("failed to spawn {program}"))?;

    if !status.success() {
        bail!("{program} failed while building SimC ({status})");
    }

    Ok(())
}

pub(crate) fn simc_profile_path(spec: SpecId) -> Option<PathBuf> {
    let name = slug_to_simc_profile(spec)?;
    let path = simc_dir()
        .join("profiles/MID1")
        .join(format!("{name}.simc"));

    is_regular_file(&path).then_some(path)
}

fn simc_assisted_path(spec: SpecId) -> Option<PathBuf> {
    let name = slug_to_assisted(spec)?;
    let path = simc_dir()
        .join("ActionPriorityLists/assisted_combat")
        .join(format!("{name}.simc"));

    is_regular_file(&path).then_some(path)
}

fn is_regular_file(path: &Path) -> bool {
    directory::inspect(path)
        .ok()
        .flatten()
        .is_some_and(|entry| entry.kind() == EntryKind::File)
}

// #t(fn: rust_cyclomatic_complexity) 1:1 spec-to-filename match table
fn slug_to_assisted(spec: SpecId) -> Option<&'static str> {
    match spec {
        // tidy-alphabetical-start
        SpecId::Affliction => Some("warlock_affliction"),
        SpecId::Arcane => Some("mage_arcane"),
        SpecId::Arms => Some("warrior_arms"),
        SpecId::Assassination => Some("rogue_assassination"),
        SpecId::Balance => Some("druid_balance"),
        SpecId::BeastMastery => Some("hunter_beast_mastery"),
        SpecId::Demonology => Some("warlock_demonology"),
        SpecId::Destruction => Some("warlock_destruction"),
        SpecId::Devastation => Some("evoker_devastation"),
        SpecId::Devourer => Some("demonhunter_devourer"),
        SpecId::Elemental => Some("shaman_elemental"),
        SpecId::Enhancement => Some("shaman_enhancement"),
        SpecId::Feral => Some("druid_feral"),
        SpecId::Fire => Some("mage_fire"),
        SpecId::FrostDK => Some("deathknight_frost"),
        SpecId::FrostMage => Some("mage_frost"),
        SpecId::Fury => Some("warrior_fury"),
        SpecId::Havoc => Some("demonhunter_havoc"),
        SpecId::Marksmanship => Some("hunter_marksmanship"),
        SpecId::Outlaw => Some("rogue_outlaw"),
        SpecId::Retribution => Some("paladin_retribution"),
        SpecId::Shadow => Some("priest_shadow"),
        SpecId::Subtlety => Some("rogue_subtlety"),
        SpecId::Survival => Some("hunter_survival"),
        SpecId::Unholy => Some("deathknight_unholy"),
        SpecId::Vengeance => Some("demonhunter_vengeance"),
        SpecId::Windwalker => Some("monk_windwalker"),
        // tidy-alphabetical-end
        _ => None,
    }
}

// #t(fn: rust_cyclomatic_complexity) 1:1 spec-to-filename match table
fn slug_to_simc_profile(spec: SpecId) -> Option<&'static str> {
    match spec {
        // tidy-alphabetical-start
        SpecId::Affliction => Some("MID1_Warlock_Affliction"),
        SpecId::Arcane => Some("MID1_Mage_Arcane"),
        SpecId::Arms => Some("MID1_Warrior_Arms"),
        SpecId::Assassination => Some("MID1_Rogue_Assassination"),
        SpecId::Balance => Some("MID1_Druid_Balance"),
        SpecId::BeastMastery => Some("MID1_Hunter_Beast_Mastery"),
        SpecId::Demonology => Some("MID1_Warlock_Demonology"),
        SpecId::Destruction => Some("MID1_Warlock_Destruction"),
        SpecId::Devastation => Some("MID1_Evoker_Devastation"),
        SpecId::Devourer => Some("MID1_Demon_Hunter_Devourer"),
        SpecId::Elemental => Some("MID1_Shaman_Elemental"),
        SpecId::Enhancement => Some("MID1_Shaman_Enhancement"),
        SpecId::Feral => Some("MID1_Druid_Feral"),
        SpecId::Fire => Some("MID1_Mage_Fire"),
        SpecId::FrostDK => Some("MID1_Death_Knight_Frost"),
        SpecId::FrostMage => Some("MID1_Mage_Frost"),
        SpecId::Fury => Some("MID1_Warrior_Fury"),
        SpecId::Havoc => Some("MID1_Demon_Hunter_Havoc"),
        SpecId::Marksmanship => Some("MID1_Hunter_Marksmanship"),
        SpecId::Outlaw => Some("MID1_Rogue_Outlaw"),
        SpecId::Retribution => Some("MID1_Paladin_Retribution"),
        SpecId::Shadow => Some("MID1_Priest_Shadow"),
        SpecId::Subtlety => Some("MID1_Rogue_Subtlety"),
        SpecId::Survival => Some("MID1_Hunter_Survival"),
        SpecId::Unholy => Some("MID1_Death_Knight_Unholy"),
        SpecId::Vengeance => Some("MID1_Demon_Hunter_Vengeance"),
        SpecId::Windwalker => Some("MID1_Monk_Windwalker"),
        // tidy-alphabetical-end
        _ => None,
    }
}

pub(crate) fn supports_comparison(spec: SpecId) -> bool {
    slug_to_assisted(spec).is_some() && slug_to_simc_profile(spec).is_some()
}

/// Extracts precombat variable definitions so the assisted APL's `use_items` expansions don't dangle and zero the `SimC` side.
fn extract_precombat_variables(profile: &Path) -> Vec<String> {
    let text = file::read_text(profile).unwrap_or_default();
    let mut vars = Vec::new();

    for line in text.lines() {
        if let Some(rest) = line.strip_prefix("actions.precombat") {
            let action = rest
                .strip_prefix("+=/")
                .or_else(|| rest.strip_prefix('='))
                .unwrap_or("");

            if action.starts_with("variable,") {
                vars.push(action.to_string());
            }
        }
    }

    vars
}

/// Actions that only start the actor's auto-attack loop rather than making a rotation decision.
#[rustfmt::skip]
const AUTO_ATTACK_ACTIONS: &[&str] = &[
    // tidy-alphabetical-start
    "auto_attack",
    "auto_shot",
    // tidy-alphabetical-end
];

/// Returns every action string declared for `list` in a `.simc` file, in declaration order.
fn extract_list_actions(source: &Path, list: &str) -> Vec<String> {
    let text = file::read_text(source).unwrap_or_default();
    let prefix = if list == "default" {
        "actions".to_string()
    } else {
        format!("actions.{list}")
    };
    let mut actions = Vec::new();

    for line in text.lines() {
        let Some(rest) = line.strip_prefix(&prefix) else {
            continue;
        };
        let action = if let Some(appended) = rest.strip_prefix("+=") {
            appended.strip_prefix('/').unwrap_or(appended)
        } else {
            let Some(assigned) = rest.strip_prefix('=') else {
                continue;
            };

            assigned.strip_prefix('/').unwrap_or(assigned)
        };

        if !action.is_empty() {
            actions.push(action.to_string());
        }
    }

    actions
}

/// The auto-attack action a profile declares that the assisted dump never does.
fn dropped_auto_attack(profile: &Path, assisted: &Path) -> Option<String> {
    let assisted_text = file::read_text(assisted).unwrap_or_default();

    extract_action_lists(profile)
        .iter()
        .flat_map(|list| extract_list_actions(profile, list))
        .find(|action| {
            AUTO_ATTACK_ACTIONS.contains(&action.as_str())
                && !assisted_text.contains(action.as_str())
        })
}

pub(crate) fn extract_action_lists(profile: &Path) -> Vec<String> {
    let text = file::read_text(profile).unwrap_or_default();
    let mut names = BTreeSet::new();

    for line in text.lines() {
        if let Some(rest) = line.strip_prefix("actions.") {
            if let Some(name) = rest.split(['+', '=']).next() {
                names.insert(name.to_string());
            }
        } else if line.starts_with("actions+") || line.starts_with("actions=") {
            names.insert("default".to_string());
        }
    }

    names.into_iter().collect()
}

/// Swaps the profile's action lists for the assisted dump, keeping its profile-only setup actions.
fn append_assisted_arguments(cmd_args: &mut Vec<String>, profile: &Path, assisted: &Path) {
    for name in extract_action_lists(profile) {
        if name == "default" {
            cmd_args.push("actions=/".to_string());
        } else {
            cmd_args.push(format!("actions.{name}=/"));
        }
    }

    cmd_args.push(assisted.display().to_string());

    // Rebuild the default list with the auto-attack seeded first, exactly where every assisted
    // dump that does declare one puts it.

    if let Some(action) = dropped_auto_attack(profile, assisted) {
        cmd_args.push(format!("actions=/{action}"));

        for line in extract_list_actions(assisted, "default") {
            cmd_args.push(format!("actions+=/{line}"));
        }
    }

    for var in extract_precombat_variables(profile) {
        cmd_args.push(format!("actions.precombat+=/{var}"));
    }
}

fn run_simc(config: &ComparisonConfig) -> Result<SimOutput> {
    let binary = ensure_simc_binary()?;

    let profile = simc_profile_path(config.spec)
        .ok_or_else(|| anyhow::anyhow!("no SimC profile for {}", config.spec.slug()))?;
    let output = temporary::Directory::with_prefix("wowlab-forge-simc-")
        .context("failed to create temporary SimC output directory")?;
    let json_path = output.path().join("result.json");

    let mut cmd_args: Vec<String> = vec![profile.display().to_string()];

    if let Some(assisted) = simc_assisted_path(config.spec) {
        let apl_name = assisted.file_name().unwrap_or_default().to_string_lossy();

        output::detail(&format!("Using assisted APL: {apl_name}"));
        append_assisted_arguments(&mut cmd_args, &profile, &assisted);
    }

    append_run_arguments(&mut cmd_args, config, &json_path);

    output::detail(&format!(
        "Running SimC ({} iter, {}s)...",
        config.parameters.iterations(),
        config.parameters.fight_duration_secs(),
    ));

    let cmd_output = Command::new(&binary)
        .args(&cmd_args)
        .output()
        .context("failed to spawn SimC")?;

    if !cmd_output.status.success() {
        let stderr = String::from_utf8_lossy(&cmd_output.stderr);
        let truncated: String = stderr.chars().take(SIMC_STDERR_TRUNCATE).collect();

        bail!("SimC failed:\n{truncated}");
    }

    if config.simc_debug {
        retain_debug_log(config.spec, &cmd_output.stdout)?;
    }

    let json_text = file::read_text(&json_path).context("failed to read SimC json2 output")?;

    parse_json2(&json_text, config)
}

fn append_run_arguments(arguments: &mut Vec<String>, config: &ComparisonConfig, json_path: &Path) {
    arguments.extend([
        format!("max_time={}", config.parameters.fight_duration_secs()),
        format!("iterations={}", config.parameters.iterations()),
        "fight_style=Patchwerk".to_string(),
        // The engine simulates a lone actor; external raid buffs/debuffs would skew every dpc.
        "optimal_raid=0".to_string(),
        format!("json2={}", json_path.display()),
        "threads=1".to_string(),
        // Pin the RNG so SimC re-runs are reproducible, mirroring the seed-deterministic engine side.
        format!("seed={}", crate::constants::DEFAULT_SEED),
    ]);

    if let Some(ref race) = config.race {
        arguments.push(format!("race={race}"));
    }

    if !config.bugs {
        arguments.push("bugs=0".to_string());
    }

    if config.simc_debug {
        arguments.push("debug=1".to_string());
    }
}

/// Writes `SimC`'s debug stdout beside the engine trace log so both sides can be grepped factor by factor.
fn retain_debug_log(spec: SpecId, stdout: &[u8]) -> Result<()> {
    let log = temporary::File::with_affixes(&format!("forge-simc-debug-{}-", spec.slug()), ".log")
        .context("failed to create SimC debug log")?
        .retain()
        .context("failed to create SimC debug log")?;
    let path = log.path().to_path_buf();

    file::write_bytes(&path, stdout).context("failed to write SimC debug log")?;
    output::detail(&format!("SimC debug log written to: {}", path.display()));

    Ok(())
}

// #t(fn: rust_unchecked_indexing) serde_json::Value indexing returns Value::Null for missing keys, never panics
fn parse_resource_gains(
    player: &serde_json::Value,
) -> std::collections::BTreeMap<String, crate::provider::ResourceGain> {
    let mut resource_gains = std::collections::BTreeMap::new();
    let Some(gains) = player["gains"].as_array() else {
        return resource_gains;
    };

    for gain in gains {
        let (Some(name), Some(obj)) = (gain["name"].as_str(), gain.as_object()) else {
            continue;
        };

        for (key, value) in obj {
            if key == "name" {
                continue;
            }

            let gained = value["actual"].as_f64().unwrap_or(0.0);
            let wasted = value["overflow"].as_f64().unwrap_or(0.0);

            if gained > 0.0 || wasted > 0.0 {
                let entry = resource_gains
                    .entry(name.to_string())
                    .or_insert(crate::provider::ResourceGain::default());

                entry.gained += gained;
                entry.wasted += wasted;
            }
        }
    }

    resource_gains
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum StatsOwner {
    Player,
    Pet,
}

impl StatsOwner {
    fn report_name(self, name: &str) -> String {
        if self == Self::Pet && matches!(name, "auto_attack_mh" | "auto_attack_oh") {
            format!("pet_{name}")
        } else {
            name.to_string()
        }
    }
}

// #t(fn: rust_unchecked_indexing) serde_json::Value indexing returns Value::Null for missing keys, never panics
fn push_spell_result(
    s: &serde_json::Value,
    mean_dps: f64,
    owner: StatsOwner,
    spells: &mut Vec<(String, SpellResult)>,
) {
    // Heal/absorb rows report portion_amount of their own pool (absorbs report 1.0), not damage.
    if s["type"].as_str().is_some_and(|t| t != "damage") {
        return;
    }
    // portion_amount is each row's share of total damage; portion_aps is pet-active-time normalized and inflates temporary-pet rows.

    let dps = s["portion_amount"].as_f64().map_or_else(
        || s["portion_aps"]["mean"].as_f64().unwrap_or(0.0),
        |p| p * mean_dps,
    );

    if dps <= 0.0 {
        return;
    }

    let pct = if mean_dps > 0.0 { dps / mean_dps } else { 0.0 };
    // Pet, guardian, and proc rows report zero executes but still land results.
    let hits = s["num_direct_results"]["mean"].as_f64().unwrap_or(0.0)
        + s["num_tick_results"]["mean"].as_f64().unwrap_or(0.0);

    let name = owner.report_name(s["name"].as_str().unwrap_or("?"));

    spells.push((
        name,
        SpellResult {
            casts: s["num_executes"]["mean"].as_f64().unwrap_or(0.0) as u32,
            hits: hits as u32,
            dps,
            pct,
        },
    ));
}

// #t(fn: rust_unchecked_indexing) serde_json::Value indexing returns Value::Null for missing keys, never panics
fn collect_stats<'a>(
    stats: &'a serde_json::Value,
    mean_dps: f64,
    owner: StatsOwner,
    spells: &mut Vec<(String, SpellResult)>,
) {
    // Child actions carry their own damage that never rolls up into the parent's portion figures, nesting arbitrarily deep.
    let mut queue: Vec<&'a serde_json::Value> = vec![stats];

    while let Some(node) = queue.pop() {
        let Some(arr) = node.as_array() else {
            continue;
        };

        for s in arr {
            push_spell_result(s, mean_dps, owner, spells);
            queue.push(&s["children"]);
        }
    }
}

// #t(fn: rust_unchecked_indexing) serde_json::Value indexing returns Value::Null for missing keys, never panics
fn parse_json2(json_text: &str, config: &ComparisonConfig) -> Result<SimOutput> {
    let root: serde_json::Value = serde_json::from_str(json_text).context("invalid SimC json2")?;
    let player = &root["sim"]["players"][0];

    let mean_dps = player["collected_data"]["dps"]["mean"]
        .as_f64()
        .unwrap_or(0.0);

    let mut spells = Vec::new();

    collect_stats(&player["stats"], mean_dps, StatsOwner::Player, &mut spells);
    let resource_gains = parse_resource_gains(player);
    // Pet damage lives under stats_pets and never rolls up into the owner's stats array.

    if let Some(pets) = player["stats_pets"].as_object() {
        for pet_stats in pets.values() {
            collect_stats(pet_stats, mean_dps, StatsOwner::Pet, &mut spells);
        }
    }

    let mut timeline = Vec::new();

    if config.parameters.iterations() == 1 {
        if let Some(seq) = player["collected_data"]["action_sequence"].as_array() {
            for event in seq {
                let name = event["name"].as_str().unwrap_or("").to_string();

                if SIMC_SKIP.contains(&name.as_str()) {
                    continue;
                }

                let time_secs = event["time"].as_f64().unwrap_or(0.0);

                timeline.push(CastEntry {
                    time_secs,
                    spell_name: name,
                });
            }
        }
    }

    let mut output = SimOutput::new(mean_dps, spells, timeline);

    output.resource_gains = resource_gains;

    Ok(output)
}

#[cfg(test)]
mod tests;