import type { AbilityDefinition, AbilityEffect } from "./abilityCatalog";
import type { AuraDefinition, AuraModifier, AuraProcDefinition } from "./combatAuras";
import type { RomGeneratedAbilityLike } from "./romAbilitySemantics";
import {
  ROM_ROGUE_COERCE_TAG,
  ROM_ROGUE_DAGGER_MASTERY_TAG,
  ROM_ROGUE_OFF_HAND_MASTERY_TAG,
  ROM_ROGUE_TREASURE_HUNTER_TAG,
  romRogueCoerceLowBlowDamageMultiplier,
} from "./romRogueMechanics";
import { ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG as ROM_CHAOS_DAGGER_TAG } from "./romRogueChaosDagger";
import {
  ROM_ROGUE_CHAMPION_NERVE_GEAR_MARKER_TAG,
  ROM_ROGUE_CHAMPION_NERVE_GEAR_PASSIVE_SPELL_ID,
} from "./romRogueChampionNerveGearRuntime";

export const ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG = ROM_CHAOS_DAGGER_TAG;
/** @deprecated Use ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG for current CoA behavior. */
export const ROM_ROGUE_MAGE_ENCHANTED_THROW_TAG = ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG;
export const ROM_ROGUE_PRIEST_SINISTER_METHODS_TAG = "rom-rogue-priest-sinister-methods";
export const ROM_ROGUE_PRIEST_SINISTER_METHODS_COOLDOWN_KEY = "rom-rogue-priest-sinister-methods";
export const ROM_SCOUT_PRIEST_SNIPER_TAG = "rom-scout-priest-sniper";
export const ROM_SCOUT_MAGE_WIND_RETURN_TAG = "rom-scout-mage-wind-return";
export const ROM_SCOUT_PRIEST_REVIVAL_ENGRAVING_TAG = "rom-scout-priest-revival-engraving";
export const ROM_SCOUT_WARDEN_FOREST_GUIDANCE_TAG = "rom-scout-warden-forest-guidance";
const ROM_SCOUT_KNIGHT_ENHANCED_ARMOR_PERFECTION_TAG = "rom-scout-knight-enhanced-armor-perfection";
// Local RuneWaker component 501823 sets Enhanced Armor's duration to 600s.
const ROM_SCOUT_KNIGHT_ENHANCED_ARMOR_DURATION_MS = 600_000;
/** RuneWaker itemobject/shop rows supply Poison Powder to the Scout/Rogue loadout. */
export const ROM_SCOUT_ROGUE_POISON_POWDER_SUPPLY = Object.freeze({
  itemId: 200563,
  name: "Poison Powder",
  quantity: "unlimited",
} as const);

function firstDamage(effects: readonly AbilityEffect[]): AbilityEffect[] {
  return effects.filter((effect) => effect.kind === "damage").slice(0, 1);
}

function scaleDamageEffects(effects: readonly AbilityEffect[], factor: number): readonly AbilityEffect[] {
  return effects.map((effect) => effect.kind === "damage" || effect.kind === "dot" ? {
    ...effect,
    coefficient: effect.coefficient * factor,
    ...(effect.coefficientPerLevel === undefined ? {} : { coefficientPerLevel: effect.coefficientPerLevel * factor }),
    ...(effect.basePoints === undefined ? {} : { basePoints: effect.basePoints * factor }),
    ...(effect.pointsPerLevel === undefined ? {} : { pointsPerLevel: effect.pointsPerLevel * factor }),
    ...(effect.bonusPowerCoefficient === undefined ? {} : { bonusPowerCoefficient: effect.bonusPowerCoefficient * factor }),
    ...(effect.kind !== "damage" || effect.bonusFlat === undefined ? {} : { bonusFlat: effect.bonusFlat * factor }),
  } : effect);
}

