wowlab_engine_content/hooks/enhancement_shaman/

hooks.rs

use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::CooldownOps as _;
use wowlab_engine_combat::ProcOps as _;
use wowlab_engine_combat::SchedulingOps as _;
use wowlab_engine_combat::GuardianOps as _;
use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::{
    DamageFlags, DamageOutcome, GuardianAbility, GuardianEvent, GuardianSpec, HookCtx, MasteryCtx,
    SwingEvent, SwingHand,
};
use wowlab_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_engine_domain::{
    constants::OFF_HAND_DAMAGE_MULT,
    dbc::{
        DefenseType, ResolvedGameDataSemanticExt as _, SpellAttributeKind, damage_def,
        spell_attribute_is,
    },
};
use wowlab_engine_gamedata::ResolvedGameData;
use wowlab_engine_rng::{accumulated_proc_chance, proc_chance};
use wowlab_types::{combat::DamageSchool, constants::HUNDRED, sim::SpellIdx};

use crate::generated::specs::enhancement_shaman::{
    AURA, AURA_AMPLIFICATION_CORE, AURA_CRACKLING_SURGE, AURA_CRASH_LIGHTNING, AURA_DOOM_WINDS,
    AURA_FLAME_SHOCK, AURA_HOT_HAND, AURA_LASHING_FLAMES, AURA_MAELSTROM_WEAPON,
    AURA_MOLTEN_WEAPON, AURA_STORM_UNLEASHED, AURA_STORMSURGE, AURA_SURGING_TOTEM,
    AURA_TOTEMIC_REBOUND, AURA_WHIRLING_AIR, AURA_WHIRLING_EARTH, AURA_WHIRLING_FIRE, EFFECT,
    REPORTED_SPELL, SPELL, SPELL_LAVA_LASH, SPELL_STORMSTRIKE, TALENT,
};

/// Stormflurry (344357) e1: echo chance.
const STORMFLURRY_CHANCE: f64 = 0.20;
/// Stormflurry (344357) e2: echo damage percent.
const STORMFLURRY_MULT: f64 = 0.40;
/// Doom Winds (466772) e1: +100% Windfury proc chance while active.
const DOOM_WINDS_WF_PROC_MULT: f64 = 2.0;
/// `SimC`'s accumulated RNG base chance for Imbuement Mastery.
const IMBUEMENT_MASTERY_CHANCE: f64 = 0.07;
const LIVELY_TOTEMS_CHANCE: f64 = 0.06;
/// Maelstrom Weapon 187880: 20% melee proc with spell 384149 e2's stack cap.
const MW_CONSUME_CAP: i32 = 10;
/// Maelstrom Weapon talent 187880 e3: +20% damage per stack consumed.
const MW_DMG_PER_STACK: f64 = 0.20;
/// Whirling Air (453409 e3): three guaranteed bolts on the next direct lightning cast.
const WHIRLING_AIR_BOLTS: u32 = 3;
/// Earthsurge e1 multiplier is 150%.
const EARTHSURGE_MULT: f64 = 1.5;
/// Whirling Fire (453405 e1) starts or extends Hot Hand by 8 seconds.
const WHIRLING_FIRE_HOT_HAND_MS: u32 = 8_000;
/// Synthetic guardian tags distinguish elemental wolf actors without using game spell IDs.
const FIRE_WOLF_GUARDIAN_TAG: u32 = 4_693_141;
const LIGHTNING_WOLF_GUARDIAN_TAG: u32 = 4_693_142;
const SEARING_TOTEM_DURATION_MS: u32 = 8_000;
const SEARING_TOTEM_PULSE_MS: u32 = 2_000;
const PRIMORDIAL_FROST_DELAY_MS: u32 = 300;
const PRIMORDIAL_LIGHTNING_DELAY_MS: u32 = 600;
const PRIMORDIAL_LIGHTNING_BOLT_DELAY_MS: u32 = 950;
const PRIMORDIAL_LIGHTNING_BOLT_MULT: f64 = 1.5;
const SURGING_BOLT_DELAY_MS: u32 = 300;
const WHIRLING_AIR_BOLT_SPACING_MS: u32 = 500;
const CRASH_LIGHTNING_UNLEASHED_FIRST_MS: u32 = 1_000;
const CRASH_LIGHTNING_UNLEASHED_SECOND_MS: u32 = 2_000;
/// Ride the Lightning 289874 e2 always unleashes Chain Lightning.
const RIDE_THE_LIGHTNING_MULT: f64 = 1.0;

