wowlab_engine_content/hooks/demonology_warlock/

hooks.rs

use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::GuardianOps as _;
use wowlab_engine_combat::ResourceOps as _;
use wowlab_engine_combat::{
    DamageFlags, GuardianAbility, GuardianActionFn, GuardianEvent, GuardianSpec, HookCtx,
    MasteryCtx,
};
use wowlab_engine_rng::{prd_constant, proc_chance};
use wowlab_types::constants::HUNDRED;

use super::config::{demonology_config, DemonologyConfig, DemonologyRuntime};

use crate::generated::specs::demonology_warlock::{
    AURA, AURA_ABYSSAL_DOMINION, AURA_ABYSSAL_DOMINION_TALENT, AURA_CARNIVOROUS_STALKERS_TALENT,
    AURA_DEMONIC_ART_MOTHER, AURA_DEMONIC_ART_OVERLORD, AURA_DEMONIC_ART_PIT_LORD,
    AURA_DEMONIC_CORE, AURA_DIABOLIC_RITUAL_MOTHER, AURA_DIABOLIC_RITUAL_OVERLORD,
    AURA_DIABOLIC_RITUAL_PIT_LORD, AURA_DIABOLIC_RITUAL_TALENT, AURA_DOMINION_OF_ARGUS,
    AURA_DREADSTALKERS, AURA_POWER_SIPHON, AURA_WILD_IMPS, EFFECT, HERO, REPORTED_SPELL, TALENT,
};
use crate::hooks::shared::warlock::{DiabolicRitual, WarlockSpec};

const DIABOLIC_RITUAL: DiabolicRitual = DiabolicRitual {
    talent: AURA_DIABOLIC_RITUAL_TALENT,
    art: [
        AURA_DEMONIC_ART_OVERLORD,
        AURA_DEMONIC_ART_MOTHER,
        AURA_DEMONIC_ART_PIT_LORD,
    ],
    ritual: [
        AURA_DIABOLIC_RITUAL_OVERLORD,
        AURA_DIABOLIC_RITUAL_MOTHER,
        AURA_DIABOLIC_RITUAL_PIT_LORD,
    ],
};

const MAX_SHARDS_PER_HAND_OF_GULDAN: u32 = 3;
const DOMINION_ROLL_QUARTER: f64 = 0.25;
const DOMINION_ROLL_HALF: f64 = 0.50;
const DOMINION_ROLL_THREE_QUARTERS: f64 = 0.75;
const VILEFIEND_HEADBUTT_PERIOD: u16 = 3;
const DEMONIC_KNOWLEDGE_RANK_1_CHANCE: f64 = 0.08;
const DEMONIC_KNOWLEDGE_RANK_2_CHANCE: f64 = 0.15;
const SPITEFUL_RECONSTITUTION_CHANCE: f64 = 0.10;
const POWER_SIPHON_MAX_IMPS: usize = 2;
pub(super) const DEMONIC_CALLING_BASE_COST: f64 = 2.0;
pub(super) const DEMONIC_CALLING_BASE_CAST_MS: u32 = 2_000;
pub(super) const DEMONIC_CALLING_CAST_REDUCTION_MS: u32 = 1_000;
const CARNIVOROUS_STALKERS_CHANCE: f64 = 0.20;