function taggedPassive(
  sourceId: number,
  name: string,
  tag: string,
  proc?: AuraProcDefinition,
): AbilityEffect[] {
  return [{
    kind: "apply-aura",
    recipient: "caster",
    aura: {
      id: `rom-pair-passive-${sourceId}`,
      name,
      disposition: "buff",
      durationMs: null,
      utilityTags: [tag],
      ...(proc ? { procs: [proc] } : {}),
    },
    sourceEffectType: -1,
    sourceAuraType: -1,
    miscValue: 0,
    triggerSpellId: sourceId,
  }];
}

function taggedRoguePassive(sourceId: number, name: string, tag: string): AbilityEffect[] {
  return [{
    kind: "apply-aura",
    recipient: "caster",
    aura: {
      id: `rom-aura:${sourceId}:rogue-passive`,
      name,
      disposition: "buff",
      durationMs: null,
      utilityTags: [tag],
    },
    sourceEffectType: -1,
    sourceAuraType: -1,
    miscValue: 0,
    triggerSpellId: sourceId,
  }];
}

function customProc(
  sourceId: number,
  trigger: "hit" | "crit",
  actionId: string,
  options: {
    readonly chance?: number;
    readonly internalCooldownMs?: number;
    readonly data?: Readonly<Record<string, string | number | boolean>>;
  } = {},
): AuraProcDefinition {
  return {
    id: `rom-pair-proc-${sourceId}`,
    triggers: trigger === "hit" ? ["hit", "crit"] : trigger,
    chance: options.chance ?? 1,
    ...(options.internalCooldownMs ? { internalCooldownMs: options.internalCooldownMs } : {}),
    action: { kind: "custom", id: actionId, ...(options.data ? { data: options.data } : {}) },
  };
}

function timedCasterAura(
  sourceId: number,
  name: string,
  durationMs: number,
  modifiers: readonly AuraModifier[],
): AbilityEffect {
  return {
    kind: "apply-aura",
    recipient: "caster",
    aura: {
      id: `rom-pair-buff-${sourceId}`,
      name,
      disposition: "buff",
      durationMs,
      modifiers,
    },
    sourceEffectType: -1,
    sourceAuraType: -1,
    miscValue: 0,
    triggerSpellId: sourceId,
  };
}

/**
 * Source-specific translations for the accepted Scout paired-class
 * mechanics. Passive tags and custom proc IDs are consumed by combat-store
 * transitions; they intentionally do not apply unrelated generic stat buffs.
 */