/// Disables DBC damage children that an affected spell's cast hook owns.
pub(crate) const fn hook_owned_damage_trigger_disabled(_ctx: &HookCtx<'_>) -> bool {
    false
}

fn windfury_chance(ctx: &HookCtx<'_>) -> f64 {
    let base = ctx
        .game_data()
        .proc_chance(SpellIdx::from_raw(EFFECT::WINDFURY_PROC.0))
        .unwrap_or(0.0);
    let mastery_bonus = ctx.effect_points(EFFECT::WINDFURY_MASTERY) / HUNDRED;
    let mut chance = base + mastery_bonus;

    if ctx.is_aura_active(AURA_DOOM_WINDS.raw()) {
        chance *= DOOM_WINDS_WF_PROC_MULT;
    }

    chance
}

fn stormsurge_chance(ctx: &HookCtx<'_>) -> f64 {
    let base = ctx
        .game_data()
        .proc_chance(SpellIdx::from_raw(SPELL::STORMSURGE_DRIVER))
        .unwrap_or(0.0);

    base + ctx.effect_points(EFFECT::STORMSURGE_MASTERY) / HUNDRED
}

use super::{
    config::{EnhancementConfig, EnhancementRuntime, WINDFURY_BASE_HITS, enhancement_config},
    guardians::summon_feral_spirit,
};

fn searing_totem_pulse(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx
        .game_data()
        .effect_sp_coefficient(EFFECT::SEARING_BOLT_DAMAGE);

    ctx.deal_damage_sp(SPELL::SEARING_BOLT, coefficient, DamageFlags::empty());
}

fn summon_searing_totem(ctx: &mut HookCtx<'_>) {
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(TALENT::LIVELY_TOTEMS, SEARING_TOTEM_DURATION_MS)
            .ability(
                GuardianAbility::new(SEARING_TOTEM_PULSE_MS, searing_totem_pulse)
                    .first_action_delay(SEARING_TOTEM_PULSE_MS),
            ),
    );
}

fn trigger_searing_volley(ctx: &mut HookCtx<'_>) {
    let count = ctx.active_guardian_count(TALENT::LIVELY_TOTEMS);

    if count == 0 {
        return;
    }

    let coefficient = ctx
        .game_data()
        .effect_sp_coefficient(EFFECT::SEARING_VOLLEY_DAMAGE);

    for _ in 0..count {
        ctx.deal_damage_sp(SPELL::SEARING_VOLLEY, coefficient, DamageFlags::empty());
    }
}

fn deal_tremor(ctx: &mut HookCtx<'_>, mult: f64) {
    let coefficient = ctx.game_data().effect_ap_coefficient(EFFECT::TREMOR_DAMAGE);

    ctx.deal_damage_ap(SPELL::TREMOR, coefficient * mult, DamageFlags::empty());
}

fn deal_surging_bolt(ctx: &mut HookCtx<'_>) {
    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) == 0 {
        return;
    }

    let coefficient = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::SURGING_BOLT_DAMAGE);

    ctx.deal_damage_ap(SPELL::SURGING_BOLT, coefficient, DamageFlags::PET);
}

fn trigger_totemic_rebound(ctx: &mut HookCtx<'_>, forced: bool, delay_ms: u32) {
    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) == 0 {
        return;
    }

    if !forced && !ctx.roll_system_rppm(EFFECT::TOTEMIC_REBOUND_RPPM_DRIVER.0) {
        return;
    }

    ctx.apply_aura(AURA_TOTEMIC_REBOUND.raw());
    ctx.schedule_hook(delay_ms, deal_surging_bolt);
}