/// Bolts per imp: 100 energy at 16 cost (334591 e1) yields six before the imp dies.
const FIREBOLTS_PER_IMP: u16 = 6;
const WILD_IMP_LIFETIME_MS: u32 = 40_000;
const WILD_IMP_CAST_MS: u32 = 2_000;
/// Imp Gang Boss buff 1250772 e2: +100% damage.
const IMP_GANG_BOSS_DAMAGE_MULT: f64 = 2.0;
/// To Hell and Back gang boss also carries Unstable Soul 1281512 e1 (+50%).
const UNSTABLE_SOUL_DAMAGE_MULT: f64 = 1.5;
/// To Hell and Back 1281511: e1 = 1 Imp Gang Boss per e2 = 2 sacrificed imps.
const TO_HELL_AND_BACK_IMPS_PER_BOSS: usize = 2;
const INFERNAL_RAPIDITY_EFFECTIVE_CHANCE: f64 = 0.048;
const INFERNAL_RAPIDITY_DAMAGE_MULT: f64 = 2.0;
pub(super) const INNER_DEMONS_PERIOD_MS: u32 = 12_000;
const DOMINION_TRIGGER_CASTS: i32 = 2;
pub(super) const DOMINION_BASE_DURATION_MS: u32 = 15_000;
pub(super) const DOMINION_RANK_2_EXTENSION_MS: u32 = 5_000;
const DOMINION_GUARDIAN_BASE_DURATION_MS: u32 = 10_000;
const DOMINION_GUARDIAN_RANK_3_EXTENSION_MS: u32 = 4_000;
const DOMINION_HAND_OF_GULDAN_PER_RANK: f64 = 0.10;
const GLOOM_OF_NATHREZA_PER_SHARD: f64 = 0.15;
const DOMINION_SHARD_REFUND: f64 = 1.0;
const DOMINION_ACTION_MS: u32 = 2_000;
const VILEFIEND_LIFETIME_MS: u32 = 15_000;
const VILEFIEND_ACTION_MS: u32 = 2_000;
const VILEFIEND_SP_FROM_SP: f64 = 1.95;
const VILEFIEND_AP_FROM_SP: f64 = 0.45;
const VILEFIEND_MELEE_WM: f64 = 2.0;
const VILEFIEND_MELEE_SP: f64 = VILEFIEND_AP_FROM_SP * PET_SWING_AP * VILEFIEND_MELEE_WM;
const BILE_SPIT_TICKS: u8 = 5;
const BLIGHTED_MAW_FRACTION: f64 = 0.50;
const DREADLASH_DAMAGE_MULT: f64 = 1.10;
pub(super) const FELGUARD_CONTROLLER_TICK_MS: u32 = 1_000;
const FELGUARD_AP_FROM_SP: f64 = 1.5201;
const LEGION_STRIKE_PERIOD_TICKS: u16 = 7;
const FELSTORM_PERIOD_TICKS: u16 = 30;
/// Felstorm 89751: six ticks over a five-second channel including tick zero.
const FELSTORM_TICKS: u8 = 6;

/// Dreadstalker pet AP is 0.825 times owner SP.
const DREADSTALKER_AP_FROM_SP: f64 = 0.825;
/// Pet swing coefficient: 2s swing / weapon-power coefficient 6; npc weapon dps (~13) unmodeled.
const PET_SWING_AP: f64 = 2.0 / 6.0;
const DREADSTALKER_MELEE_WM: f64 = 0.96;
/// Flametouched 453699 e1: +10% Dreadstalker attack speed.
const FLAMETOUCHED_ATTACK_SPEED_MULT: f64 = 1.10;
/// Flametouched 453699 e2 (buff 453704 e2): +15% Dreadstalker crit chance.
pub(super) const FLAMETOUCHED_CRIT_PCT: f64 = 15.0;
/// Dreadstalker attacks that Flametouched's crit bonus applies to.
#[rustfmt::skip]
pub(super) const FLAMETOUCHED_CRIT_SPELLS: [u32; 2] = [
    REPORTED_SPELL::DREADSTALKER_MELEE,
    REPORTED_SPELL::DREADBITE,
];
/// 12s summon (193332) with a 2s base swing.
const DREADSTALKER_LIFETIME_MS: u32 = 12_000;
const DREADSTALKER_SWING_MS: u32 = 2_000;
const DREADSTALKERS_PER_CALL: u32 = 2;
const TYRANT_TAG_BASE: u32 = 2_650_000;
pub(super) const TYRANT_LIFETIME_MS: u32 = 15_000;
pub(super) const REIGN_OF_TYRANNY_EXTENSION_MS: u32 = 5_000;
const REIGN_DREADSTALKER_EXTENSION_MS: u32 = 15_000;
const TYRANT_ACTION_MS: u32 = 2_000;
const DEMONIC_POWER_PER_DEMON: f64 = 0.10;

const DIABOLIC_RITUAL_REDUCTION_PER_SHARD_MS: u32 = 1_000;
const RUINATION_FOLLOWUP_DELAY_MS: u32 = 1_000;