export function overrideRomScoutRogueEffects(
  row: RomGeneratedAbilityLike,
  translated: readonly AbilityEffect[],
): readonly AbilityEffect[] | null {
  switch (row.sourceSkillId) {
    case 497206: { // Dodge arms the usable spell; its child applies the three-second concealment.
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-mage") return null;
      const concealment = row.source?.components?.find((component) => component.id === 502597);
      const durationMs = Math.max(1_000, Math.round((concealment?.effectTime ?? 3) * 1_000));
      return [{
        kind: "apply-aura",
        recipient: "caster",
        aura: {
          id: "rom-rogue:instant-shadow",
          name: "Instant Shadow",
          disposition: "buff",
          durationMs,
          maxStacks: 1,
          stackBehavior: "refresh",
          utilityTags: ["stealth"],
        },
        sourceEffectType: row.source?.sourceEffectType ?? -1,
        sourceAuraType: -1,
        miscValue: 0,
        triggerSpellId: 502597,
      }];
    }
    case 490504:
      return taggedRoguePassive(490504, "Dagger Mastery", ROM_ROGUE_DAGGER_MASTERY_TAG);
    case 493019:
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-scout") return null;
      // Current CoA Coerce directly increases Low Blow damage and reduces its
      // Energy cost. Its older RuneWaker below-30% temporary buff is obsolete.
      return taggedRoguePassive(493019, "Coerce", ROM_ROGUE_COERCE_TAG);
    case 490316:
      return taggedRoguePassive(490316, "Treasure Hunter", ROM_ROGUE_TREASURE_HUNTER_TAG);
    case 490143:
      // Keep the source modifiers scoped to actual off-hand attacks. A generic
      // melee aura would incorrectly buff the main hand as well.
      return taggedRoguePassive(490143, "Off Hand Mastery", ROM_ROGUE_OFF_HAND_MASTERY_TAG);
    case 493020: { // Successful Low Blow/Blind Spot hits trigger the local 10s crit buff.
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-priest") return null;
      const buff = row.source?.components?.find((component) => component.id === 503265);
      const criticalModifier = buff?.abilityModifiers?.find((modifier) => modifier.type === 18);
      const cooldown = row.source?.components?.find((component) => component.id === 503300);
      const durationMs = Math.max(0, Math.round((buff?.effectTime ?? 0) * 1_000));
      const cooldownMs = Math.max(0, Math.round((cooldown?.effectTime ?? 0) * 1_000));
      const proc = criticalModifier && durationMs > 0 && cooldownMs > 0
        ? customProc(493020, "hit", "rom-sinister-methods", {
          data: { criticalStrike: criticalModifier.value, durationMs, cooldownMs },
        })
        : undefined;
      return taggedPassive(493020, "Sinister Methods", ROM_ROGUE_PRIEST_SINISTER_METHODS_TAG, proc);
    }
    case ROM_ROGUE_CHAMPION_NERVE_GEAR_PASSIVE_SPELL_ID:
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-champion") return null;
      // The timed child only triggers after an elite skill use. Keep a learned
      // marker, not its generic aura, so party passive loading cannot grant the
      // attack-speed/dodge payload on an unrelated cast.
      return taggedPassive(
        ROM_ROGUE_CHAMPION_NERVE_GEAR_PASSIVE_SPELL_ID,
        "Nerve Gear",
        ROM_ROGUE_CHAMPION_NERVE_GEAR_MARKER_TAG,
      );
    case 491178:
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-mage") return null;
      // Current CoA reuses this exact Rogue/Mage ID as passive Chaos Dagger.
      // Keep a marker for learned-passive consumers such as Day of Rain; do
      // not register the incompatible RuneWaker Throw child or local aura.
      return taggedRoguePassive(491178, "Chaos Dagger", ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG);
    case 491552:
      if (row.classId !== "rom-rogue") return null;
      return translated.map((effect) => effect.kind === "apply-aura" ? {
        ...effect,
        aura: { ...effect.aura, utilityTags: [...(effect.aura.utilityTags ?? []), "rom-491552"] },
      } : effect);
    case 490445: // Bow/crossbow accuracy must not grant melee hit; keep its range scope explicit.
      return translated.filter((effect) => effect.kind !== "apply-aura" || effect.sourceAuraType !== 54)
        .map((effect) => effect.kind === "apply-aura" ? {
          ...effect,
          aura: {
            ...effect.aura,
            modifiers: effect.aura.modifiers?.map((modifier) => modifier.kind === "stat"
              && modifier.stat === "physical-hit"
              ? { ...modifier, stat: "ranged-hit" }
              : modifier),
          },
        } : effect);
    case 490505: // Bow and crossbow each carry an equivalent +11% attack-speed modifier in the source.
      return translated.filter((effect) => effect.kind !== "apply-aura" || effect.sourceAuraType !== 70);
    case 490400: // Piercing Arrow: one projectile, then a line hit behind its target.
      return firstDamage(translated);
    case 490424: { // Combo Shot: three impacts of the same source shot.
      const hit = firstDamage(translated)[0];
      return hit ? [hit, hit, hit] : translated;
    }
    case 490457: { // Reflected Shot: two jumps, each retaining half the prior hit.
      const hit = firstDamage(translated)[0];
      return hit?.kind === "damage" ? [{ ...hit, falloffPerJump: 0.5 }] : translated;
    }
    case 498803: // Soul Stab's first hit is unconditional; its second hit requires Weakened.
      return translated.filter((effect) => effect.kind === "damage");
    case 490354: // Vanish is an aggro/stealth transition, not a self-heal.
      return translated.filter((effect) => effect.kind !== "heal").map((effect) => effect.kind === "apply-aura"
        ? { ...effect, aura: { ...effect.aura, utilityTags: ["stealth", "rom-vanish"] } }
        : effect);
    case 491493: { // Weak Spot's buff is component 501895, not its permanent hit modifier.
      const source = row.source?.components?.find((component) => component.id === 501895);
      const critical = source?.abilityModifiers?.find((modifier) => modifier.type === 18)?.value ?? 20;
      const durationMs = Math.max(1_000, Math.round((source?.effectTime ?? 15) * 1_000));
      return [
        ...firstDamage(translated),
        timedCasterAura(491493, "Weak Spot critical strike", durationMs, [
          { kind: "stat", stat: "physical-critical-strike", operation: "flat", value: critical },
        ]),
      ];
    }
    case 492342:
      return taggedPassive(492342, "Lasso Master", "rom-lasso-master");
    case 492916:
      return taggedPassive(492916, "Exploiting Shot", "rom-exploiting-shot",
        customProc(492916, "crit", "rom-exploiting-shot", { internalCooldownMs: 20_000 }));
    case 493006:
      return taggedPassive(493006, "Accurate Targeting", "rom-accurate-targeting",
        customProc(493006, "hit", "rom-accurate-targeting", { internalCooldownMs: 30_000 }));
    case 491489:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-warrior") return null;
      return taggedPassive(491489, "Enhanced Throat Attack", "rom-enhanced-throat-attack",
        customProc(491489, "hit", "rom-enhanced-throat-attack"));
    case 491532:
      if (row.classId !== "rom-rogue" || row.secondaryClassId !== "rom-scout") return null;
      return taggedPassive(491532, "Slit Throat", "rom-slit-throat",
        customProc(491532, "hit", "rom-slit-throat"));
    case 492344:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-priest") return null;
      return taggedPassive(492344, "Sniper", ROM_SCOUT_PRIEST_SNIPER_TAG);
    case 492346:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-knight") return null;
      return taggedPassive(492346, "Enhanced Armor Perfection", ROM_SCOUT_KNIGHT_ENHANCED_ARMOR_PERFECTION_TAG);
    case 493007:
      return taggedPassive(493007, "Deadly Counterattack", "rom-deadly-counterattack",
        customProc(493007, "hit", "rom-deadly-counterattack", { internalCooldownMs: 20_000 }));
    case 493253:
      return taggedPassive(493253, "Poisonous Spit", "rom-poisonous-spit",
        customProc(493253, "hit", "rom-poisonous-spit", { internalCooldownMs: 20_000 }));
    case 499548:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-mage") return null;
      // Component 623070/623083 describes the six-second buff and HoT earned
      // after skill 499549 expires. That referenced skill has no local player
      // row, so do not grant its child payload when the passive is learned.
      return taggedPassive(499548, "Wind Return", ROM_SCOUT_MAGE_WIND_RETURN_TAG);
    case 499552:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-priest") return null;
      // Component 623087 is a pet-stat aura triggered after skill 490443 hits.
      // The trigger has no local player row and pet stats are not modeled, so
      // keep only the learned marker instead of applying it to the Scout.
      return taggedPassive(499552, "Revival Engraving", ROM_SCOUT_PRIEST_REVIVAL_ENGRAVING_TAG);
    case 499575:
      if (row.classId !== "rom-scout" || row.secondaryClassId !== "rom-warden") return null;
      // Component 623117 belongs on the target hit by skill 499576. That
      // player-facing skill has no local generated row, so keep only the
      // learned marker instead of applying its timed vulnerability to the
      // passive owner at combat initialization.
      return taggedPassive(499575, "Forest Guidance", ROM_SCOUT_WARDEN_FOREST_GUIDANCE_TAG);
    case 499534:
      return taggedPassive(499534, "Master Reflected Shot", "rom-master-reflected-shot");
    case 499536:
      return taggedPassive(499536, "Meridian Attack", "rom-meridian-attack");
    case 491526:
      return taggedPassive(491526, "Throwing Mastery", "rom-throwing-mastery");
    case 491527: // The bonus applies to one-hand axes only, never all melee damage.
      return taggedPassive(491527, "One-Hand Axe Mastery", "rom-one-hand-axe-mastery");
    case 492349:
      return taggedPassive(492349, "Whirlwind Mastery", "rom-whirlwind-mastery");
    case 491339: // A negative RuneWaker value means reduced received healing.
      return translated.map((effect) => effect.kind === "apply-aura"
        ? {
          ...effect,
          aura: {
            ...effect.aura,
            modifiers: effect.aura.modifiers?.map((modifier) => modifier.kind === "healing"
              && modifier.direction === "taken"
              ? { ...modifier, value: -Math.abs(modifier.value) }
              : modifier),
          },
        }
        : effect);
    case 492625: // Source attack component 620287 must not make its victim immune to physical damage.
      return translated.filter((effect) => effect.kind === "damage" || effect.kind === "dot");
    case 492920: { // Poison Spray spreads Infection's ten-second poison to nearby enemies.
      const hit = firstDamage(translated)[0];
      const poison: AbilityEffect = {
        kind: "dot",
        coefficient: 0,
        basePoints: 12,
        pointsPerLevel: 4.2,
        sourceLevel: 1,
        ticks: 5,
        intervalMs: 2_000,
        tag: "rom-poisonous-infection",
      };
      return hit ? [hit, poison] : [poison];
    }
    case 493017: // Decay's empty indefinite state is not its timed critical buff.
      return translated.filter((effect) => effect.kind !== "apply-aura"
        || effect.aura.modifiers?.length || effect.aura.procs?.length || effect.aura.utilityTags?.length);
    case 493257:
      return taggedPassive(493257, "Reclaim Energy", "rom-reclaim-energy",
        customProc(493257, "hit", "rom-reclaim-energy", { chance: 0.25 }));
    case 499476:
      return taggedPassive(499476, "Toxic Splash", "rom-toxic-splash",
        // 493296 replaces Infection and can generate 20 rage on a successful hit.
        customProc(499476, "hit", "rom-infection-rage", { chance: 0.25 }));
    case 499480:
      return taggedPassive(499480, "Poison Battle Technique", "rom-poison-battle-technique");
    default:
      return null;
  }
}

