essences/

entity.rs

use std::collections::{BTreeMap, HashMap};

use crate::abilities::{AbilityId, ActiveAbility, EquippedAbilities};
use crate::character_state::CharacterState;
use crate::class::ClassId;
use crate::combat_origin::CombatEventOrigin;
use crate::effect::EffectId;
use crate::fighting::EntityTeam;
use crate::game::{EnemyReward, EntityTemplateId};
use crate::items::Item;
use crate::opponents::OpponentState;
use crate::pets::{EquippedPets, PetId};

use crate::prelude::*;
use strum::{EnumIter, IntoEnumIterator};

#[declare]
pub type EntityId = Uuid;

#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct EntityAttributes(pub BTreeMap<String, i64>);

impl EntityAttributes {
    pub fn add(&mut self, key: &str, delta: i64) {
        let value = self
            .0
            .entry(key.to_owned())
            .and_modify(|x| *x += delta)
            .or_insert(delta);
        if *value == 0 {
            self.0.remove(key);
        }
    }

    pub fn set(&mut self, key: &str, value: i64) {
        let value = self
            .0
            .entry(key.to_owned())
            .and_modify(|x| *x = value)
            .or_insert(value);
        if *value == 0 {
            self.0.remove(key);
        }
    }

    pub fn remove_zeroes(&mut self) {
        self.0.retain(|_, v| *v != 0);
    }

    /// Boss-summon-wave: the mob was spawned by a boss summon wave (marked with
    /// the `"summoned"` attribute in `spawn_wave`). Summoned reinforcements carry
    /// NO economy weight — their `wave_share()` is 0, so per-kill drops, pet-ult
    /// charge and counterattack procs from them are zero, and kill quests skip
    /// their deaths. This keeps a boss fight's total faucet flat when the summon
    /// wave is added (the boss keeps its full, unscaled payout).
    pub fn is_summoned(&self) -> bool {
        self.0.contains_key("summoned")
    }

    /// Growing-enemy-waves §2: the mob's reward/weight share as a fraction
    /// (stored per-10000 under `"wave_share"`, like `crit_chance`). Absent ⇒ 1.0
    /// (legacy content with no `reward_mob_budget`). Consumers multiply per-kill
    /// drop chance, pet-ult charge fill and counterattack proc chance by this so
    /// they stay count-invariant when concurrency is inflated. Boss-summoned
    /// reinforcements return 0 (no net faucet, see `is_summoned`).
    pub fn wave_share(&self) -> f64 {
        if self.is_summoned() {
            return 0.0;
        }
        self.0.get("wave_share").copied().unwrap_or(10000) as f64 / 10000.0
    }

    /// BAL-026: this combatant's share of its roster's initial max-HP budget
    /// (stored per-10000 under `"gauge_hp_share"`, stamped at spawn). It
    /// normalizes the OUTGOING damage gauge, so absolute stats never speed the
    /// bar up: killing a full wave is worth the same gauge at any power.
    /// Absent ⇒ 1.0 (a solo roster); summoned reinforcements return 0 and
    /// never move the gauge. A NEGATIVE stamp is the explicit "worth nothing"
    /// marker (BAL-026's invalid-fixture rule — the attribute map drops
    /// literal zeros, so 0 cannot be stored directly) and reads as 0.
    pub fn gauge_hp_share(&self) -> f64 {
        if self.is_summoned() {
            return 0.0;
        }
        self.0
            .get("gauge_hp_share")
            .copied()
            .unwrap_or(10000)
            .max(0) as f64
            / 10000.0
    }

    /// Convention: the entity's speed multiplier lives under the `"speed"` attribute key.
    /// Returns `baseline_speed` when missing, so unmigrated units keep working at 1× cooldown
    /// rate. `baseline_speed` is sourced from `GameSettings.baseline_speed`.
    pub fn speed_or_baseline(&self, baseline_speed: u64) -> i64 {
        self.0
            .get("speed")
            .copied()
            .unwrap_or(baseline_speed as i64)
    }
}

#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct Coordinates {
    #[schemars(title = "Координата по х")]
    pub x: i64,
    #[schemars(title = "Координата по у")]
    pub y: i64,
}

#[derive(Clone, Default, Debug, Copy, Serialize, Hash, Deserialize, PartialEq, Eq, EnumIter)]
pub enum ActionPriority {
    #[default]
    First,
    Second,
    Third,
    Fourth,
}

// This is a copy of CustomEventData from OES/script, because it cant be imported here and also needs to be defined in OES
#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct EssencesCustomEventData(pub BTreeMap<String, i64>);

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum EntityAction {
    CastEffect {
        entity_id: Uuid,
        effect_id: Uuid,
    },
    CastAbility {
        ability_id: AbilityId,
        target_entity_id: EntityId,
    },
    CastBasicAbility {
        ability_id: AbilityId,
        target_entity_id: EntityId,
    },
    StartCastAbility {
        ability_id: AbilityId,
        by_entity_id: EntityId,
        pet_id: Option<PetId>,
    },
}

impl EntityAction {
    fn get_action_priority(action: &EntityAction) -> ActionPriority {
        match action {
            EntityAction::CastEffect { .. } => ActionPriority::First,
            EntityAction::CastAbility { .. } => ActionPriority::Second,
            EntityAction::CastBasicAbility { .. } => ActionPriority::Third,
            EntityAction::StartCastAbility { .. } => ActionPriority::Fourth,
        }
    }

    fn get_actions_priorities(actions: &[Self]) -> Vec<ActionPriority> {
        actions.iter().map(Self::get_action_priority).collect()
    }