fn wild_imp_action(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    let imp_mult = match event.tag {
        TALENT::IMP_GANG_BOSS => IMP_GANG_BOSS_DAMAGE_MULT,
        REPORTED_SPELL::UNSTABLE_GANG_BOSS => IMP_GANG_BOSS_DAMAGE_MULT * UNSTABLE_SOUL_DAMAGE_MULT,
        _ => 1.0,
    } * demonology_config(ctx).mid2_imp_mult;
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::FEL_FIREBOLT_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::FEL_FIREBOLT,
        coefficient * imp_mult,
        DamageFlags::PET,
    );
    let infernal_rapidity = demonology_config(ctx).infernal_rapidity;

    if infernal_rapidity && proc_chance(ctx.rng(), INFERNAL_RAPIDITY_EFFECTIVE_CHANCE) {
        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::FEL_FIREBOLT,
            coefficient * imp_mult * INFERNAL_RAPIDITY_DAMAGE_MULT,
            DamageFlags::PET,
        );
    }

    let cfg = demonology_config(ctx);

    if event.action_index + 1 == FIREBOLTS_PER_IMP && isolated_implosion_proc(ctx, &cfg) {
        let implosion = ctx.effect_sp_coefficient(
            crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::IMPLOSION_DAMAGE,
        );
        let primary = ctx.target();

        ctx.with_resolved_spell_effect_targets(
            crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::IMPLOSION_DAMAGE,
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::ISOLATED_IMPLOSION,
            None,
            |ctx, targets| {
                for target in targets.iter().copied() {
                    let multiplier = if Some(target) == primary {
                        cfg.mid2_isolated_main_mult
                    } else {
                        cfg.mid2_isolated_secondary_mult
                    };

                    ctx.deal_damage_sp_to_target(
                        target,
                        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::ISOLATED_IMPLOSION,
                        implosion * multiplier,
                        DamageFlags::empty(),
                    );
                }
            },
        );
    }
}

fn isolated_implosion_proc(ctx: &mut HookCtx<'_>, cfg: &DemonologyConfig) -> bool {
    if cfg.mid2_isolated_chance <= 0.0 {
        return false;
    }

    let attempts = ctx
        .spec_runtime::<DemonologyRuntime>()
        .map_or(1, |runtime| {
            runtime.isolated_implosion_attempts.saturating_add(1)
        });
    let success = proc_chance(
        ctx.rng(),
        prd_constant(cfg.mid2_isolated_chance) * f64::from(attempts),
    );

    if let Some(runtime) = ctx.spec_runtime_mut::<DemonologyRuntime>() {
        runtime.isolated_implosion_attempts = if success { 0 } else { attempts };
    }

    success
}

fn wild_imp_demise(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.consume_owner_aura_stack(AURA_WILD_IMPS);

    let chance = demonology_config(ctx).demonic_core_imp_chance;

    if chance > 0.0 && proc_chance(ctx.rng(), chance) {
        ctx.apply_owner_aura(AURA_DEMONIC_CORE);
    }
}

fn summon_imp_with_tag(ctx: &mut HookCtx<'_>, tag: u32) {
    ctx.apply_owner_aura(AURA_WILD_IMPS);
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(tag, WILD_IMP_LIFETIME_MS)
            .ability(
                GuardianAbility::new(WILD_IMP_CAST_MS, wild_imp_action)
                    .hasted_actions()
                    .max_actions(FIREBOLTS_PER_IMP)
                    .ends_guardian(),
            )
            .on_demise(wild_imp_demise),
    );
}

fn summon_wild_imp(ctx: &mut HookCtx<'_>, gang_boss: bool) {
    summon_imp_with_tag(
        ctx,
        if gang_boss {
            TALENT::IMP_GANG_BOSS
        } else {
            AURA::WILD_IMPS
        },
    );
}

fn shadow_nova_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::SHADOW_NOVA_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::SHADOW_NOVA,
        coefficient,
        DamageFlags::PET,
    );
}

fn blaze_missile_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::BLAZE_MISSILE_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::BLAZE_MISSILE,
        coefficient,
        DamageFlags::PET,
    );
}

fn mind_sear_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::MIND_SEAR_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::MIND_SEAR_CHANNEL,
        coefficient,
        DamageFlags::PET,
    );
}

fn soul_barrage_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::SOUL_BARRAGE_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::SOUL_BARRAGE_CAST,
        coefficient,
        DamageFlags::PET,
    );
}