/** Select source-conditional pair effects after the target's existing states are known. */
export function romScoutRogueCastEffects(
  ability: AbilityDefinition,
  effects: readonly AbilityEffect[],
  passiveTags: readonly string[],
  targetTags: readonly string[],
): readonly AbilityEffect[] {
  const passives = new Set(passiveTags);
  const target = new Set(targetTags);
  const coerceDamageMultiplier = romRogueCoerceLowBlowDamageMultiplier({
    classId: ability.classId,
    abilitySource: ability.source,
    abilitySpellId: ability.dbcSpellId,
    passiveTags,
  });
  if (coerceDamageMultiplier !== 1) return scaleDamageEffects(effects, coerceDamageMultiplier);
  if (ability.dbcSpellId === 490152 && passives.has(ROM_SCOUT_KNIGHT_ENHANCED_ARMOR_PERFECTION_TAG)) {
    // Component 501823 is the source's rank payload: Enhanced Armor lasts 600s.
    return effects.map((effect) => effect.kind === "apply-aura"
      ? { ...effect, aura: { ...effect.aura, durationMs: ROM_SCOUT_KNIGHT_ENHANCED_ARMOR_DURATION_MS } }
      : effect);
  }
  if (ability.dbcSpellId === 490457) {
    // Replacement 499535 / component 623051 raises ranged DPS from 0.75 to 0.85.
    const masteryFactor = passives.has("rom-master-reflected-shot") ? 0.85 / 0.75 : 1;
    return effects.map((effect) => effect.kind === "damage" ? {
      ...effect,
      coefficient: effect.coefficient * masteryFactor,
      ...(effect.coefficientPerLevel === undefined ? {} : { coefficientPerLevel: effect.coefficientPerLevel * masteryFactor }),
      ...(effect.basePoints === undefined ? {} : { basePoints: effect.basePoints * masteryFactor }),
      ...(effect.pointsPerLevel === undefined ? {} : { pointsPerLevel: effect.pointsPerLevel * masteryFactor }),
      ...(effect.bonusPowerCoefficient === undefined ? {} : { bonusPowerCoefficient: effect.bonusPowerCoefficient * masteryFactor }),
      ...(effect.bonusFlat === undefined ? {} : { bonusFlat: effect.bonusFlat * masteryFactor }),
      falloffPerJump: passives.has("rom-poisonous-spit") ? 1 : effect.falloffPerJump,
    } : effect);
  }
  if (ability.dbcSpellId === 498803) {
    let seenDamage = 0;
    const weakened = target.has("rom-weakened");
    return effects.filter((effect) => {
      if (effect.kind !== "damage") return true;
      seenDamage += 1;
      return seenDamage === 1 || weakened;
    });
  }
  if (ability.dbcSpellId === 490451 && passives.has("rom-meridian-attack")) {
    // 499537/623061 replaces Wrist Attack: -30 physical and magical damage for 10s.
    return effects.map((effect) => effect.kind === "apply-aura" && effect.recipient !== "caster"
      ? {
        ...effect,
        aura: {
          ...effect.aura,
          durationMs: 10_000,
          modifiers: [
            { kind: "damage" as const, direction: "dealt" as const, school: "physical" as const, operation: "percent" as const, value: -0.30 },
            { kind: "damage" as const, direction: "dealt" as const, attackKind: "spell" as const, operation: "percent" as const, value: -0.30 },
          ],
        },
      } : effect);
  }
  if (ability.dbcSpellId === 492920 && passives.has("rom-toxic-splash")) {
    // 499477 replaces Poison Spray. 493296 is its additional infection hit;
    // 622992 is the six-second poison it spreads to nearby targets.
    return [
      ...effects.filter((effect) => effect.kind !== "dot"),
      // 620287: 0.85 main-hand DPS + 0.20 Dexterity, then +7.5% skill-level DPS.
      { kind: "damage", coefficient: 1.11375, coefficientPerLevel: 0.06375, sourceLevel: 1 },
      { kind: "dot", coefficient: 0, basePoints: 16.2, pointsPerLevel: 4.2,
        sourceLevel: 1, ticks: 3, intervalMs: 2_000, tag: "rom-622992" },
    ];
  }
  if (ability.dbcSpellId === 490133 && passives.has("rom-poison-battle-technique")) {
    // 499481/620286 raises Whirlwind's main-hand DPS coefficient 0.70 -> 0.75.
    return effects.map((effect) => effect.kind === "damage" ? {
      ...effect,
      coefficient: effect.coefficient * 0.75 / 0.70,
      ...(effect.coefficientPerLevel === undefined ? {} : { coefficientPerLevel: effect.coefficientPerLevel * 0.75 / 0.70 }),
    } : effect);
  }
  if (ability.dbcSpellId === 490454 && passives.has("rom-lasso-master")) {
    return [...effects, {
      kind: "status",
      status: "disarm",
      durationMs: 10_000,
      maxTargets: 1,
      breakOnDamage: true,
    }];
  }
  if (ability.dbcSpellId === 490309) {
    return [
      ...effects,
      ...(passives.has("rom-throwing-mastery")
        ? [{ kind: "status" as const, status: "slow" as const, durationMs: 5_000, magnitude: 0.4 }]
        : []),
      { kind: "cooldown-reset", mode: "reduce", abilityName: "Day of Rain", amountMs: 1_000 },
    ];
  }
  if (ability.dbcSpellId === 492621) {
    const hasSourcePoison = target.has("rom-deadly-poison") || target.has("rom-501690");
    let seenHits = 0;
    return effects.filter((effect) => {
      if (effect.kind !== "damage") return true;
      seenHits += 1;
      return seenHits === 1 || (seenHits === 2 && hasSourcePoison);
    });
  }
  return effects;
}