    fn get_casting_spell_priorities() -> Vec<ActionPriority> {
        Self::get_actions_priorities(&[
            Self::CastAbility {
                ability_id: Uuid::nil(),
                target_entity_id: Uuid::nil(),
            },
            Self::CastBasicAbility {
                ability_id: Uuid::nil(),
                target_entity_id: Uuid::nil(),
            },
        ])
    }

    pub fn get_cast_ability_priority() -> ActionPriority {
        Self::get_action_priority(&Self::CastAbility {
            ability_id: Uuid::nil(),
            target_entity_id: Uuid::nil(),
        })
    }

    pub fn get_cast_basic_ability_priority() -> ActionPriority {
        Self::get_action_priority(&Self::CastBasicAbility {
            ability_id: Uuid::nil(),
            target_entity_id: Uuid::nil(),
        })
    }

    pub fn get_starting_cast_priority() -> ActionPriority {
        Self::get_action_priority(&Self::StartCastAbility {
            ability_id: Uuid::nil(),
            by_entity_id: Uuid::nil(),
            pet_id: None,
        })
    }

    pub fn get_cast_effect_priority() -> ActionPriority {
        Self::get_action_priority(&Self::CastEffect {
            entity_id: Uuid::nil(),
            effect_id: Uuid::nil(),
        })
    }
}

/// Scales a base cooldown duration (in ticks, defined at baseline speed) by the entity's current
/// speed attribute. Returns the cooldown duration the entity actually experiences.
///
/// `scaled = base * baseline_speed / max(speed, 1)`. A speed of `0` or negative is treated as
/// `baseline_speed`, so unmigrated units keep working at 1×.
///
/// Floors at 1 tick when `base > 0` so high speeds never collapse a cooldown to zero via integer
/// truncation (which would change semantics from "very fast" to "off cooldown forever").
///
/// `baseline_speed` is sourced from `GameSettings.baseline_speed`.
pub fn scale_cooldown_for_speed(base_cooldown_ticks: u64, speed: i64, baseline_speed: u64) -> u64 {
    if base_cooldown_ticks == 0 {
        return 0;
    }
    let baseline = baseline_speed.max(1);
    let effective_speed = if speed <= 0 { baseline } else { speed as u64 };
    let scaled = (base_cooldown_ticks as u128 * baseline as u128) / effective_speed as u128;
    (scaled as u64).max(1)
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct ActionWithDeadline {
    pub action: EntityAction,
    pub deadline_tick: u64,
    /// Provenance the rebuilt event inherits when this action drains.
    ///
    /// The queue is a real hop in a cascade: a modifier arms an interval effect
    /// or drives a cast, and the work comes back one or more ticks later, after
    /// the producing dispatch is long gone. Without this field
    /// `entities::event_from_entity_action` would rebuild it as Core and a
    /// modifier's output would re-enter the triggers that produced it.
    ///
    /// Fight state is never persisted (`active_fight` hydrates as `None`), so
    /// this field is state-shape only — no migration.
    pub origin: CombatEventOrigin,
}

impl ActionWithDeadline {
    /// An action the fight engine itself queues: the entity's own cadence.
    pub fn core(action: EntityAction, deadline_tick: u64) -> Self {
        Self {
            action,
            deadline_tick,
            origin: CombatEventOrigin::Core,
        }
    }
}

#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct EntityActionsQueue {
    action_queues: HashMap<ActionPriority, Vec<ActionWithDeadline>>,
    entity_id: EntityId,
}

impl EntityActionsQueue {
    pub fn new(entity_id: EntityId) -> Self {
        Self {
            action_queues: HashMap::new(),
            entity_id,
        }
    }

    // Push signle action
    pub fn push(&mut self, action_with_deadline: &ActionWithDeadline) {
        let priority = EntityAction::get_action_priority(&action_with_deadline.action);

        self.action_queues
            .entry(priority)
            .or_default()
            .push(action_with_deadline.clone());
    }

    // Add StartCastAbilityAction, depending on what action was triggered
    fn add_start_cast_ability(
        &mut self,
        action_with_deadline: Option<&ActionWithDeadline>,
        current_tick: u64,
        ability_id: AbilityId,
        ability_cooldown: u64,
    ) {
        if let Some(action_with_deadline) = action_with_deadline {
            match action_with_deadline.action {
                EntityAction::CastAbility { .. } | EntityAction::CastBasicAbility { .. } => {
                    if ability_cooldown != 0 {
                        self.push_start_cast_replacing(ability_id, current_tick + ability_cooldown)
                    }
                }
                EntityAction::StartCastAbility { .. } => {}
                EntityAction::CastEffect { .. } => {}
            }
        } else {
            self.push_start_cast_replacing(ability_id, current_tick);
        }
    }

    // Append multiple actions(casts or move) + add start_cast_ability, depending on action
    pub fn append_start_cast_ability_result_actions(
        &mut self,
        actions_with_deadlines: &Vec<ActionWithDeadline>,
        current_tick: u64,
        ability_id: AbilityId,
        ability_cooldown: u64,
    ) {
        for action_with_deadline in actions_with_deadlines {
            self.push(action_with_deadline);
        }

        // TODO
        // If move -> actions_with_deadlines should be empty -> Add StartCastAbility without increased deadline. If CastAbility -> increase deadline by ability cooldown.
        self.add_start_cast_ability(
            actions_with_deadlines.first(),
            current_tick,
            ability_id,
            ability_cooldown,
        );
    }