fn trigger_direct_lightning_totemic(ctx: &mut HookCtx<'_>) {
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);

    if ctx.is_aura_active(AURA_WHIRLING_AIR.raw()) {
        for bolt in 0..WHIRLING_AIR_BOLTS {
            let delay_ms = SURGING_BOLT_DELAY_MS + bolt * WHIRLING_AIR_BOLT_SPACING_MS;

            trigger_totemic_rebound(ctx, true, delay_ms);
        }

        ctx.consume_aura(AURA_WHIRLING_AIR.raw());
    }
}

fn roll_stormsurge(ctx: &mut HookCtx<'_>) {
    let chance = stormsurge_chance(ctx);

    apply_stormsurge_roll(ctx, chance, AURA_STORMSURGE.raw(), SPELL_STORMSTRIKE.raw());
}

fn apply_stormsurge_roll(ctx: &mut HookCtx<'_>, chance: f64, aura: u8, strike: u8) {
    let success = proc_chance(ctx.rng(), chance);

    tracing::trace!(chance, success, "STORMSURGE_ROLL");

    if success {
        ctx.apply_aura(aura);
        ctx.reset_cooldown(strike);
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[expect(
    clippy::struct_excessive_bools,
    reason = "each flag preserves one independent SimC landed-melee proc-family capability"
)]
struct LandedMeleeProcFamily {
    windfury: bool,
    flametongue: bool,
    imbuement_mastery: bool,
    maelstrom_weapon: bool,
}

impl LandedMeleeProcFamily {
    const fn player_attack(main_hand: bool) -> Self {
        Self {
            windfury: main_hand,
            flametongue: true,
            imbuement_mastery: false,
            maelstrom_weapon: true,
        }
    }
}

fn spell_landed_melee_proc_family(
    game_data: &ResolvedGameData,
    spell_id: u32,
) -> LandedMeleeProcFamily {
    let spell = SpellIdx::from_raw(spell_id);
    let attributes = game_data.spell_attributes(spell).unwrap_or_default();
    let melee = game_data.defense_type(spell) == Some(DefenseType::Melee as i32);
    let direct_melee = melee && damage_def(game_data, spell).is_some();
    let main_hand_bound = spell_attribute_is(attributes, SpellAttributeKind::RequiresMainHand);
    let weapon_bound =
        main_hand_bound || spell_attribute_is(attributes, SpellAttributeKind::RequiresOffHand);
    let flametongue = direct_melee && weapon_bound;

    LandedMeleeProcFamily {
        // SimC's windfury_attack_t explicitly disables only Windfury self-procs.
        windfury: direct_melee && main_hand_bound && spell_id != SPELL::WINDFURY_ATTACK,
        flametongue,
        // trigger_flametongue_weapon only rolls this rider for Windfury attack 25504.
        imbuement_mastery: flametongue && spell_id == SPELL::WINDFURY_ATTACK,
        maelstrom_weapon: melee
            && !spell_attribute_is(attributes, SpellAttributeKind::SuppressCasterProcs),
    }
}

fn trigger_flametongue(ctx: &mut HookCtx<'_>, imbuement_mastery_eligible: bool) {
    let ft_coef = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::FLAMETONGUE_ATTACK_DAMAGE);

    ctx.deal_damage_ap(SPELL::FLAMETONGUE_ATTACK, ft_coef, DamageFlags::empty());

    let imbuement_mastery = ctx
        .spec_config::<EnhancementConfig>()
        .is_some_and(|config| config.imbuement_mastery);

    let mut failures = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map(|runtime| runtime.imbuement_mastery_failures);
    let imbuement_mastery_proc = imbuement_mastery_eligible
        && imbuement_mastery
        && failures.as_mut().is_some_and(|failures| {
            accumulated_proc_chance(ctx.rng(), IMBUEMENT_MASTERY_CHANCE, failures, 0)
        });

    if let (Some(runtime), Some(failures)) =
        (ctx.spec_runtime_mut::<EnhancementRuntime>(), failures)
    {
        runtime.imbuement_mastery_failures = failures;
    }

    if imbuement_mastery_proc {
        let coef = ctx.game_data().ap_coef(
            SpellIdx::from_raw(SPELL::FLAMETONGUE_ATTACK_IMBUEMENT_MASTERY),
            1,
        );

        ctx.deal_damage_ap(
            SPELL::FLAMETONGUE_ATTACK_IMBUEMENT_MASTERY,
            coef,
            DamageFlags::empty(),
        );
    }
}

fn trigger_maelstrom_weapon(ctx: &mut HookCtx<'_>) {
    let chance = ctx
        .game_data()
        .proc_chance(SpellIdx::from_raw(SPELL::MAELSTROM_WEAPON_DRIVER))
        .unwrap_or(0.0);

    if proc_chance(ctx.rng(), chance) {
        ctx.apply_aura(AURA_MAELSTROM_WEAPON.raw());
    }
}

fn landed_melee_riders(ctx: &mut HookCtx<'_>, family: LandedMeleeProcFamily) {
    if family.flametongue {
        trigger_flametongue(ctx, family.imbuement_mastery);
    }

    if family.maelstrom_weapon {
        trigger_maelstrom_weapon(ctx);
    }
}

fn landed_melee_spell_procs(ctx: &mut HookCtx<'_>, spell_id: u32, outcome: DamageOutcome) {
    if outcome.amount <= 0.0 {
        return;
    }

    let family = spell_landed_melee_proc_family(ctx.game_data(), spell_id);

    landed_melee_procs(ctx, family);
}

fn landed_melee_procs(ctx: &mut HookCtx<'_>, family: LandedMeleeProcFamily) {
    let windfury_procced = if family.windfury {
        let chance = windfury_chance(ctx);
        let success = proc_chance(ctx.rng(), chance);

        tracing::trace!(chance, success, "WINDFURY_ROLL");

        success
    } else {
        false
    };

    if windfury_procced {
        let coef = ctx
            .game_data()
            .effect_ap_coefficient(EFFECT::WINDFURY_ATTACK_DAMAGE);
        let hits = ctx
            .spec_config::<EnhancementConfig>()
            .map_or(WINDFURY_BASE_HITS, |config| config.windfury_hits);
        let child_family = spell_landed_melee_proc_family(ctx.game_data(), SPELL::WINDFURY_ATTACK);

        for _ in 0..hits {
            let outcome =
                ctx.deal_damage_ap_result(SPELL::WINDFURY_ATTACK, coef, DamageFlags::PHYSICAL);

            if outcome.amount > 0.0 {
                landed_melee_riders(ctx, child_family);
            }
        }
    }

    landed_melee_riders(ctx, family);
}

fn melee_hit_procs(ctx: &mut HookCtx<'_>, main_hand: bool) {
    landed_melee_procs(ctx, LandedMeleeProcFamily::player_attack(main_hand));
}

fn trigger_crash_lightning_proc(
    ctx: &mut HookCtx<'_>,
    source_spell_id: u32,
    effect_index: u8,
    multiplier: f64,
) {
    if ctx.deal_triggered_damage(
        source_spell_id,
        effect_index,
        multiplier,
        DamageFlags::empty(),
    ) {
        let family =
            spell_landed_melee_proc_family(ctx.game_data(), REPORTED_SPELL::CRASH_LIGHTNING_PROC);

        landed_melee_procs(ctx, family);
    }
}

pub(crate) fn swing_hook(ctx: &mut HookCtx<'_>, event: SwingEvent) {
    let hand = event.hand;

    let mh = matches!(hand, SwingHand::MainHand);

    melee_hit_procs(ctx, mh);

    let hh_chance = ctx
        .game_data()
        .proc_chance(SpellIdx::from_raw(SPELL::HOT_HAND_DRIVER))
        .unwrap_or(0.0);

    if proc_chance(ctx.rng(), hh_chance) {
        ctx.apply_aura(AURA_HOT_HAND.raw());
    }
}

fn stormstrike_hits(ctx: &mut HookCtx<'_>, mult: f64, stormblast_mult: f64) {
    let mh_coef = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::STORMSTRIKE_MH_DAMAGE);
    let oh_coef = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::STORMSTRIKE_OH_DAMAGE);
    let main_hand =
        ctx.deal_damage_ap_result(SPELL::STORMSTRIKE_MH, mh_coef * mult, DamageFlags::PHYSICAL);

    if stormblast_mult > 0.0 {
        let _ = ctx.deal_damage_from_result(
            SPELL::STORMBLAST,
            main_hand,
            stormblast_mult,
            DamageFlags::empty(),
        );
    }

    roll_stormsurge(ctx);
    melee_hit_procs(ctx, true);
    let off_hand = ctx.deal_damage_ap_result(
        SPELL::STORMSTRIKE_OFFHAND,
        oh_coef * mult * OFF_HAND_DAMAGE_MULT,
        DamageFlags::PHYSICAL,
    );

    if stormblast_mult > 0.0 {
        let _ = ctx.deal_damage_from_result(
            SPELL::STORMBLAST,
            off_hand,
            stormblast_mult,
            DamageFlags::empty(),
        );
    }

    roll_stormsurge(ctx);
    melee_hit_procs(ctx, false);

    // Crash Lightning procs once per Stormstrike variant, including echoes.

    if ctx.is_aura_active(AURA_CRASH_LIGHTNING.raw()) {
        let stacks = f64::from(ctx.aura_stacks(AURA_CRASH_LIGHTNING.raw()));

        trigger_crash_lightning_proc(ctx, AURA::CRASH_LIGHTNING, 1, mult * stacks);
    }

    ride_the_lightning(ctx);
}