/** Day of Rain has an exact 50% miss chance while the Rogue/Mage Chaos Dagger passive is learned. */
export function romRogueMageDayOfRainBaseMissPercent(
  classId: string,
  secondaryClassId: string | null | undefined,
  abilitySpellId: number | undefined,
  activeAuraTags: readonly string[],
  attackerHitPercent: number,
): number | null {
  if (classId !== "rom-rogue"
    || secondaryClassId !== "rom-mage"
    || abilitySpellId !== 491183
    || !activeAuraTags.includes(ROM_ROGUE_MAGE_CHAOS_DAGGER_TAG)) return null;
  const hitPercent = Number.isFinite(attackerHitPercent)
    ? Math.max(0, Math.min(100, attackerHitPercent))
    : 0;
  // combatAttackTable subtracts attacker hit rating from base miss chance.
  // Offset it here so the tooltip's 50% rate remains exact at any hit rating.
  return 50 + hitPercent;
}

/** 499481/622993 adds a hit only to targets already carrying 622992's poison. */
export function romScoutRogueWhirlwindBonusEffect(
  ability: AbilityDefinition,
  passiveTags: readonly string[],
  targetTags: readonly string[],
): Extract<AbilityEffect, { kind: "damage" }> | null {
  if (ability.dbcSpellId !== 490133 || !passiveTags.includes("rom-poison-battle-technique")
    || !targetTags.includes("rom-622992")) return null;
  return { kind: "damage", coefficient: 0.50, coefficientPerLevel: 0.03, sourceLevel: 1 };
}