    fn is_casting_spell(&self) -> bool {
        for priority in EntityAction::get_casting_spell_priorities() {
            if let Some(queue) = self.action_queues.get(&priority)
                && !queue.is_empty()
            {
                return true;
            }
        }
        false
    }

    fn check_action_is_available(&self, action_priority: &ActionPriority) -> bool {
        match action_priority {
            ActionPriority::First => true,
            ActionPriority::Second => true,
            ActionPriority::Third => true,
            ActionPriority::Fourth => !self.is_casting_spell(),
        }
    }

    /// Drains the next due action, provenance included — the rebuilt event
    /// inherits [`ActionWithDeadline::origin`] instead of resetting to Core.
    pub fn pop(&mut self, current_tick: u64) -> Option<ActionWithDeadline> {
        for priority in ActionPriority::iter() {
            if !self.check_action_is_available(&priority) {
                continue;
            }

            if let Some(queue) = self.action_queues.get_mut(&priority)
                && let Some((idx, action_with_deadline)) = queue
                    .iter()
                    .enumerate()
                    .min_by_key(|(_, action_with_deadline)| action_with_deadline.deadline_tick)
                && action_with_deadline.deadline_tick <= current_tick
            {
                return Some(queue.remove(idx));
            }
        }

        None
    }

    pub fn remove_start_cast_ability_action(&mut self, ability_id_to_remove: AbilityId) {
        if let Some(queue) = self.action_queues.get_mut(&EntityAction::get_starting_cast_priority()) && let Some(pos) = queue.iter().position(|action_with_deadline| {
            matches!(
                action_with_deadline.action,
                EntityAction::StartCastAbility { ability_id, .. } if ability_id == ability_id_to_remove
            )
        }) {
            queue.remove(pos);
        }
    }