pub(crate) fn stormstrike_hook(ctx: &mut HookCtx<'_>) {
    let stormblast_mult = if ctx.is_aura_active(AURA_STORMSURGE.raw()) {
        ctx.spec_config::<EnhancementConfig>()
            .map_or(0.0, |config| config.stormblast_mult)
    } else {
        0.0
    };
    // Consume the prior proc before the child hits roll fresh Stormsurges;
    // new procs must survive for the next Stormstrike.

    ctx.consume_aura(AURA_STORMSURGE.raw());
    stormstrike_hits(ctx, 1.0, stormblast_mult);

    // Doom Winds' direct lightning does not consume Maelstrom Weapon stacks.
    let mw_stacks = ctx
        .aura_stacks(AURA_MAELSTROM_WEAPON.raw())
        .min(MW_CONSUME_CAP);

    if ctx.is_aura_active(AURA_DOOM_WINDS.raw()) && mw_stacks > 0 {
        let coefficient = ctx
            .game_data()
            .effect_sp_coefficient(EFFECT::LIGHTNING_BOLT_DAMAGE);

        ctx.deal_damage_sp(
            SPELL::LIGHTNING_BOLT,
            coefficient * (1.0 + MW_DMG_PER_STACK * f64::from(mw_stacks)),
            DamageFlags::empty(),
        );
        trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
    }

    if proc_chance(ctx.rng(), STORMFLURRY_CHANCE) {
        stormstrike_hits(ctx, STORMFLURRY_MULT, stormblast_mult);
    }

    ctx.apply_aura(AURA_MAELSTROM_WEAPON.raw());
}