fn summon_dominion_guardian(ctx: &mut HookCtx<'_>) {
    let rank_3 = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.dominion_rank_3);
    let duration_ms = DOMINION_GUARDIAN_BASE_DURATION_MS
        + u32::from(rank_3) * DOMINION_GUARDIAN_RANK_3_EXTENSION_MS;
    let roll = ctx.rng()();
    let (tag, action): (u32, GuardianActionFn) = if roll < DOMINION_ROLL_QUARTER {
        (REPORTED_SPELL::ANTORAN_JAILER, soul_barrage_action)
    } else if roll < DOMINION_ROLL_HALF {
        (REPORTED_SPELL::ANTORAN_INQUISITOR, mind_sear_action)
    } else if roll < DOMINION_ROLL_THREE_QUARTERS
        && ctx.active_guardian_count(REPORTED_SPELL::GRAND_WARLOCK_ALYTHESS) == 0
    {
        (REPORTED_SPELL::GRAND_WARLOCK_ALYTHESS, blaze_missile_action)
    } else if roll < DOMINION_ROLL_THREE_QUARTERS {
        (REPORTED_SPELL::ANTORAN_JAILER, soul_barrage_action)
    } else if ctx.active_guardian_count(REPORTED_SPELL::LADY_SACROLASH) == 0 {
        (REPORTED_SPELL::LADY_SACROLASH, shadow_nova_action)
    } else {
        (REPORTED_SPELL::ANTORAN_INQUISITOR, mind_sear_action)
    };
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(tag, duration_ms).ability(
            GuardianAbility::new(DOMINION_ACTION_MS, action)
                .first_action_delay(DOMINION_ACTION_MS)
                .hasted_actions(),
        ),
    );
}

fn trigger_dominion(ctx: &mut HookCtx<'_>) {
    let Some(cfg) = ctx.spec_config::<DemonologyConfig>() else {
        return;
    };

    if !cfg.dominion_rank_1 || !ctx.is_aura_active(AURA_DOMINION_OF_ARGUS) {
        return;
    }

    let refund = cfg.dominion_rank_3;

    ctx.add_aura_stack(AURA_DOMINION_OF_ARGUS);

    if ctx.aura_stacks(AURA_DOMINION_OF_ARGUS) > DOMINION_TRIGGER_CASTS {
        ctx.consume_aura_stack(AURA_DOMINION_OF_ARGUS);
        ctx.consume_aura_stack(AURA_DOMINION_OF_ARGUS);
        summon_dominion_guardian(ctx);
    }

    if refund {
        ctx.gain_resource(DOMINION_SHARD_REFUND);
    }
}

pub(super) fn inner_demons_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    summon_wild_imp(ctx, false);
}

pub(super) fn felguard_controller_action(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    let tick = event.action_index + 1;

    if tick.is_multiple_of(LEGION_STRIKE_PERIOD_TICKS) {
        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::LEGION_STRIKE,
            ctx.effect_ap_coefficient(
                crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::LEGION_STRIKE_DAMAGE,
            ) * FELGUARD_AP_FROM_SP,
            DamageFlags::PHYSICAL | DamageFlags::PET,
        );
    }

    if tick.is_multiple_of(FELSTORM_PERIOD_TICKS) {
        for _ in 0..FELSTORM_TICKS {
            ctx.deal_damage_sp(
                crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::FELSTORM,
                ctx.effect_ap_coefficient(
                    crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::FELSTORM_DAMAGE,
                ) * FELGUARD_AP_FROM_SP,
                DamageFlags::PHYSICAL | DamageFlags::PET,
            );
        }
    }
}

fn ruination_followup(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let (dominion_mult, gloom_mult) =
        ctx.spec_config::<DemonologyConfig>()
            .map_or((1.0, 1.0), |cfg| {
                (
                    1.0 + DOMINION_HAND_OF_GULDAN_PER_RANK * f64::from(cfg.dominion_rank_2),
                    if cfg.gloom_of_nathreza {
                        1.0 + GLOOM_OF_NATHREZA_PER_SHARD * f64::from(MAX_SHARDS_PER_HAND_OF_GULDAN)
                    } else {
                        1.0
                    },
                )
            });

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::HAND_OF_GULDAN_IMPACT,
        ctx.effect_sp_coefficient(crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::HAND_OF_GULDAN_IMPACT_DAMAGE)
            * f64::from(MAX_SHARDS_PER_HAND_OF_GULDAN)
            * dominion_mult
            * gloom_mult,
        DamageFlags::empty(),
    );
    let gang_boss = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.imp_gang_boss);

    for index in 0..MAX_SHARDS_PER_HAND_OF_GULDAN {
        summon_wild_imp(ctx, gang_boss && index == 0);
    }
}