    pub fn remove_cast_effect_action(&mut self, effect_id_to_remove: EffectId) {
        if let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_cast_effect_priority())
            && let Some(pos) = queue.iter().position(|action_with_deadline| {
                matches!(
                    action_with_deadline.action,
                    EntityAction::CastEffect { effect_id, .. } if effect_id == effect_id_to_remove
                )
            })
        {
            queue.remove(pos);
        }
    }

    pub fn get_closest_start_cast_action_deadline(&self) -> Option<u64> {
        if let Some(queue) = self
            .action_queues
            .get(&EntityAction::get_starting_cast_priority())
        {
            return queue.iter().map(|action| action.deadline_tick).min();
        }

        None
    }

    /// Rescales every `StartCastAbility` (cooldown) entry in the queue to reflect a change in
    /// the entity's speed attribute.
    ///
    /// At speed `S`, a cooldown that was originally `C` ticks long elapses in `C * baseline / S`
    /// game-ticks. So when speed changes from `S_old` to `S_new`, the still-remaining game-ticks
    /// for each in-flight cooldown become `(deadline - current_tick) * S_old / S_new`.
    /// `baseline_speed` falls in for non-positive speed values.
    ///
    /// In-flight casts (`CastAbility` / `CastBasicAbility` cast animations) are intentionally not
    /// touched here — speed scales cooldowns, not cast time.
    pub fn rescale_cooldowns(
        &mut self,
        old_speed: i64,
        new_speed: i64,
        current_tick: u64,
        baseline_speed: u64,
    ) {
        if old_speed == new_speed {
            return;
        }
        let baseline = baseline_speed.max(1);
        let old_speed = if old_speed <= 0 {
            baseline
        } else {
            old_speed as u64
        };
        let new_speed = if new_speed <= 0 {
            baseline
        } else {
            new_speed as u64
        };

        let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        else {
            return;
        };

        for action in queue.iter_mut() {
            if !matches!(action.action, EntityAction::StartCastAbility { .. }) {
                continue;
            }
            let remaining = action.deadline_tick.saturating_sub(current_tick);
            if remaining == 0 {
                continue;
            }
            let scaled = (remaining as u128 * old_speed as u128) / new_speed as u128;
            let scaled = (scaled as u64).max(1);
            action.deadline_tick = current_tick + scaled;
        }
    }

    /// Applies stun semantics to a single ability:
    /// - If the ability is currently mid-cast (`CastAbility`/`CastBasicAbility` queued), cancels
    ///   the cast and sets the cooldown deadline to `current_tick + full_cooldown_ticks +
    ///   duration_ticks` — full cooldown plus the stun freeze on top.
    /// - Otherwise, if the ability already has a cooldown entry, extends its deadline by
    ///   `duration_ticks` (the cooldown effectively pauses for the stun duration).
    /// - Otherwise (off cooldown), pushes a fresh cooldown entry of `duration_ticks` so the
    ///   ability stays unusable while stunned.
    ///
    /// `full_cooldown_ticks` is the ability's full cooldown (already scaled for entity speed if
    /// the caller wants speed to apply).
    /// Push the cooldown entry (`StartCastAbility`) for `ability_id`, replacing any entry
    /// already queued for it and keeping the LATER deadline. One ability must never hold two
    /// self-rescheduling cooldown entries: a stun landing on the exact tick the previous entry
    /// was popped (event in flight) used to add a second one, permanently doubling the
    /// ability's attack loop.
    pub fn push_start_cast_replacing(&mut self, ability_id: AbilityId, deadline_tick: u64) {
        let existing_max = self.start_cast_deadlines(ability_id).into_iter().max();
        if let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        {
            queue.retain(|a| {
                !matches!(
                    a.action,
                    EntityAction::StartCastAbility { ability_id: aid, .. } if aid == ability_id
                )
            });
        }
        let entity_id = self.entity_id;
        // Cooldown entries are the entity's own cadence, not any producer's
        // output: the same metronome would have re-armed with or without a
        // modifier, and its rate is bounded by the ability cooldown. Marking it
        // would silently turn every later swing of that ability into a
        // modifier's product and switch triggers off for the rest of the fight.
        self.push(&ActionWithDeadline::core(
            EntityAction::StartCastAbility {
                ability_id,
                by_entity_id: entity_id,
                pet_id: None,
            },
            existing_max.map_or(deadline_tick, |d| d.max(deadline_tick)),
        ));
    }

    /// Every queued cooldown entry as `(ability_id, deadline_tick)`.
    ///
    /// The read counterpart of [`Self::adjust_ability_cooldown`]: a consumer
    /// that wants "the longest remaining cooldown" (laws `RL-03`, `RL-11`,
    /// `FL-04`, `FL-11`) needs the whole set, not one ability's deadlines.
    pub fn start_cast_entries(&self) -> Vec<(AbilityId, u64)> {
        self.action_queues
            .get(&EntityAction::get_starting_cast_priority())
            .map(|queue| {
                queue
                    .iter()
                    .filter_map(|a| match a.action {
                        EntityAction::StartCastAbility { ability_id, .. } => {
                            Some((ability_id, a.deadline_tick))
                        }
                        _ => None,
                    })
                    .collect()
            })
            .unwrap_or_default()
    }

    /// Remaining cooldown of every ability that is not ready yet, longest
    /// first. Ties break on `ability_id` so the order is deterministic.
    ///
    /// A `StartCastAbility` entry IS the ability's cooldown: it is the
    /// self-rescheduling metronome that lets the ability swing again at
    /// `deadline_tick`. That is why the three helpers below are enough to
    /// express every "shorten / reset a Skill cooldown" Effect Stone without
    /// any new state.
    pub fn ability_cooldowns(&self, current_tick: u64) -> Vec<(AbilityId, u64)> {
        let Some(queue) = self
            .action_queues
            .get(&EntityAction::get_starting_cast_priority())
        else {
            return Vec::new();
        };
        let mut remaining: Vec<(AbilityId, u64)> = queue
            .iter()
            .filter_map(|action| match action.action {
                EntityAction::StartCastAbility { ability_id, .. } => {
                    let left = action.deadline_tick.saturating_sub(current_tick);
                    (left > 0).then_some((ability_id, left))
                }
                _ => None,
            })
            .collect();
        remaining.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
        remaining
    }

    /// Brings EVERY remaining cooldown of the named abilities forward by
    /// `by_ticks` and returns how many entries actually moved.
    ///
    /// The named-set sibling of [`Self::shorten_longest_cooldowns`], which takes
    /// the `count` longest ones instead. `PET-01 Head Start` needs this shape:
    /// its wording is "ALL remaining Skill cooldowns", and the caller — not this
    /// queue, which cannot tell a Skill from a class Basic Attack — decides
    /// which abilities are Skills.
    pub fn shorten_cooldowns_of(
        &mut self,
        current_tick: u64,
        ability_ids: &[AbilityId],
        by_ticks: u64,
    ) -> usize {
        if ability_ids.is_empty() || by_ticks == 0 {
            return 0;
        }
        let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        else {
            return 0;
        };
        let mut moved = 0;
        for action in queue.iter_mut() {
            let EntityAction::StartCastAbility { ability_id, .. } = action.action else {
                continue;
            };
            if !ability_ids.contains(&ability_id) || action.deadline_tick <= current_tick {
                continue;
            }
            action.deadline_tick = action
                .deadline_tick
                .saturating_sub(by_ticks)
                .max(current_tick);
            moved += 1;
        }
        moved
    }

    /// Brings the `count` longest remaining cooldowns forward by `by_ticks` and
    /// returns how many entries actually moved.
    ///
    /// A cooldown is never pushed before `current_tick`: the ability becomes
    /// ready, it does not become ready in the past.
    pub fn shorten_longest_cooldowns(
        &mut self,
        current_tick: u64,
        count: usize,
        by_ticks: u64,
    ) -> usize {
        if count == 0 || by_ticks == 0 {
            return 0;
        }
        let chosen: Vec<AbilityId> = self
            .ability_cooldowns(current_tick)
            .into_iter()
            .take(count)
            .map(|(ability_id, _)| ability_id)
            .collect();
        if chosen.is_empty() {
            return 0;
        }
        let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        else {
            return 0;
        };
        let mut moved = 0;
        for action in queue.iter_mut() {
            let EntityAction::StartCastAbility { ability_id, .. } = action.action else {
                continue;
            };
            if !chosen.contains(&ability_id) || action.deadline_tick <= current_tick {
                continue;
            }
            action.deadline_tick = action
                .deadline_tick
                .saturating_sub(by_ticks)
                .max(current_tick);
            moved += 1;
        }
        moved
    }

    /// Makes every ability ready at `current_tick` and returns how many
    /// cooldowns were cleared.
    pub fn clear_ability_cooldowns(&mut self, current_tick: u64) -> usize {
        let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        else {
            return 0;
        };
        let mut cleared = 0;
        for action in queue.iter_mut() {
            if !matches!(action.action, EntityAction::StartCastAbility { .. })
                || action.deadline_tick <= current_tick
            {
                continue;
            }
            action.deadline_tick = current_tick;
            cleared += 1;
        }
        cleared
    }

    /// Deadlines of every `StartCastAbility` entry queued for `ability_id`.
    /// Load-bearing: `push_start_cast_replacing` uses the max to never shorten
    /// an existing (e.g. stun-extended) cooldown entry.
    pub fn start_cast_deadlines(&self, ability_id: AbilityId) -> Vec<u64> {
        self.action_queues
            .get(&EntityAction::get_starting_cast_priority())
            .map(|queue| {
                queue
                    .iter()
                    .filter(|a| {
                        matches!(
                            a.action,
                            EntityAction::StartCastAbility { ability_id: aid, .. } if aid == ability_id
                        )
                    })
                    .map(|a| a.deadline_tick)
                    .collect()
            })
            .unwrap_or_default()
    }

    pub fn stun_ability(
        &mut self,
        ability_id: AbilityId,
        duration_ticks: u64,
        full_cooldown_ticks: u64,
        current_tick: u64,
    ) {
        let had_in_flight_cast = [
            EntityAction::get_cast_ability_priority(),
            EntityAction::get_cast_basic_ability_priority(),
        ]
        .iter()
        .any(|priority| {
            self.action_queues
                .get(priority)
                .is_some_and(|queue| {
                    queue.iter().any(|action_with_deadline| {
                        matches!(
                            action_with_deadline.action,
                            EntityAction::CastAbility { ability_id: aid, .. } | EntityAction::CastBasicAbility { ability_id: aid, .. } if aid == ability_id
                        )
                    })
                })
        });

        if had_in_flight_cast {
            self.cancel_cast_and_set_cooldown(
                ability_id,
                current_tick
                    .saturating_add(full_cooldown_ticks)
                    .saturating_add(duration_ticks),
            );
            return;
        }

        if self.adjust_ability_cooldown(ability_id, duration_ticks as i64, current_tick) {
            return;
        }

        // No existing cooldown — push a fresh stun-only cooldown (the entry was
        // popped this same tick; the in-flight event is handled by the
        // `stun_until_tick` guard in `logic/fighting.rs`).
        let entity_id = self.entity_id;
        // Cadence entry — see `push_start_cast_replacing`.
        self.push(&ActionWithDeadline::core(
            EntityAction::StartCastAbility {
                ability_id,
                by_entity_id: entity_id,
                pet_id: None,
            },
            current_tick.saturating_add(duration_ticks),
        ));
    }

    /// Cancels any in-flight cast (CastAbility / CastBasicAbility) for `ability_id_to_cancel`
    /// and replaces the cooldown entry (StartCastAbility) with a new one at `new_deadline_tick`.
    /// Returns `true` when an in-flight cast was found and removed.
    pub fn cancel_cast_and_set_cooldown(
        &mut self,
        ability_id_to_cancel: AbilityId,
        new_deadline_tick: u64,
    ) -> bool {
        let mut had_in_flight = false;
        for priority in [
            EntityAction::get_cast_ability_priority(),
            EntityAction::get_cast_basic_ability_priority(),
        ] {
            if let Some(queue) = self.action_queues.get_mut(&priority) {
                let original_len = queue.len();
                queue.retain(|action_with_deadline| {
                    !matches!(
                        action_with_deadline.action,
                        EntityAction::CastAbility { ability_id, .. } if ability_id == ability_id_to_cancel
                    ) && !matches!(
                        action_with_deadline.action,
                        EntityAction::CastBasicAbility { ability_id, .. } if ability_id == ability_id_to_cancel
                    )
                });
                if queue.len() != original_len {
                    had_in_flight = true;
                }
            }
        }

        if let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        {
            queue.retain(|action_with_deadline| {
                !matches!(
                    action_with_deadline.action,
                    EntityAction::StartCastAbility { ability_id, .. } if ability_id == ability_id_to_cancel
                )
            });
        }

        let entity_id = self.entity_id;
        // Cadence entry — see `push_start_cast_replacing`.
        self.push(&ActionWithDeadline::core(
            EntityAction::StartCastAbility {
                ability_id: ability_id_to_cancel,
                by_entity_id: entity_id,
                pet_id: None,
            },
            new_deadline_tick,
        ));

        had_in_flight
    }

    /// Adjusts the cooldown for a specific ability by `delta_ticks`.
    /// Positive delta extends the cooldown, negative shortens it (saturating at `current_tick`,
    /// i.e. no remaining cooldown). Returns `true` when an entry was found and adjusted.
    pub fn adjust_ability_cooldown(
        &mut self,
        ability_id_to_adjust: AbilityId,
        delta_ticks: i64,
        current_tick: u64,
    ) -> bool {
        let Some(queue) = self
            .action_queues
            .get_mut(&EntityAction::get_starting_cast_priority())
        else {
            return false;
        };

        let Some(action) = queue.iter_mut().find(|action_with_deadline| {
            matches!(
                action_with_deadline.action,
                EntityAction::StartCastAbility { ability_id, .. } if ability_id == ability_id_to_adjust
            )
        }) else {
            return false;
        };

        action.deadline_tick = if delta_ticks >= 0 {
            action.deadline_tick.saturating_add(delta_ticks as u64)
        } else {
            let abs = (-delta_ticks) as u64;
            action.deadline_tick.saturating_sub(abs).max(current_tick)
        };

        true
    }

    pub fn view(&self) -> HashMap<ActionPriority, Vec<ActionWithDeadline>> {
        self.action_queues.clone()
    }
}