export type RomScoutRogueProcActionSpec =
  | {
      readonly kind: "aura";
      readonly recipient: "caster" | "target";
      readonly aura: AuraDefinition;
      readonly provenance: "source" | "hybrid-estimate";
      readonly cooldownMs?: number;
    }
  | {
      readonly kind: "dot";
      readonly recipient: "target";
      readonly effect: Extract<AbilityEffect, { kind: "dot" }>;
      readonly provenance: "source" | "hybrid-estimate";
    }
  | {
      readonly kind: "resource";
      readonly recipient: "caster";
      readonly resource: "energy" | "rage";
      readonly amount: number;
      readonly provenance: "source" | "hybrid-estimate";
    }
  | {
      readonly kind: "damage";
      readonly recipient: "target";
      readonly effect: Extract<AbilityEffect, { kind: "damage" }>;
      readonly provenance: "source" | "hybrid-estimate";
    }
  | {
      readonly kind: "status";
      readonly recipient: "target";
      readonly status: "silence";
      readonly durationMs: number;
      readonly provenance: "source";
    };

/**
 * A pure result for combat-store proc execution. `triggeringSourceSkillId` is
 * the RuneWaker skill ID of the attack that generated the hit/crit event.
 * The level-60/70 replacement skills 499477 and 499481 are represented by
 * their learned passive tags and base-ID cast upgrades, not custom procs.
 */