pub(crate) fn ruination_hook(ctx: &mut HookCtx<'_>) {
    if DIABOLIC_RITUAL.consume_art(ctx).is_some() {
        crate::hooks::shared::warlock::explode_oculi(ctx, WarlockSpec::Demonology);
    }

    trigger_dominion(ctx);
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(
            HERO::DIABOLIST::SPELL::RUINATION_IMPACT,
            RUINATION_FOLLOWUP_DELAY_MS + 1,
        )
        .ability(
            GuardianAbility::new(RUINATION_FOLLOWUP_DELAY_MS, ruination_followup)
                .first_action_delay(RUINATION_FOLLOWUP_DELAY_MS)
                .max_actions(1)
                .ends_guardian(),
        ),
    );
}

fn dreadstalker_action(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    let Some((dreadlash_selected, blighted_maw)) = ctx
        .spec_config::<DemonologyConfig>()
        .map(|cfg| (cfg.dreadlash, cfg.blighted_maw))
    else {
        return;
    };
    // Flametouched critical strike chance is already carried by its aura.
    let swing = DREADSTALKER_AP_FROM_SP * PET_SWING_AP * DREADSTALKER_MELEE_WM;

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::DREADSTALKER_MELEE,
        swing,
        DamageFlags::PHYSICAL | DamageFlags::PET,
    );
    let extra_bite = ctx.is_aura_active(AURA_CARNIVOROUS_STALKERS_TALENT)
        && proc_chance(ctx.rng(), CARNIVOROUS_STALKERS_CHANCE);

    if event.action_index == 0 || extra_bite {
        let dreadlash = if dreadlash_selected {
            DREADLASH_DAMAGE_MULT
        } else {
            1.0
        };
        let dreadbite = ctx.effect_ap_coefficient(
            crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::DREADBITE_DAMAGE,
        ) * DREADSTALKER_AP_FROM_SP
            * dreadlash;

        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::DREADBITE,
            dreadbite,
            DamageFlags::PHYSICAL | DamageFlags::PET,
        );

        if blighted_maw {
            ctx.deal_damage_sp(
                crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::BLIGHTED_MAW,
                dreadbite * BLIGHTED_MAW_FRACTION,
                DamageFlags::PET,
            );
        }
    }
}

fn vilefiend_action(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    if event.action_index == 0 {
        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::BILE_SPIT,
            ctx.effect_sp_coefficient(
                crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::BILE_SPIT_DIRECT_DAMAGE,
            ) * VILEFIEND_SP_FROM_SP,
            DamageFlags::PET,
        );

        for _ in 0..BILE_SPIT_TICKS {
            ctx.deal_damage_sp(
                crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::BILE_SPIT,
                ctx.effect_sp_coefficient(crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::BILE_SPIT_TICK_DAMAGE) * VILEFIEND_SP_FROM_SP,
                DamageFlags::PET | DamageFlags::NO_CRIT,
            );
        }

        return;
    }

    let mark_of_shatug = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.mark_of_shatug);

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::VILEFIEND,
        VILEFIEND_MELEE_SP,
        DamageFlags::PHYSICAL | DamageFlags::PET,
    );

    if mark_of_shatug {
        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::GLOOM_SLASH,
            ctx.effect_sp_coefficient(
                crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::GLOOM_SLASH_DAMAGE,
            ) * VILEFIEND_SP_FROM_SP,
            DamageFlags::PET,
        );
    }

    if (event.action_index - 1).is_multiple_of(VILEFIEND_HEADBUTT_PERIOD) {
        ctx.deal_damage_sp(
            crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::HEADBUTT,
            ctx.effect_ap_coefficient(
                crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::HEADBUTT_DAMAGE,
            ) * VILEFIEND_AP_FROM_SP,
            DamageFlags::PHYSICAL | DamageFlags::PET,
        );

        if mark_of_shatug {
            ctx.deal_damage_sp(
                crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::GLOOM_SLASH,
                ctx.effect_sp_coefficient(
                    crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::GLOOM_SLASH_DAMAGE,
                ) * VILEFIEND_SP_FROM_SP,
                DamageFlags::PET,
            );
        }
    }
}