#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct Entity {
    pub id: EntityId,
    pub max_hp: u64,
    pub hp: u64,
    pub abilities: Vec<ActiveAbility>,
    #[schemars(skip)]
    pub actions_queue: EntityActionsQueue,
    pub attributes: EntityAttributes,
    pub effect_ids: Vec<EffectId>,
    pub coordinates: Coordinates,
    /// Destination of the in-flight run, `None` when not moving. Also reserves
    /// the cell so a concurrently-planning opponent will not run onto it.
    pub move_target: Option<Coordinates>,
    pub width: i8, // not ENUM because JsonSchema and Tsify can't be friends // TODO I am not sure anymore
    pub rewards: Option<Vec<EnemyReward>>,
    pub class_id: Option<ClassId>,
    pub team: EntityTeam,
    pub has_big_hp_bar: bool,
    pub entity_template_id: Option<EntityTemplateId>,
    /// Fight-local copy of this hero's global equipment-side state. Character
    /// combatants carry `Some`; non-player entities carry `None`.
    #[serde(default)]
    pub flip_state: Option<crate::flip::FlipState>,
    /// Fight-local mana. Character combatants carry `Some` (full at fight
    /// start, never carried between fights); mobs carry `None` and are never
    /// mana-gated.
    pub mana: Option<crate::mana::ManaPool>,
    /// Per-proc-type entropy accumulators (PoE-style deterministic proc
    /// resolution): key = stat code,
    /// value = accumulator in permyriad (proc when it crosses 10000). Combat
    /// runtime only: `serde(skip)` keeps it off the wire/DB/Unity schema
    /// (postcard is positional — a serialized field would break the wire);
    /// it resets on reconnect, like PoE resets entropy after idle.
    #[serde(skip)]
    #[schemars(skip)]
    pub proc_entropy: EntropyCell,
    /// Live bridge charges of THIS combatant (twin cores, OVT-2517, laws
    /// v0.2). Combat runtime only, same treatment as `proc_entropy`:
    /// `serde(skip)` keeps it off the wire, the DB and the Unity schema.
    /// `active_fight` is never persisted, so there is no durable copy that
    /// could drift; a reconnect starts a fresh fight and therefore an empty
    /// charge, which is exactly what "the charge resets between fights" already
    /// prescribes.
    #[serde(skip)]
    #[schemars(skip)]
    pub law_bridges: crate::cores::LawBridgeCharges,
    /// Cores snapshot THIS combatant fights with, taken when the entity was
    /// built (`entities::seed_law_state`). Everything the law layer needs
    /// mid-fight — which laws are slotted, at what level, on which side — is
    /// read from here, so the local hero, the party ally and a PvP opponent all
    /// take the same entity-local path instead of the session-state lookup that
    /// only ever worked for the first two.
    ///
    /// Empty for mobs and for a combatant whose cores are not unlocked yet, and
    /// then every law computation degenerates to "no contribution".
    ///
    /// A snapshot rather than a live borrow on purpose: Core build edits made
    /// during combat update durable character state, so this fight intentionally
    /// keeps the Core values captured at start and the new Core build applies to
    /// the next fight. This also keeps a party-ally refresh
    /// from swapping the ally's laws out from under attributes that were
    /// already folded in.
    ///
    /// Combat runtime only, same treatment as `law_bridges`.
    #[serde(skip)]
    #[schemars(skip)]
    pub law_cores: crate::cores::CoresState,
}