export function romScoutRogueProcActionSpec(
  actionId: string,
  triggeringSourceSkillId: number,
  _casterPoisonous: boolean,
  data: Readonly<Record<string, string | number | boolean>> = {},
): RomScoutRogueProcActionSpec | null {
  switch (actionId) {
    case "rom-enhanced-throat-attack":
    case "rom-slit-throat":
      if (triggeringSourceSkillId !== 490428) return null;
      return { kind: "status", recipient: "target", status: "silence", durationMs: 4_000, provenance: "source" };
    case "rom-sinister-methods": {
      if (![490323, 490311].includes(triggeringSourceSkillId)) return null;
      const criticalStrike = data.criticalStrike;
      const durationMs = data.durationMs;
      const cooldownMs = data.cooldownMs;
      if (typeof criticalStrike !== "number" || !Number.isFinite(criticalStrike)
        || typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs <= 0
        || typeof cooldownMs !== "number" || !Number.isFinite(cooldownMs) || cooldownMs <= 0) return null;
      return {
        kind: "aura",
        recipient: "caster",
        aura: {
          id: "rom-pair-sinister-methods-critical",
          name: "Sinister Methods",
          disposition: "buff",
          durationMs,
          maxStacks: 1,
          stackBehavior: "refresh",
          modifiers: [{ kind: "stat", stat: "physical-critical-strike", operation: "flat", value: criticalStrike }],
        },
        cooldownMs,
        provenance: "source",
      };
    }
    case "rom-accurate-targeting": {
      if (triggeringSourceSkillId !== 490423) return null;
      return {
        kind: "aura",
        recipient: "caster",
        aura: {
          id: "rom-scout-accurate-targeting",
          name: "Accurate Targeting",
          disposition: "buff",
          durationMs: 15_000, // Source component 503255.
          modifiers: [{ kind: "stat", stat: "physical-attack", operation: "flat", value: 50 }],
        },
        provenance: "source",
      };
    }
    case "rom-exploiting-shot":
      if (triggeringSourceSkillId !== 490423) return null;
      return {
        kind: "aura",
        recipient: "target",
        aura: {
          id: "rom-pair-exploiting-shot-vulnerability",
          name: "Exploiting Shot",
          disposition: "debuff",
          durationMs: 12_000, // Source component 503169.
          maxStacks: 5, // Explicit hybrid cap; source tooltip references a cap without a numeric value.
          stackBehavior: "add",
          modifiers: [{ kind: "damage", direction: "taken", school: "physical", operation: "percent", value: 0.02 }],
        },
        provenance: "hybrid-estimate",
      };
    case "rom-deadly-counterattack":
      if (triggeringSourceSkillId !== 490400) return null;
      return {
        kind: "aura",
        recipient: "caster",
        aura: {
          id: "rom-pair-deadly-counterattack-crit",
          name: "Deadly Counterattack",
          disposition: "buff",
          durationMs: 5_000, // Hybrid estimate; source specifies a 20s internal cooldown, not buff duration.
          modifiers: [{ kind: "stat", stat: "physical-critical-strike", operation: "flat", value: 20 }],
        },
        provenance: "hybrid-estimate",
      };
    case "rom-poisonous-spit":
      // Poison Powder (item 200563) is supplied as an unlimited bag reagent by
      // the Scout/Rogue loadout model. Do not use Rogue's separate Poison
      // Bottle aura (490329) as a proxy for carrying this item.
      if (ROM_SCOUT_ROGUE_POISON_POWDER_SUPPLY.quantity !== "unlimited"
        || ![490457, 490424].includes(triggeringSourceSkillId)) return null;
      return {
        kind: "dot",
        recipient: "target",
        effect: {
          kind: "dot",
          coefficient: 0,
          basePoints: 7.1,
          pointsPerLevel: 2.1,
          sourceLevel: 1,
          ticks: 4,
          intervalMs: 2_000,
          tag: "rom-poisonous-spit",
        },
        provenance: "source", // 503522; Poison Powder is a carried item, not Rogue's Poison Bottle buff.
      };
    case "rom-reclaim-energy":
      if (triggeringSourceSkillId === 490306) return {
        kind: "resource", recipient: "caster", resource: "energy", amount: 15, provenance: "hybrid-estimate",
      };
      if (triggeringSourceSkillId === 492625) return {
        kind: "resource", recipient: "caster", resource: "rage", amount: 10, provenance: "hybrid-estimate",
      };
      return null;
    case "rom-infection-rage":
      return triggeringSourceSkillId === 492625
        ? { kind: "resource", recipient: "caster", resource: "rage", amount: 20, provenance: "hybrid-estimate" }
        : null;
    case "rom-toxic-splash": // 499477 is applied as an upgrade of base 492920.
    case "rom-poison-battle-technique": // 499481 is applied as an upgrade of base 490133.
      return null;
    default:
      return null;
  }
}