fn summon_vilefiend(ctx: &mut HookCtx<'_>) {
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(REPORTED_SPELL::VILEFIEND, VILEFIEND_LIFETIME_MS)
            .ability(
                GuardianAbility::new(VILEFIEND_ACTION_MS, vilefiend_action)
                    .first_action_delay(VILEFIEND_ACTION_MS)
                    .hasted_actions(),
            ),
    );
}

fn dreadstalker_demise(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.consume_owner_aura_stack(AURA_DREADSTALKERS);
    ctx.apply_owner_aura(AURA_DEMONIC_CORE);
}

fn demonic_tyrant_action(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    // Vilefiend and Felguard Demonic Power stacks never decrement and ride in the tag.
    let static_demons = event.tag.saturating_sub(TYRANT_TAG_BASE);
    let live_demons = ctx.active_guardian_count(AURA::WILD_IMPS)
        + ctx.active_guardian_count(TALENT::IMP_GANG_BOSS)
        + ctx.active_guardian_count(AURA::DREADSTALKERS);
    let demonic_power = 1.0
        + DEMONIC_POWER_PER_DEMON
            * f64::from(
                static_demons + wowlab_types::numeric::usize_to_u32_saturating(live_demons),
            );
    // Abyssal Dominion 429581 e1 is already folded into spell 1264093.
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::BURNING_CLEAVE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::BURNING_CLEAVE.action(),
        coefficient * demonic_power,
        DamageFlags::PET,
    );
}

pub(crate) fn hand_of_guldan_hook(ctx: &mut HookCtx<'_>) {
    let ritual_was_active = DIABOLIC_RITUAL.active(ctx);
    let next_ritual = DIABOLIC_RITUAL.consume_art(ctx);

    if next_ritual.is_some() {
        crate::hooks::shared::warlock::explode_oculi(ctx, WarlockSpec::Demonology);
    }

    DIABOLIC_RITUAL.advance(
        ctx,
        next_ritual,
        MAX_SHARDS_PER_HAND_OF_GULDAN * DIABOLIC_RITUAL_REDUCTION_PER_SHARD_MS,
    );

    if ritual_was_active {
        crate::hooks::shared::warlock::trigger_oculi(ctx, WarlockSpec::Demonology);
    }

    let dominion_mult = ctx.spec_config::<DemonologyConfig>().map_or(1.0, |cfg| {
        1.0 + DOMINION_HAND_OF_GULDAN_PER_RANK * f64::from(cfg.dominion_rank_2)
    });
    let gloom_mult = if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.gloom_of_nathreza)
    {
        1.0 + GLOOM_OF_NATHREZA_PER_SHARD * f64::from(MAX_SHARDS_PER_HAND_OF_GULDAN)
    } else {
        1.0
    };

    ctx.deal_damage_sp(
        crate::generated::specs::demonology_warlock::DAMAGE_REPORTED::HAND_OF_GULDAN_IMPACT,
        ctx.effect_sp_coefficient(crate::generated::specs::demonology_warlock::DAMAGE_EFFECT::HAND_OF_GULDAN_IMPACT_DAMAGE)
            * f64::from(MAX_SHARDS_PER_HAND_OF_GULDAN)
            * dominion_mult
            * gloom_mult,
        DamageFlags::NO_CRIT,
    );

    let gang_boss = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.imp_gang_boss);

    for index in 0..MAX_SHARDS_PER_HAND_OF_GULDAN {
        summon_wild_imp(ctx, gang_boss && index == 0);
    }

    let demonic_knowledge_rank = ctx
        .spec_config::<DemonologyConfig>()
        .map_or(0, |cfg| cfg.demonic_knowledge_rank);
    let demonic_knowledge_chance = match demonic_knowledge_rank {
        0 => 0.0,
        1 => DEMONIC_KNOWLEDGE_RANK_1_CHANCE,
        _ => DEMONIC_KNOWLEDGE_RANK_2_CHANCE,
    };

    if proc_chance(ctx.rng(), demonic_knowledge_chance) {
        ctx.apply_aura(AURA_DEMONIC_CORE);
    }

    trigger_dominion(ctx);
}