/// Sync interior-mutable holder for [`Entity::proc_entropy`] — proc checks run
/// behind `&Entity` throughout the fight code, and `OverlordState` futures
/// must stay `Send` (a `RefCell` here would un-`Sync` the whole state).
/// Manual impls because `Mutex` is neither `Clone` nor `Eq`; equality/clone
/// go through snapshots (combat-transient data, never serialized).
#[derive(Debug, Default)]
pub struct EntropyCell(std::sync::Mutex<std::collections::HashMap<String, i64>>);

impl EntropyCell {
    /// Advance the `key` accumulator by `add` permyriad (seeding it with
    /// `init` on first touch) and report whether it crossed 10000 — the
    /// entropy proc: exactly one proc per 10000 permyriad accumulated, no
    /// streaks either way.
    pub fn bump(&self, key: &str, add: i64, init: impl FnOnce() -> i64) -> bool {
        let mut m = self.0.lock().unwrap();
        let acc = m.entry(key.to_string()).or_insert_with(init);
        *acc += add;
        if *acc >= 10000 {
            *acc -= 10000;
            true
        } else {
            false
        }
    }
}

impl Clone for EntropyCell {
    fn clone(&self) -> Self {
        Self(std::sync::Mutex::new(self.0.lock().unwrap().clone()))
    }
}

impl PartialEq for EntropyCell {
    fn eq(&self, other: &Self) -> bool {
        *self.0.lock().unwrap() == *other.0.lock().unwrap()
    }
}