fn ride_the_lightning(ctx: &mut HookCtx<'_>) {
    let coef = ctx
        .game_data()
        .effect_sp_coefficient(EFFECT::CHAIN_LIGHTNING_DAMAGE);

    ctx.deal_damage_sp(
        SPELL::CHAIN_LIGHTNING,
        coef * RIDE_THE_LIGHTNING_MULT,
        DamageFlags::empty(),
    );
    // Triggered Chain Lightning variants do not consume Whirling Air.
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
}

fn trigger_splitstream(ctx: &mut HookCtx<'_>) {
    let splitstream_mult = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.splitstream_mult);

    if splitstream_mult <= 0.0 {
        return;
    }

    let splitstream = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::SUNDERING_SPLITSTREAM_DAMAGE);

    ctx.deal_damage_ap(
        SPELL::SUNDERING_SPLITSTREAM,
        splitstream * splitstream_mult,
        DamageFlags::PHYSICAL,
    );
    melee_hit_procs(ctx, true);

    if ctx.is_aura_active(AURA_SURGING_TOTEM.raw()) {
        deal_tremor(ctx, EARTHSURGE_MULT * splitstream_mult);
    }
}

/// Applies Lava Lash hook effects.
pub(crate) fn lava_lash_hook(ctx: &mut HookCtx<'_>) {
    let ashen_catalyst_cdr_ms = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.ashen_catalyst_cdr_ms);

    if ashen_catalyst_cdr_ms > 0 && ctx.is_aura_active(AURA_FLAME_SHOCK.raw()) {
        ctx.reduce_cooldown(SPELL_LAVA_LASH.raw(), ashen_catalyst_cdr_ms);
    }

    if ctx.is_aura_active(AURA_HOT_HAND.raw()) {
        trigger_splitstream(ctx);
    }

    // An already-active Hot Hand fires a second Splitstream before extension.

    if ctx.is_aura_active(AURA_WHIRLING_FIRE.raw()) {
        let hot_hand_active = ctx.is_aura_active(AURA_HOT_HAND.raw());

        if hot_hand_active {
            trigger_splitstream(ctx);
        }

        ctx.consume_aura(AURA_WHIRLING_FIRE.raw());

        if hot_hand_active {
            ctx.extend_aura(AURA_HOT_HAND.raw(), WHIRLING_FIRE_HOT_HAND_MS);
        } else {
            ctx.apply_aura(AURA_HOT_HAND.raw());
        }
    }

    // Lava Lash applies Lashing Flames 334168 e1 but does not benefit from it.

    ctx.apply_aura(AURA_LASHING_FLAMES.raw());

    if ctx.is_aura_active(AURA_CRASH_LIGHTNING.raw()) {
        let stacks = f64::from(ctx.aura_stacks(AURA_CRASH_LIGHTNING.raw()));

        trigger_crash_lightning_proc(
            ctx,
            EFFECT::CRASH_LIGHTNING_DAMAGE.0,
            EFFECT::CRASH_LIGHTNING_DAMAGE.1,
            stacks,
        );
    }

    // A newly spawned Searing Totem participates in the same Lava Lash volley.

    let lively_totems = ctx
        .spec_config::<EnhancementConfig>()
        .is_some_and(|config| config.lively_totems);
    let mut failures = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map(|runtime| runtime.lively_totems_failures);
    let lively_totems_proc = lively_totems
        && failures.as_mut().is_some_and(|failures| {
            accumulated_proc_chance(ctx.rng(), LIVELY_TOTEMS_CHANCE, failures, 0)
        });

    if let (Some(runtime), Some(failures)) =
        (ctx.spec_runtime_mut::<EnhancementRuntime>(), failures)
    {
        runtime.lively_totems_failures = failures;
    }

    if lively_totems_proc {
        summon_searing_totem(ctx);
    }

    trigger_searing_volley(ctx);

    ride_the_lightning(ctx);
    melee_hit_procs(ctx, false);
}