pub(crate) fn call_dreadstalkers_hook(ctx: &mut HookCtx<'_>) {
    let next_ritual = DIABOLIC_RITUAL.next_from_art(ctx);

    DIABOLIC_RITUAL.advance(ctx, next_ritual, 0);
    let dreadstalker_lifetime_ms = DREADSTALKER_LIFETIME_MS;
    let swing_ms = if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.flametouched)
    {
        wowlab_types::numeric::f64_to_u32_saturating_trunc(
            f64::from(DREADSTALKER_SWING_MS) / FLAMETOUCHED_ATTACK_SPEED_MULT,
        )
    } else {
        DREADSTALKER_SWING_MS
    };

    for _ in 0..DREADSTALKERS_PER_CALL {
        ctx.apply_aura(AURA_DREADSTALKERS);
        let _ = ctx.summon_guardian(
            GuardianSpec::new_inheriting_owner(AURA::DREADSTALKERS, dreadstalker_lifetime_ms)
                .ability(
                    GuardianAbility::new(swing_ms, dreadstalker_action)
                        .first_action_delay(swing_ms)
                        .hasted_actions(),
                )
                .on_demise(dreadstalker_demise),
        );
    }

    if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.summon_vilefiend)
    {
        summon_vilefiend(ctx);
    }
}

pub(crate) fn demonbolt_hook(ctx: &mut HookCtx<'_>) {
    ctx.consume_aura_stack(AURA_DEMONIC_CORE);
    ctx.consume_aura_stack(AURA_POWER_SIPHON);
    let spiteful_reconstitution = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.spiteful_reconstitution);

    if spiteful_reconstitution && proc_chance(ctx.rng(), SPITEFUL_RECONSTITUTION_CHANCE) {
        summon_wild_imp(ctx, false);
    }
}

pub(crate) fn power_siphon_hook(ctx: &mut HookCtx<'_>) {
    let normal = ctx.dismiss_guardians(AURA::WILD_IMPS, POWER_SIPHON_MAX_IMPS);
    let sacrificed =
        normal + ctx.dismiss_guardians(TALENT::IMP_GANG_BOSS, POWER_SIPHON_MAX_IMPS - normal);

    for _ in 0..sacrificed {
        ctx.consume_aura_stack(AURA_WILD_IMPS);
        ctx.apply_aura(AURA_DEMONIC_CORE);
        ctx.apply_aura(AURA_POWER_SIPHON);
    }

    if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.to_hell_and_back)
    {
        for _ in 0..(sacrificed / TO_HELL_AND_BACK_IMPS_PER_BOSS) {
            summon_imp_with_tag(ctx, REPORTED_SPELL::UNSTABLE_GANG_BOSS);
        }
    }
}

pub(crate) fn summon_demonic_tyrant_hook(ctx: &mut HookCtx<'_>) {
    if ctx.is_aura_active(AURA_ABYSSAL_DOMINION_TALENT) {
        ctx.apply_aura(AURA_ABYSSAL_DOMINION);
    }

    if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.dominion_rank_1)
    {
        ctx.apply_aura(AURA_DOMINION_OF_ARGUS);
    }

    if ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.tyrants_oblation)
    {
        ctx.apply_aura(crate::generated::specs::demonology_warlock::AURA_TYRANTS_OBLATION);
    }

    let reign_of_tyranny = ctx
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.reign_of_tyranny);

    if reign_of_tyranny {
        ctx.extend_guardians(AURA::DREADSTALKERS, REIGN_DREADSTALKER_EXTENSION_MS);
        ctx.extend_aura(AURA_DREADSTALKERS, REIGN_DREADSTALKER_EXTENSION_MS);
    }
    // Only never-decremented Vilefiend and Felguard stacks ride in the tag.

    let static_demons = ctx.active_guardian_count(REPORTED_SPELL::VILEFIEND) + 1;
    let tyrant_duration_ms =
        TYRANT_LIFETIME_MS + u32::from(reign_of_tyranny) * REIGN_OF_TYRANNY_EXTENSION_MS;
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(
            TYRANT_TAG_BASE + wowlab_types::numeric::usize_to_u32_saturating(static_demons),
            tyrant_duration_ms,
        )
        .ability(
            GuardianAbility::new(TYRANT_ACTION_MS, demonic_tyrant_action)
                .first_action_delay(TYRANT_ACTION_MS)
                .hasted_actions(),
        ),
    );
}

// Demonic Brutality 453908 e1/e2 yields 260% pet crits; Vilefiend's shared report ID causes a known melee-row overshoot.
const DEMONIC_BRUTALITY_PET_CRIT_BONUS_PTS: f64 = 60.0;