impl Eq for EntropyCell {}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum EntityState<'a> {
    Character(&'a CharacterState),
    Opponent(&'a OpponentState),
}

impl<'a> EntityState<'a> {
    pub fn id(&self) -> uuid::Uuid {
        match self {
            EntityState::Character(character_state) => character_state.character.id,
            EntityState::Opponent(opponent_state) => opponent_state.id(),
        }
    }

    pub fn level(&self) -> i64 {
        match self {
            EntityState::Character(character_state) => character_state.character.character_level,
            EntityState::Opponent(opponent_state) => opponent_state.level(),
        }
    }

    pub fn current_chapter_level(&self) -> i64 {
        match self {
            EntityState::Character(character_state) => {
                character_state.character.current_chapter_level
            }
            EntityState::Opponent(OpponentState::Human(human)) => {
                human.character_state.character.current_chapter_level
            }
            EntityState::Opponent(OpponentState::Bot(bot)) => bot.bot.level,
        }
    }

    pub fn inventory(&self) -> &Vec<Item> {
        match self {
            EntityState::Character(character_state) => &character_state.inventory,
            EntityState::Opponent(opponent_state) => opponent_state.inventory(),
        }
    }

    pub fn class(&self) -> ClassId {
        match self {
            EntityState::Character(character_state) => character_state.character.class,
            EntityState::Opponent(opponent_state) => opponent_state.class(),
        }
    }

    pub fn equipped_abilities(&self) -> &EquippedAbilities {
        match self {
            EntityState::Character(character_state) => &character_state.equipped_abilities,
            EntityState::Opponent(opponent_state) => opponent_state.equipped_abilities(),
        }
    }

    pub fn equipped_pets(&self) -> Option<&EquippedPets> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.equipped_pets),
            EntityState::Opponent(opponent_state) => opponent_state.equipped_pets(),
        }
    }

    /// Twin-cores state of whoever this combatant is (OVT-2517). A human PvP
    /// opponent carries a full `CharacterState`, so their cores are just as
    /// available as the local hero's; an arena filler bot has none.
    pub fn cores(&self) -> Option<&crate::cores::CoresState> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.cores),
            EntityState::Opponent(opponent_state) => {
                opponent_state.character_state().map(|state| &state.cores)
            }
        }
    }

    /// Researched talent levels of whoever this combatant is. Same shape as
    /// [`Self::cores`]: a human PvP opponent carries a full `CharacterState`, so
    /// their talents are as available as the local hero's; an arena filler bot
    /// has no talent tree and returns `None`.
    pub fn talent_levels(&self) -> Option<&crate::talent_tree::TalentLevelsMap> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.talent_levels),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| &state.talent_levels),
        }
    }

    /// Statue state of whoever this combatant is. `None` for arena filler bots,
    /// which have no statue.
    pub fn statue_state(&self) -> Option<&crate::statue::StatueState> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.statue_state),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| &state.statue_state),
        }
    }

    /// Per-class progression rows of whoever this combatant is. `None` for arena
    /// filler bots, which have no class levels (their `class()` still resolves —
    /// only the levelling progress is absent).
    pub fn character_classes(&self) -> Option<&[crate::class::CharacterClass]> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.character_classes),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| state.character_classes.as_slice()),
        }
    }

    /// Gear-stone inventory of whoever this combatant is. Same shape as
    /// [`Self::cores`]: a human PvP opponent carries a full `CharacterState`,
    /// so their socketed stones count like the local hero's; an arena filler
    /// bot has none.
    pub fn stones(&self) -> Option<&crate::stones::StoneInventory> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.stones),
            EntityState::Opponent(opponent_state) => {
                opponent_state.character_state().map(|state| &state.stones)
            }
        }
    }

    /// Ability-stone collection of whoever this combatant is — the OWNED
    /// stones, socketed or not, which is what Collection Power reads. `None`
    /// for arena filler bots.
    pub fn ability_stones(&self) -> Option<&[crate::ability_stones::OwnedAbilityStone]> {
        match self {
            EntityState::Character(character_state) => {
                Some(character_state.ability_stones.as_slice())
            }
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| state.ability_stones.as_slice()),
        }
    }

    /// Every ability this combatant owns, equipped or not. Distinct from
    /// [`Self::equipped_abilities`], which is the loadout — Collection Power
    /// pays for the collection, so it needs the whole roster. `None` for arena
    /// filler bots, whose kit is authored rather than collected.
    pub fn all_abilities(&self) -> Option<&[crate::abilities::Ability]> {
        match self {
            EntityState::Character(character_state) => {
                Some(character_state.all_abilities.as_slice())
            }
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| state.all_abilities.as_slice()),
        }
    }

    /// Every pet this combatant owns, slotted or not — the counterpart of
    /// [`Self::equipped_pets`] for the same reason [`Self::all_abilities`] is
    /// the counterpart of the loadout. `None` for arena filler bots.
    pub fn all_pets(&self) -> Option<&[crate::pets::Pet]> {
        match self {
            EntityState::Character(character_state) => Some(character_state.all_pets.as_slice()),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| state.all_pets.as_slice()),
        }
    }

    /// Artifact collection of whoever this combatant is. `None` for arena
    /// filler bots, which own no artifacts.
    pub fn artifacts(&self) -> Option<&crate::artifacts::ArtifactCollection> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.artifacts),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| &state.artifacts),
        }
    }

    /// Banked Plinko pin bonuses of whoever this combatant is. `None` for
    /// arena filler bots.
    pub fn plinko_pin_bonuses(&self) -> Option<&crate::plinko::PlinkoPinBonusesMap> {
        match self {
            EntityState::Character(character_state) => Some(&character_state.plinko_pin_bonuses),
            EntityState::Opponent(opponent_state) => opponent_state
                .character_state()
                .map(|state| &state.plinko_pin_bonuses),
        }
    }
}

#[cfg(test)]
mod wave_share_tests {
    use super::*;

    /// §2: `wave_share()` reads the per-10000 attribute as a fraction; absent ⇒
    /// 1.0 (legacy content), so every consumer defaults to no scaling.
    #[test]
    fn wave_share_reads_permyriad_or_defaults_to_one() {
        let mut attrs = EntityAttributes::default();
        assert_eq!(
            attrs.wave_share(),
            1.0,
            "absent wave_share must default to 1.0"
        );

        attrs.add("wave_share", 5000);
        assert_eq!(attrs.wave_share(), 0.5);

        attrs.set("wave_share", 10000);
        assert_eq!(attrs.wave_share(), 1.0);

        attrs.set("wave_share", 3333);
        assert!((attrs.wave_share() - 0.3333).abs() < 1e-9);
    }