fn crash_lightning_unleashed(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::CRASH_LIGHTNING_UNLEASHED_DAMAGE);

    ctx.deal_damage_ap(
        SPELL::CRASH_LIGHTNING_UNLEASHED,
        coefficient,
        DamageFlags::empty(),
    );
}

pub(crate) fn crash_lightning_hook(ctx: &mut HookCtx<'_>) {
    melee_hit_procs(ctx, true);
    let repeats = ctx
        .spec_config::<EnhancementConfig>()
        .is_some_and(|config| config.storm_unleashed_repeats);

    if repeats {
        ctx.schedule_hook(
            CRASH_LIGHTNING_UNLEASHED_FIRST_MS,
            crash_lightning_unleashed,
        );
        ctx.schedule_hook(
            CRASH_LIGHTNING_UNLEASHED_SECOND_MS,
            crash_lightning_unleashed,
        );
    }
}

fn primordial_storm_damage_mult(ctx: &HookCtx<'_>) -> f64 {
    let stacks = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map_or(0, |runtime| runtime.primordial_storm_mw_stacks);

    1.0 + MW_DMG_PER_STACK * f64::from(stacks)
}

fn consume_maelstrom_weapon(ctx: &mut HookCtx<'_>) -> i32 {
    let stacks = ctx
        .aura_stacks(AURA_MAELSTROM_WEAPON.raw())
        .min(MW_CONSUME_CAP);

    ctx.consume_aura(AURA_MAELSTROM_WEAPON.raw());
    let cdr_per_stack = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.elemental_tempo_cdr_per_stack_ms);
    let stack_count = wowlab_types::numeric::i32_to_u32_nonnegative(stacks);
    let cdr_ms = cdr_per_stack.saturating_mul(stack_count);

    if cdr_ms > 0 {
        ctx.reduce_cooldown(SPELL_STORMSTRIKE.raw(), cdr_ms);
        ctx.reduce_cooldown(SPELL_LAVA_LASH.raw(), cdr_ms);
    }

    let hot_hand_per_stack = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.totemic_momentum_hot_hand_ms);

    if hot_hand_per_stack > 0 && ctx.is_aura_active(AURA_HOT_HAND.raw()) {
        ctx.extend_aura(
            AURA_HOT_HAND.raw(),
            hot_hand_per_stack.saturating_mul(stack_count),
        );
    }

    let storm_unleashed_chance = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.storm_unleashed_chance_per_stack);

    if (0..stacks).any(|_| proc_chance(ctx.rng(), storm_unleashed_chance)) {
        ctx.apply_aura(AURA_STORM_UNLEASHED.raw());
    }

    stacks
}