#[must_use]
pub(crate) fn crit_damage(ctx: &MasteryCtx<'_>) -> f64 {
    let brutality = ctx
        .program
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.demonic_brutality);

    if !brutality || !ctx.is_pet {
        return 0.0;
    }

    match ctx.spell_id {
        1
        | REPORTED_SPELL::FEL_FIREBOLT
        | REPORTED_SPELL::DREADSTALKER_MELEE
        | REPORTED_SPELL::DREADBITE
        | REPORTED_SPELL::LEGION_STRIKE
        | REPORTED_SPELL::FELSTORM => DEMONIC_BRUTALITY_PET_CRIT_BONUS_PTS,
        id if id == EFFECT::BURNING_CLEAVE.0 => DEMONIC_BRUTALITY_PET_CRIT_BONUS_PTS,
        _ => 0.0,
    }
}

/// Returns Master Demonologist pet damage.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    let mastery = ctx.pet_bonus(1);
    let hellbent = ctx
        .program
        .spec_config::<DemonologyConfig>()
        .is_some_and(|cfg| cfg.hellbent_commander);

    if ctx.is_pet && hellbent {
        mastery
            * (1.0 + wowlab_types::numeric::usize_to_f64(ctx.active_guardian_count() + 1) / HUNDRED)
    } else {
        mastery
    }
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_engine_combat::GuardianHandle;
    use wowlab_engine_ports::CombatStats;
    use wowlab_engine_telemetry::TelemetrySink;

    use wowlab_types::sim::SimTime;

    use super::*;

    const UNUSUAL_IMP_CHANCE: f64 = 0.37;

    fn imp_demise_outcome(chance: f64, roll: f64) -> Result<(usize, bool)> {
        let mut builder = crate::test_combat_builder_for(
            wowlab_engine_combat::generated_identities::specs::demonology_warlock::PROOF,
            CombatStats::default(),
        );

        for local in 0..=AURA_WILD_IMPS.as_usize() {
            let aura_id = match local {
                value if value == AURA_DEMONIC_CORE.as_usize() => AURA::DEMONIC_CORE,
                value if value == AURA_WILD_IMPS.as_usize() => AURA::WILD_IMPS,
                _ => 900_000 + u32::try_from(local).expect("fixture local fits u32"),
            };

            builder = builder.aura(&format!("demonology_test_aura_{local}"), aura_id, |aura| {
                Ok(aura.on_player().max_stacks(20))
            });
        }

        let mut draft = builder.into_draft().or_fail()?;

        draft.set_spec_config(DemonologyConfig {
            demonic_core_imp_chance: chance,
            ..DemonologyConfig::default()
        });
        let mut built = draft
            .finalize(&crate::test_support::wait_rotation())
            .or_fail()?;
        let mut telemetry = TelemetrySink::default();
        let mut draws = 0;
        let mut rng = || {
            draws += 1;

            roll
        };
        let core_active;

        {
            let mut ctx = HookCtx::new(
                wowlab_engine_combat::HookCtxServices {
                    program: &built.program,
                    instance: &mut built.instance,
                    sink: &mut telemetry,
                    rng: &mut rng,
                },
                wowlab_engine_combat::HookCtxRequest::targetless(SimTime::ZERO),
            );

            ctx.apply_aura(AURA_WILD_IMPS);
            wild_imp_demise(
                &mut ctx,
                GuardianEvent {
                    handle: GuardianHandle::new(0, 1),
                    tag: AURA::WILD_IMPS,
                    ability_index: 0,
                    action_index: 0,
                    spawned_at: SimTime::ZERO,
                    expires_at: SimTime::ZERO,
                },
            );
            core_active = ctx.is_aura_active(AURA_DEMONIC_CORE);
        };

        Ok((draws, core_active))
    }

    #[gtest]
    fn imp_demise_skips_zero_chance_rng_and_uses_configured_threshold() -> Result<()> {
        verify_that!(imp_demise_outcome(0.0, 0.0)?, eq((0, false)))?;
        verify_that!(imp_demise_outcome(UNUSUAL_IMP_CHANCE, 0.36)?, eq((1, true)))?;

        verify_that!(
            imp_demise_outcome(UNUSUAL_IMP_CHANCE, 0.38)?,
            eq((1, false))
        )
    }
}