    /// Boss-summon: a `summoned` mob has `wave_share() == 0` (no net faucet),
    /// overriding any stamped `wave_share` value, and `is_summoned()` is true.
    #[test]
    fn summoned_mob_has_zero_wave_share() {
        let mut attrs = EntityAttributes::default();
        assert!(!attrs.is_summoned());

        attrs.add("summoned", 1);
        assert!(attrs.is_summoned());
        assert_eq!(
            attrs.wave_share(),
            0.0,
            "a summoned reinforcement contributes no drop/pet/counter faucet"
        );

        // Even if a wave_share is also present, summoned wins (share stays 0).
        attrs.add("wave_share", 5000);
        assert_eq!(attrs.wave_share(), 0.0);
    }
}

#[cfg(test)]
mod entropy_tests {
    use super::*;

    /// The entropy accumulator delivers EXACTLY floor-rate procs: at 25%
    /// (2500 permyriad) every window of 4 checks contains exactly one proc —
    /// no lucky doubles, no dry streaks — for ANY seed. This is the whole
    /// point of the resolver: expected rate identical to independent rolls,
    /// variance of proc COUNT eliminated.
    #[test]
    fn entropy_rate_is_exact_for_any_seed() {
        for seed in [0i64, 1, 2499, 2500, 5000, 9999] {
            let cell = EntropyCell::default();
            let procs: Vec<bool> = (0..40).map(|_| cell.bump("crit", 2500, || seed)).collect();
            let total: usize = procs.iter().filter(|p| **p).count();
            assert_eq!(
                total, 10,
                "25% over 40 checks must proc exactly 10 (seed {seed})"
            );
            // no window of 4 consecutive checks has 2+ procs, none has 0
            for w in procs.windows(4) {
                let c = w.iter().filter(|p| **p).count();
                assert!(c <= 1, "double proc within a 4-window (seed {seed})");
            }
        }
    }

    /// Different proc types keep independent accumulators on one entity.
    #[test]
    fn entropy_keys_are_independent() {
        let cell = EntropyCell::default();
        assert!(!cell.bump("a", 6000, || 0));
        assert!(cell.bump("a", 6000, || 0)); // 12000 → proc
        assert!(!cell.bump("b", 6000, || 0)); // separate key starts fresh
    }
}

#[cfg(test)]
mod ability_cooldown_tests {
    use super::*;

    fn queue_with(deadlines: &[(u128, u64)]) -> EntityActionsQueue {
        let mut queue = EntityActionsQueue::new(Uuid::from_u128(1));
        for (ability, deadline) in deadlines {
            queue.push_start_cast_replacing(Uuid::from_u128(*ability), *deadline);
        }
        queue
    }

    /// The Effect Stones that shorten or clear a Skill cooldown all read this
    /// list, so its order is part of their contract: longest remaining first.
    #[test]
    fn cooldowns_are_reported_longest_first_and_ready_abilities_are_omitted() {
        let queue = queue_with(&[(1, 1_500), (2, 3_000), (3, 1_000)]);

        let remaining = queue.ability_cooldowns(1_000);

        assert_eq!(
            remaining,
            vec![(Uuid::from_u128(2), 2_000), (Uuid::from_u128(1), 500),],
            "ability 3 is already ready at tick 1000 and is not a cooldown"
        );
    }

    /// `EF-C07` Quickstep takes 0.8 s off the longest cooldown — one, not all.
    #[test]
    fn shortening_touches_only_the_longest_cooldowns() {
        let mut queue = queue_with(&[(1, 2_000), (2, 5_000)]);

        assert_eq!(queue.shorten_longest_cooldowns(0, 1, 800), 1);

        assert_eq!(
            queue.ability_cooldowns(0),
            vec![(Uuid::from_u128(2), 4_200), (Uuid::from_u128(1), 2_000),],
            "only the longest one moved"
        );
    }

    /// A cooldown becomes ready, never ready in the past — an over-long
    /// reduction clamps at "now" instead of pushing the deadline behind it.
    #[test]
    fn shortening_past_now_just_makes_the_ability_ready() {
        let mut queue = queue_with(&[(1, 1_200)]);

        queue.shorten_longest_cooldowns(1_000, 1, 10_000);

        assert!(
            queue.ability_cooldowns(1_000).is_empty(),
            "the ability is ready, and no deadline went behind the clock"
        );
        assert_eq!(queue.start_cast_deadlines(Uuid::from_u128(1)), vec![1_000]);
    }

    /// `EF-L04` Time Collapse: every Skill becomes ready at once.
    #[test]
    fn clearing_makes_every_cooldown_ready() {
        let mut queue = queue_with(&[(1, 2_000), (2, 9_000), (3, 500)]);

        assert_eq!(
            queue.clear_ability_cooldowns(1_000),
            2,
            "the two still on cooldown at tick 1000"
        );
        assert!(queue.ability_cooldowns(1_000).is_empty());
    }

    /// Nothing on cooldown is a quiet no-op for both, not a panic.
    #[test]
    fn an_empty_queue_is_a_no_op() {
        let mut queue = EntityActionsQueue::new(Uuid::from_u128(1));
        assert!(queue.ability_cooldowns(0).is_empty());
        assert_eq!(queue.shorten_longest_cooldowns(0, 3, 500), 0);
        assert_eq!(queue.clear_ability_cooldowns(0), 0);
    }
}