fn primordial_fire(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::PRIMORDIAL_FIRE_DAMAGE);

    let outcome = ctx.deal_damage_ap_result(
        SPELL::PRIMORDIAL_FIRE,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(ctx, SPELL::PRIMORDIAL_FIRE, outcome);
}

fn primordial_frost(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::PRIMORDIAL_FROST_DAMAGE);

    let outcome = ctx.deal_damage_ap_result(
        SPELL::PRIMORDIAL_FROST,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(ctx, SPELL::PRIMORDIAL_FROST, outcome);
}

fn primordial_lightning(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::PRIMORDIAL_LIGHTNING_DAMAGE);

    let outcome = ctx.deal_damage_ap_result(
        SPELL::PRIMORDIAL_LIGHTNING,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(ctx, SPELL::PRIMORDIAL_LIGHTNING, outcome);
}

fn primordial_lightning_bolt(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx
        .game_data()
        .effect_sp_coefficient(EFFECT::LIGHTNING_BOLT_DAMAGE);

    ctx.deal_damage_sp(
        SPELL::LIGHTNING_BOLT,
        coefficient * primordial_storm_damage_mult(ctx) * PRIMORDIAL_LIGHTNING_BOLT_MULT,
        DamageFlags::empty(),
    );
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
}

pub(crate) fn primordial_storm_hook(ctx: &mut HookCtx<'_>) {
    let stacks = consume_maelstrom_weapon(ctx);

    if let Some(runtime) = ctx.spec_runtime_mut::<EnhancementRuntime>() {
        runtime.primordial_storm_mw_stacks = stacks;
    }

    primordial_fire(ctx);
    ctx.schedule_hook(PRIMORDIAL_FROST_DELAY_MS, primordial_frost);
    ctx.schedule_hook(PRIMORDIAL_LIGHTNING_DELAY_MS, primordial_lightning);
    ctx.schedule_hook(
        PRIMORDIAL_LIGHTNING_BOLT_DELAY_MS,
        primordial_lightning_bolt,
    );
}

pub(crate) fn lightning_bolt_hook(ctx: &mut HookCtx<'_>) {
    let stacks = consume_maelstrom_weapon(ctx);

    let coef = ctx
        .game_data()
        .effect_sp_coefficient(EFFECT::LIGHTNING_BOLT_DAMAGE);
    let mult = 1.0 + MW_DMG_PER_STACK * f64::from(stacks);

    ctx.deal_damage_sp(SPELL::LIGHTNING_BOLT, coef * mult, DamageFlags::empty());
    trigger_direct_lightning_totemic(ctx);
}

pub(crate) fn chain_lightning_hook(ctx: &mut HookCtx<'_>) {
    trigger_direct_lightning_totemic(ctx);
}

