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::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);
    }

    /// 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,
}

#[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(ActionWithDeadline {
                action: action_with_deadline.action.clone(),
                deadline_tick: action_with_deadline.deadline_tick,
            });
    }

    // 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 { .. } => {
                    if ability_cooldown != 0 {
                        self.push(&ActionWithDeadline {
                            action: EntityAction::StartCastAbility {
                                ability_id,
                                by_entity_id: self.entity_id,
                                pet_id: None,
                            },
                            deadline_tick: current_tick + ability_cooldown,
                        })
                    }
                }
                EntityAction::CastBasicAbility { .. } => {
                    if ability_cooldown != 0 {
                        self.push(&ActionWithDeadline {
                            action: EntityAction::StartCastAbility {
                                ability_id,
                                by_entity_id: self.entity_id,
                                pet_id: None,
                            },
                            deadline_tick: current_tick + ability_cooldown,
                        })
                    }
                }
                EntityAction::StartCastAbility { .. } => {}
                EntityAction::CastEffect { .. } => {}
            }
        } else {
            self.push(&ActionWithDeadline {
                action: EntityAction::StartCastAbility {
                    ability_id,
                    by_entity_id: self.entity_id,
                    pet_id: None,
                },
                deadline_tick: 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(),
        }
    }

    pub fn pop(&mut self, current_tick: u64) -> Option<EntityAction> {
        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
            {
                let action = queue.remove(idx);
                return Some(action.action);
            }
        }

        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).
    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.
        let entity_id = self.entity_id;
        self.push(&ActionWithDeadline {
            action: EntityAction::StartCastAbility {
                ability_id,
                by_entity_id: entity_id,
                pet_id: None,
            },
            deadline_tick: 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;
        self.push(&ActionWithDeadline {
            action: EntityAction::StartCastAbility {
                ability_id: ability_id_to_cancel,
                by_entity_id: entity_id,
                pet_id: None,
            },
            deadline_tick: 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>,
}

#[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 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(),
        }
    }
}