pub(crate) fn surging_totem_hook(ctx: &mut HookCtx<'_>) {
    let config = enhancement_config(ctx);
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(SPELL::SURGING_TOTEM, config.surging_totem_duration_ms)
            .npc_id(config.surging_totem_npc_id)
            .on_demise(surging_totem_demise),
    );

    ctx.apply_aura(AURA_AMPLIFICATION_CORE.raw());
    ctx.apply_aura(AURA_WHIRLING_AIR.raw());
    ctx.apply_aura(AURA_WHIRLING_FIRE.raw());
    ctx.apply_aura(AURA_WHIRLING_EARTH.raw());
    deal_tremor(ctx, 1.0);
}

fn surging_totem_demise(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.expire_aura(AURA_AMPLIFICATION_CORE.raw());
    ctx.expire_aura(AURA_SURGING_TOTEM.raw());
    ctx.expire_aura(AURA_TOTEMIC_REBOUND.raw());
    ctx.expire_aura(AURA_WHIRLING_AIR.raw());
    ctx.expire_aura(AURA_WHIRLING_EARTH.raw());
    ctx.expire_aura(AURA_WHIRLING_FIRE.raw());
}

pub(crate) fn surging_totem_pulse_hook(ctx: &mut HookCtx<'_>) {
    deal_tremor(ctx, 1.0);
}

pub(crate) fn sundering_hook(ctx: &mut HookCtx<'_>) {
    melee_hit_procs(ctx, true);
    summon_feral_spirit(ctx, FIRE_WOLF_GUARDIAN_TAG, AURA_MOLTEN_WEAPON.raw());

    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) > 0 {
        deal_tremor(ctx, EARTHSURGE_MULT);
    }

    // 453406 e1 (+100% direct on Sundering) is folded by the generic live-aura path, matching
    // SimC's source_eff_builder_t( buff.whirling_earth ) (sc_shaman.cpp:12812); only the
    // Searing Totem half of the buff is content.

    if ctx.is_aura_active(AURA_WHIRLING_EARTH.raw()) {
        ctx.consume_aura(AURA_WHIRLING_EARTH.raw());
        summon_searing_totem(ctx);
    }
}

pub(crate) fn doom_winds_hook(ctx: &mut HookCtx<'_>) {
    summon_feral_spirit(ctx, LIGHTNING_WOLF_GUARDIAN_TAG, AURA_CRACKLING_SURGE.raw());
}

pub(crate) fn voltaic_blaze_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura_n(
        AURA_MAELSTROM_WEAPON.raw(),
        enhancement_config(ctx).voltaic_blaze_maelstrom_stacks,
    );
    trigger_searing_volley(ctx);
}

pub(crate) fn ascendance_hook(ctx: &mut HookCtx<'_>) {
    ctx.reset_cooldown(SPELL_STORMSTRIKE.raw());
}

/// Returns Enhanced Elements mastery damage from effect 1.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    let enhanced_elements = if [
        DamageSchool::Fire,
        DamageSchool::Frost,
        DamageSchool::Nature,
    ]
    .into_iter()
    .any(|school| ctx.has_school(school))
    {
        ctx.bonus(1)
    } else {
        1.0
    };

    let elemental_weapons_per_imbue = ctx
        .state
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.elemental_weapons_per_imbue);
    let modifier_effect = if ctx.is_periodic {
        EFFECT::ELEMENTAL_WEAPONS_PERIODIC.1
    } else {
        EFFECT::ELEMENTAL_WEAPONS_DIRECT.1
    };
    let affected = ctx.state.config.game_data.effect_affects_spell(
        SpellIdx::from_raw(EFFECT::ELEMENTAL_WEAPONS_DIRECT.0),
        modifier_effect,
        SpellIdx::from_raw(ctx.spell_id),
    ) || ctx.spell_id == SPELL::STORMBLAST;
    let active_imbues = ctx.active_weapon_imbue_count();
    let elemental_weapons = if affected {
        1.0 + elemental_weapons_per_imbue * wowlab_types::numeric::usize_to_f64(active_imbues)
    } else {
        1.0
    };

    enhanced_elements * elemental_weapons
}

#[cfg(test)]
#[path = "hooks/tests.rs"]
mod tests;