using System.Diagnostics.CodeAnalysis;
using PkmnLib.Dynamic.Events;
using PkmnLib.Dynamic.Libraries;
using PkmnLib.Dynamic.Models.Choices;
using PkmnLib.Dynamic.Models.Serialized;
using PkmnLib.Dynamic.ScriptHandling;
using PkmnLib.Static;
using PkmnLib.Static.Species;
using PkmnLib.Static.Utils;

namespace PkmnLib.Dynamic.Models;

/// <summary>
/// A Pokémon taking part in a battle. This wraps an <see cref="IPokemon"/> and holds all state that is only
/// relevant for the duration of a single battle. The wrapper is ephemeral: it is created when the battle is
/// created, and simply dropped when the battle ends, taking all battle-only state with it. Persistent data is
/// proxied to the underlying <see cref="IPokemon"/>.
/// </summary>
public interface IBattlePokemon : IPokemon
{
    /// <summary>
    /// The persistent Pokémon this battle Pokémon wraps.
    /// </summary>
    IPokemon UnderlyingPokemon { get; }

    /// <summary>
    /// The battle the Pokémon is in.
    /// </summary>
    IBattle Battle { get; }

    /// <summary>
    /// The index of the side of the Pokémon.
    /// </summary>
    byte SideIndex { get; }

    /// <summary>
    /// The index of the position of the Pokémon on the field.
    /// </summary>
    byte Position { get; }

    /// <summary>
    /// The side the Pokémon is on.
    /// </summary>
    IBattleSide BattleSide { get; }

    /// <summary>
    /// Whether the Pokémon is on the battlefield.
    /// </summary>
    bool IsOnBattlefield { get; }

    /// <summary>
    /// A list of opponents the Pokémon has seen this battle.
    /// </summary>
    IReadOnlyList<IBattlePokemon> SeenOpponents { get; }

    /// <summary>
    /// Adds an opponent to the list of seen opponents.
    /// </summary>
    void MarkOpponentAsSeen(IBattlePokemon opponent);

    /// <summary>
    /// A list of items the Pokémon has consumed this battle.
    /// </summary>
    IReadOnlyList<IItem> ConsumedItems { get; }

    /// <summary>
    /// Marks an item as consumed.
    /// </summary>
    void MarkItemAsConsumed(IItem item);

    /// <summary>
    /// The turn the Pokémon last switched in.
    /// </summary>
    uint SwitchInTurn { get; }

    /// <summary>
    /// The number of turns the Pokémon has been on the field.
    /// </summary>
    uint TurnsOnField { get; }

    /// <summary>
    /// The species of the Pokémon at the time the battle started.
    /// </summary>
    ISpecies OriginalSpecies { get; }

    /// <summary>
    /// The form of the Pokémon at the time the battle started.
    /// </summary>
    IForm OriginalForm { get; }

    /// <summary>
    /// The last move choice executed by the Pokémon.
    /// </summary>
    IMoveChoice? LastMoveChoice { get; set; }

    /// <summary>
    /// The statistics boosts of the Pokemon. Will prevent the value from going above 6, and below -6.
    /// </summary>
    StatBoostStatisticSet StatBoost { get; }

    /// <summary>
    /// The stats of the Pokemon including the stat boosts.
    /// </summary>
    StatisticSet<uint> BoostedStats { get; }

    /// <summary>
    /// Calculates the boosted stats on the Pokemon, _without_ recalculating the flat stats.
    /// This should be called when a stat boost changes.
    /// </summary>
    void RecalculateBoostedStats();

    /// <summary>
    /// Change a boosted stat by a certain amount.
    /// </summary>
    /// <param name="stat">The stat to be changed</param>
    /// <param name="change">The amount to change the stat by</param>
    /// <param name="selfInflicted">Whether the change was self-inflicted. This can be relevant in scripts.</param>
    /// <param name="force">Whether to skip the script hooks that can prevent or change the boost</param>
    /// <param name="batchId">The event batch ID this change is a part of. This is relevant for visual handling</param>
    bool ChangeStatBoost(Statistic stat, sbyte change, bool selfInflicted, bool force, EventBatchId batchId = default);

    /// <summary>
    /// The volatile status scripts of the Pokemon.
    /// </summary>
    IScriptSet Volatile { get; }

    /// <summary>
    /// The script for the ability.
    /// </summary>
    ScriptContainer AbilityScript { get; }

    /// <summary>
    /// The script for the held item.
    /// </summary>
    ScriptContainer HeldItemTriggerScript { get; }

    /// <summary>
    /// An ability can be overriden to an arbitrary ability. This is for example used for the Mummy
    /// ability.
    /// </summary>
    IAbility? OverrideAbility { get; }

    /// <summary>
    /// Changes the ability of the Pokémon.
    /// </summary>
    bool ChangeAbility(IAbility ability);

    /// <summary>
    /// Whether the ability of the Pokémon is suppressed.
    /// </summary>
    bool AbilitySuppressed { get; }

    /// <summary>
    /// Suppresses the ability of the Pokémon.
    /// </summary>
    bool SuppressAbility();

    /// <summary>
    /// Returns the currently active ability, taking suppression and overrides into account.
    /// </summary>
    IAbility? ActiveAbility { get; }

    /// <summary>
    /// An optional display species of the Pokemon. If this is set, the client should display this
    /// species. An example of usage for this is the Illusion ability.
    /// </summary>
    ISpecies? DisplaySpecies { get; }

    /// <summary>
    /// An optional display form of the Pokemon. If this is set, the client should display this
    /// form. An example of usage for this is the Illusion ability.
    /// </summary>
    IForm? DisplayForm { get; }

    /// <summary>
    /// Sets the display species and form of the Pokemon. This is used for abilities like Illusion.
    /// </summary>
    void SetDisplaySpecies(ISpecies? species, IForm? form);

    /// <summary>
    /// The height of the Pokémon in meters. This can be changed during battle by effects such as Autotomize.
    /// </summary>
    new float HeightInMeters { get; set; }

    /// <summary>
    /// Removes a type from the Pokémon. Returns whether the type was removed.
    /// </summary>
    bool RemoveType(TypeIdentifier type);

    /// <summary>
    /// Adds a type to the Pokémon. Returns whether the type was added. It will not add the type if
    /// the Pokémon already has it.
    /// </summary>
    bool AddType(TypeIdentifier type);

    /// <summary>
    /// Replace the types of the Pokémon with the provided types.
    /// </summary>
    void SetTypes(IReadOnlyList<TypeIdentifier> types);

    /// <summary>
    /// Whether the Pokémon is levitating. This is used for moves like Magnet Rise, and abilities such as
    /// Levitate.
    /// </summary>
    bool IsFloating { get; }

    /// <summary>
    /// The permanently learned moves of the Pokemon, ignoring any temporary replacements made through
    /// <see cref="LearnTemporaryMove"/>. This is of a set length of <see cref="Const.MovesCount"/>. Empty move
    /// slots are null.
    /// </summary>
    IReadOnlyList<ILearnedMove?> BaseMoves { get; }

    /// <summary>
    /// Temporarily replaces the move in the given slot until the Pokemon leaves the battlefield. The permanently
    /// learned move in the slot is left untouched and becomes visible again automatically. Used by effects such as
    /// Mimic.
    /// </summary>
    /// <exception cref="KeyNotFoundException">Thrown when the move is not found in the move library.</exception>
    void LearnTemporaryMove(StringKey moveName, MoveLearnMethod method, byte index);

    /// <summary>
    /// Whether or not this Pokemon was caught this battle.
    /// </summary>
    bool IsCaught { get; }

    /// <summary>
    /// Marks the Pokemon as caught. This makes it so that the Pokemon is not considered valid in battle anymore.
    /// </summary>
    void MarkAsCaught();

    /// <summary>
    /// Whether the held item has been removed for the duration of the battle.
    /// </summary>
    bool HasItemBeenRemovedForBattle { get; }

    /// <summary>
    /// Removes the held item from the Pokemon for the duration of the battle. Returns the previously held item.
    /// </summary>
    /// <remarks>
    /// This is used for moves that remove a held item, but do not consume it. The held item of the underlying
    /// Pokémon is never touched; the removal simply ends with the battle.
    /// </remarks>
    IItem? RemoveHeldItemForBattle();

    /// <summary>
    /// Tries to steal the held item of the Pokémon. If successful, the item is removed from the Pokémon and returned.
    /// If the Pokémon does not have a held item, or the item is a form changer, this will return false.
    /// </summary>
    bool TryStealHeldItem([NotNullWhen(true)] out IItem? item);

    /// <summary>
    /// Restores the held item of a Pokémon if it was temporarily removed.
    /// </summary>
    void RestoreRemovedHeldItem();

    /// <summary>
    /// Makes the Pokemon uses its held item. Returns whether the item was consumed.
    /// </summary>
    bool ConsumeHeldItem();

    /// <summary>
    /// Called by the battle when the Pokémon is sent onto the battlefield. This should not be called by
    /// user code; use <see cref="IBattleSide.SwapPokemon(byte, IBattlePokemon?)"/> instead.
    /// </summary>
    void OnSwitchedIn(byte position);

    /// <summary>
    /// Called by the battle when the Pokémon leaves the battlefield. Resets all state that only lasts while
    /// the Pokémon is on the field. This should not be called by user code.
    /// </summary>
    void OnSwitchedOut();

    /// <summary>
    /// Sets the position the Pokémon has within its side, without running switch handling.
    /// </summary>
    void SetPosition(byte position);

    /// <summary>
    /// Called when the battle has ended. Reverts the few battle effects that write through to the underlying
    /// Pokémon, such as battle-only forms.
    /// </summary>
    void OnBattleEnd();
}

/// <inheritdoc cref="IBattlePokemon"/>
public class BattlePokemonImpl : ScriptSource, IBattlePokemon
{
    private readonly IPokemon _pokemon;

    /// <inheritdoc cref="BattlePokemonImpl"/>
    public BattlePokemonImpl(IPokemon pokemon, IBattle battle, byte sideIndex)
    {
        _pokemon = pokemon;
        Battle = battle;
        SideIndex = sideIndex;
        OriginalSpecies = pokemon.Species;
        OriginalForm = pokemon.Form;
        Volatile = new ScriptSet(this);
        _types = pokemon.Types.ToList();
        HeightInMeters = pokemon.HeightInMeters;
        _heldItem = pokemon.HeldItem;
        RecalculateBoostedStats();
        // A status that was set outside of the battle is parented to the underlying Pokémon. Re-parent it to
        // this wrapper, so that it has battle context for the duration of the battle.
        pokemon.StatusScript.Script?.OnAddedToParent(this);
    }

    /// <inheritdoc />
    public IPokemon UnderlyingPokemon => _pokemon;

    /// <inheritdoc />
    public IBattle Battle { get; }

    /// <inheritdoc />
    public byte SideIndex { get; }

    /// <inheritdoc />
    public byte Position { get; private set; }

    /// <inheritdoc />
    public IBattleSide BattleSide => Battle.Sides[SideIndex];

    /// <inheritdoc />
    public bool IsOnBattlefield { get; private set; }

    private readonly List<IBattlePokemon> _seenOpponents = [];

    /// <inheritdoc />
    public IReadOnlyList<IBattlePokemon> SeenOpponents => _seenOpponents;

    /// <inheritdoc />
    public void MarkOpponentAsSeen(IBattlePokemon opponent)
    {
        if (!_seenOpponents.Contains(opponent))
            _seenOpponents.Add(opponent);
    }

    private readonly List<IItem> _consumedItems = [];

    /// <inheritdoc />
    public IReadOnlyList<IItem> ConsumedItems => _consumedItems;

    /// <inheritdoc />
    public void MarkItemAsConsumed(IItem item)
    {
        _consumedItems.Add(item);
        BattleSide.SetConsumedItem(Position, item);
    }

    /// <inheritdoc />
    public uint SwitchInTurn { get; private set; }

    /// <inheritdoc />
    public uint TurnsOnField => Battle.CurrentTurnNumber - SwitchInTurn;

    /// <inheritdoc />
    public ISpecies OriginalSpecies { get; }

    /// <inheritdoc />
    public IForm OriginalForm { get; }

    /// <inheritdoc />
    public IMoveChoice? LastMoveChoice { get; set; }

    /// <inheritdoc />
    public void OnSwitchedIn(byte position)
    {
        Position = position;
        SwitchInTurn = Battle.CurrentTurnNumber;
        IsOnBattlefield = true;
        ResolveAbilityScript();
    }

    /// <inheritdoc />
    public void OnSwitchedOut()
    {
        IsOnBattlefield = false;
        Volatile.Clear();
        _temporaryMoves = null;
        HeightInMeters = _pokemon.Form.Height;
        _types = _pokemon.Form.Types.ToList();
        OverrideAbility = null;
        AbilitySuppressed = false;
        StatBoost.Reset();
        RecalculateBoostedStats();
    }

    /// <inheritdoc />
    public void SetPosition(byte position) => Position = position;

    /// <inheritdoc />
    public void OnBattleEnd()
    {
        if (_pokemon.Form.IsBattleOnlyForm)
        {
            _pokemon.ChangeForm(OriginalSpecies == _pokemon.Species ? OriginalForm : _pokemon.Species.GetDefaultForm());
        }
    }

    private void ResolveAbilityScript()
    {
        var ability = ActiveAbility;
        if (ability != null && Library.ScriptResolver.TryResolve(ScriptCategory.Ability, ability.Name,
                ability.Parameters, out var abilityScript))
        {
            AbilityScript.Set(abilityScript);
            abilityScript.OnAddedToParent(this);
        }
        else
        {
            AbilityScript.Clear();
        }
    }

    /// <inheritdoc />
    public IDynamicLibrary Library => _pokemon.Library;

    /// <inheritdoc />
    public ISpecies Species => _pokemon.Species;

    /// <inheritdoc />
    public IForm Form => _pokemon.Form;

    /// <inheritdoc />
    public LevelInt Level => _pokemon.Level;

    /// <inheritdoc />
    public uint Experience => _pokemon.Experience;

    /// <inheritdoc />
    public uint PersonalityValue => _pokemon.PersonalityValue;

    /// <inheritdoc />
    public Gender Gender => _pokemon.Gender;

    /// <inheritdoc />
    public byte Coloring => _pokemon.Coloring;

    /// <inheritdoc />
    public bool IsShiny => _pokemon.IsShiny;

    /// <inheritdoc />
    public uint CurrentHealth => _pokemon.CurrentHealth;

    /// <inheritdoc />
    public byte Happiness
    {
        get => _pokemon.Happiness;
        set => _pokemon.Happiness = value;
    }

    /// <inheritdoc />
    public StatisticSet<uint> FlatStats => _pokemon.FlatStats;

    /// <inheritdoc />
    public IndividualValueStatisticSet IndividualValues => _pokemon.IndividualValues;

    /// <inheritdoc />
    public EffortValueStatisticSet EffortValues => _pokemon.EffortValues;

    /// <inheritdoc />
    public INature Nature => _pokemon.Nature;

    /// <inheritdoc />
    public string? Nickname => _pokemon.Nickname;

    /// <inheritdoc />
    public AbilityIndex AbilityIndex => _pokemon.AbilityIndex;

    /// <inheritdoc />
    public IAbility Ability => _pokemon.Ability;

    /// <inheritdoc />
    public bool AllowedExperience => _pokemon.AllowedExperience;

    /// <inheritdoc />
    public bool IsEgg => _pokemon.IsEgg;

    /// <inheritdoc />
    public ScriptContainer StatusScript => _pokemon.StatusScript;

    /// <inheritdoc />
    public int? GetStatusTurnsLeft => _pokemon.GetStatusTurnsLeft;

    /// <inheritdoc />
    public bool HasStatus(StringKey status) => _pokemon.HasStatus(status);

    /// <inheritdoc />
    public bool IsFainted => _pokemon.IsFainted;

    /// <inheritdoc />
    public SerializedPokemon Serialize() => _pokemon.Serialize();

    /// <inheritdoc />
    public bool AddExperience(uint experience, EventHook? eventHook = null) =>
        _pokemon.AddExperience(experience, eventHook ?? Battle.EventHook);

    /// <inheritdoc />
    public void RestoreAllPP()
    {
        foreach (var move in Moves)
        {
            move?.RestoreAllUses();
        }
    }

    /// <inheritdoc />
    public void LearnMove(StringKey moveName, MoveLearnMethod method, byte index) =>
        _pokemon.LearnMove(moveName, method, index);

    /// <inheritdoc />
    public void ChangeLevelBy(int change)
    {
        _pokemon.ChangeLevelBy(change);
        RecalculateBoostedStats();
    }

    /// <inheritdoc />
    public bool EvolveTo(IEvolution evolution, EventHook? eventHook = null) =>
        _pokemon.EvolveTo(evolution, eventHook ?? Battle.EventHook);

    /// <inheritdoc />
    public StatBoostStatisticSet StatBoost { get; } = new();

    /// <inheritdoc />
    public StatisticSet<uint> BoostedStats { get; } = new();

    /// <inheritdoc />
    public uint MaxHealth => BoostedStats.Hp;

    /// <inheritdoc />
    public void RecalculateFlatStats()
    {
        _pokemon.RecalculateFlatStats();
        RecalculateBoostedStats();
    }

    /// <inheritdoc />
    public void RecalculateBoostedStats() => Library.StatCalculator.CalculateBoostedStats(this, BoostedStats);

    /// <inheritdoc />
    public bool ChangeStatBoost(Statistic stat, sbyte change, bool selfInflicted, bool force,
        EventBatchId batchId = default)
    {
        if (!force)
        {
            var prevented = false;
            this.RunScriptHook<IScriptPreventStatBoostChange>(script =>
                script.PreventStatBoostChange(this, stat, change, selfInflicted, ref prevented));
            if (prevented)
                return false;
            this.RunScriptHook<IScriptChangeStatBoostChange>(script =>
                script.ChangeStatBoostChange(this, stat, selfInflicted, ref change));
            if (change == 0)
                return false;
        }
        var changed = false;
        var oldBoost = StatBoost.GetStatistic(stat);
        changed = change switch
        {
            > 0 => StatBoost.IncreaseStatistic(stat, change),
            < 0 => StatBoost.DecreaseStatistic(stat, (sbyte)-change),
            _ => changed,
        };
        if (!changed)
            return false;
        var newBoost = StatBoost.GetStatistic(stat);
        Battle.EventHook.Invoke(new StatBoostEvent(this, stat, oldBoost, newBoost)
        {
            BatchId = batchId,
        });

        RecalculateBoostedStats();
        this.RunScriptHook<IScriptOnAfterStatBoostChange>(script =>
            script.OnAfterStatBoostChange(this, stat, selfInflicted, change));
        return true;
    }

    /// <inheritdoc />
    public ISpecies? DisplaySpecies { get; private set; }

    /// <inheritdoc />
    public IForm? DisplayForm { get; private set; }

    /// <inheritdoc />
    public void SetDisplaySpecies(ISpecies? species, IForm? form)
    {
        DisplaySpecies = species;
        DisplayForm = form;

        Battle.EventHook.Invoke(new DisplaySpeciesChangeEvent(this, species, form)
        {
            BatchId = new EventBatchId(),
        });
    }

    /// <inheritdoc />
    public void ChangeSpecies(ISpecies species, IForm form, EventHook? eventHook = null, IRandom? random = null)
    {
        var oldAbilityName = _pokemon.Form.GetAbility(_pokemon.AbilityIndex);
        _pokemon.ChangeSpecies(species, form, eventHook ?? Battle.EventHook, random ?? Battle.Random);
        OnAfterFormWriteThrough(oldAbilityName);
    }

    /// <inheritdoc />
    public void ChangeForm(IForm form, EventBatchId batchId = default, EventHook? eventHook = null)
    {
        if (form == Form)
            return;
        var oldAbilityName = _pokemon.Form.GetAbility(_pokemon.AbilityIndex);
        _pokemon.ChangeForm(form, batchId, eventHook ?? Battle.EventHook);
        OnAfterFormWriteThrough(oldAbilityName);
    }

    /// <summary>
    /// A form or species change writes through to the underlying Pokémon; the battle overlays that derive
    /// from the form need to be re-initialized from the new form.
    /// </summary>
    private void OnAfterFormWriteThrough(StringKey oldAbilityName)
    {
        _types = _pokemon.Form.Types.ToList();
        HeightInMeters = _pokemon.Form.Height;
        var newAbilityName = _pokemon.Form.GetAbility(_pokemon.AbilityIndex);
        if (OverrideAbility == null && !AbilitySuppressed && oldAbilityName != newAbilityName)
            ResolveAbilityScript();
        RecalculateBoostedStats();
    }

    private List<TypeIdentifier> _types;

    /// <inheritdoc />
    public IReadOnlyList<TypeIdentifier> Types => _types;

    /// <inheritdoc />
    public bool RemoveType(TypeIdentifier type) => _types.Remove(type);

    /// <inheritdoc />
    public bool AddType(TypeIdentifier type)
    {
        if (_types.Contains(type))
            return false;
        _types.Add(type);
        return true;
    }

    /// <inheritdoc />
    public void SetTypes(IReadOnlyList<TypeIdentifier> types) => _types = types.ToList();

    /// <inheritdoc />
    public float HeightInMeters { get; set; }

    /// <inheritdoc />
    public float WeightInKg
    {
        get
        {
            var weight = _pokemon.WeightInKg;
            // ReSharper disable once AccessToModifiedClosure
            this.RunScriptHook<IScriptModifyWeight>(script => script.ModifyWeight(ref weight));
            if (weight < 0.1f)
                weight = 0.1f;
            return weight;
        }
    }

    private static readonly StringKey FlyingTypeName = "flying";

    /// <inheritdoc />
    public bool IsFloating
    {
        get
        {
            var isFloating = Types.Any(x => x.Name == FlyingTypeName);
            this.RunScriptHook<IScriptIsFloating>(x => x.IsFloating(this, ref isFloating));
            return isFloating;
        }
    }

    /// <inheritdoc />
    public IAbility? OverrideAbility { get; private set; }

    /// <inheritdoc />
    public bool AbilitySuppressed { get; private set; }

    /// <inheritdoc />
    public IAbility? ActiveAbility
    {
        get
        {
            if (AbilitySuppressed)
                return null;
            if (OverrideAbility != null)
                return OverrideAbility;
            return _pokemon.Ability;
        }
    }

    /// <inheritdoc />
    public bool SuppressAbility()
    {
        if (ActiveAbility?.CanBeChanged == false)
            return false;

        AbilitySuppressed = true;
        AbilityScript.Clear();
        return true;
    }

    /// <inheritdoc />
    public bool ChangeAbility(IAbility ability)
    {
        if (!ability.CanBeChanged)
            return false;
        OverrideAbility = ability;
        if (Library.ScriptResolver.TryResolve(ScriptCategory.Ability, ability.Name, ability.Parameters,
                out var abilityScript))
        {
            AbilityScript.Set(abilityScript);
            abilityScript.OnAddedToParent(this);
        }
        else
        {
            AbilityScript.Clear();
        }
        return true;
    }

    /// <summary>
    /// Battle-only per-slot overrides of the underlying moveset. The permanent moveset is never mutated by
    /// temporary moves; discarding this array is all that is needed to restore the original moves.
    /// </summary>
    private ILearnedMove?[]? _temporaryMoves;

    /// <inheritdoc />
    public IReadOnlyList<ILearnedMove?> Moves =>
        _temporaryMoves?.Select((move, index) => move ?? BaseMoves[index]).ToArray() ?? BaseMoves;

    /// <inheritdoc />
    public IReadOnlyList<ILearnedMove?> BaseMoves => _pokemon.Moves;

    /// <inheritdoc />
    public bool HasMove(StringKey moveName) => Moves.Any(move => move?.MoveData.Name == moveName);

    /// <inheritdoc />
    public void SwapMoves(byte index1, byte index2)
    {
        if (index1 >= Const.MovesCount || index2 >= Const.MovesCount)
            return;
        _pokemon.SwapMoves(index1, index2);
        if (_temporaryMoves != null)
            (_temporaryMoves[index1], _temporaryMoves[index2]) = (_temporaryMoves[index2], _temporaryMoves[index1]);
    }

    /// <inheritdoc />
    public void LearnTemporaryMove(StringKey moveName, MoveLearnMethod method, byte index)
    {
        if (index >= Const.MovesCount)
            throw new ArgumentOutOfRangeException(nameof(index), $"Move slot {index} is out of range.");
        if (!Library.StaticLibrary.Moves.TryGet(moveName, out var move))
            throw new KeyNotFoundException($"Move {moveName} not found.");

        _temporaryMoves ??= new ILearnedMove?[Const.MovesCount];
        _temporaryMoves[index] = new LearnedMoveImpl(move, method);
    }

    private IItem? _heldItem;

    /// <inheritdoc />
    public IItem? HeldItem => _heldItem;

    /// <inheritdoc />
    public bool HasHeldItem(StringKey itemName) => _heldItem?.Name == itemName;

    /// <inheritdoc />
    public IItem? ForceSetHeldItem(IItem? item)
    {
        var previous = _heldItem;
        _heldItem = item;
        this.RunScriptHook<IScriptOnAfterHeldItemChange>(x => x.OnAfterHeldItemChange(this, previous, item));
        return previous;
    }

    /// <inheritdoc />
    public IItem? RemoveHeldItem()
    {
        if (_heldItem is not null && _heldItem.Category == ItemCategory.FormChanger)
            return null;
        var previous = _heldItem;
        _heldItem = null;
        this.RunScriptHook<IScriptOnAfterHeldItemChange>(x => x.OnAfterHeldItemChange(this, previous, null));
        return previous;
    }

    private IItem? _removedHeldItem;

    /// <inheritdoc />
    public bool HasItemBeenRemovedForBattle => _removedHeldItem is not null;

    /// <inheritdoc />
    public IItem? RemoveHeldItemForBattle() => _removedHeldItem = RemoveHeldItem();

    /// <inheritdoc />
    public bool TryStealHeldItem([NotNullWhen(true)] out IItem? item)
    {
        if (_heldItem is null || _heldItem.Category == ItemCategory.FormChanger)
        {
            item = null;
            return false;
        }
        var prevent = false;
        this.RunScriptHook<IScriptPreventHeldItemSteal>(script =>
            script.PreventHeldItemSteal(this, _heldItem, ref prevent));
        if (prevent)
        {
            item = null;
            return false;
        }
        item = RemoveHeldItemForBattle();
        return item is not null;
    }

    /// <inheritdoc />
    public void RestoreRemovedHeldItem()
    {
        _ = ForceSetHeldItem(_removedHeldItem);
        _removedHeldItem = null;
    }

    /// <inheritdoc />
    public bool ConsumeHeldItem()
    {
        if (_heldItem is null)
            return false;
        if (!Library.ScriptResolver.TryResolveBattleItemScript(_heldItem, out _))
            return false;

        var prevented = false;
        this.RunScriptHook<IScriptPreventHeldItemConsume>(script =>
            script.PreventHeldItemConsume(this, _heldItem, ref prevented));
        if (prevented)
            return false;
        MarkItemAsConsumed(_heldItem);

        UseItem(ForceSetHeldItem(null)!);
        return true;
    }

    /// <inheritdoc />
    public void UseItem(IItem item)
    {
        // TODO: actually consume the item

        this.RunScriptHook<IScriptOnAfterItemConsume>(x => x.OnAfterItemConsume(this, item));
    }

    /// <inheritdoc />
    public bool IsCaught { get; private set; }

    /// <inheritdoc />
    public void MarkAsCaught()
    {
        IsCaught = true;
    }

    /// <inheritdoc />
    public bool IsUsable => !IsCaught && _pokemon.IsUsable;

    /// <inheritdoc />
    public void Damage(uint damage, DamageSource source, EventBatchId batchId = default, bool forceDamage = false)
    {
        if (IsFainted)
            return;
        if (!forceDamage)
        {
            var dmg = damage;
            this.RunScriptHook<IScriptChangeIncomingDamage>(script =>
                script.ChangeIncomingDamage(this, source, ref dmg));
            damage = dmg;
        }
        if (damage == 0)
            return;

        // If the damage is more than the current health, we cap it at the current health, to prevent
        // underflow.
        if (damage >= CurrentHealth)
            damage = CurrentHealth;
        var newHealth = CurrentHealth - damage;
        // Trigger an event to the front-end.
        Battle.EventHook.Invoke(new DamageEvent(this, CurrentHealth, newHealth, source)
        {
            BatchId = batchId,
        });
        // And allow scripts to execute.
        this.RunScriptHook<IScriptOnDamage>(script => script.OnDamage(this, source, CurrentHealth, newHealth));

        _pokemon.Damage(damage, source, batchId, true);

        // If the Pokémon is now fainted, we also run faint handling.
        if (IsFainted)
        {
            OnFaint(source);
        }
    }

    /// <inheritdoc />
    public void Faint(DamageSource source, EventBatchId batchId = default)
    {
        _pokemon.Faint(source, batchId);
        OnFaint(source);
    }

    private void OnFaint(DamageSource source)
    {
        // Trigger the faint event to the front-end.
        Battle.EventHook.Invoke(new FaintEvent(this));

        // Allow scripts to trigger based on the faint.
        this.RunScriptHook<IScriptOnFaint>(script => script.OnFaint(this, source));
        foreach (var ally in BattleSide.Pokemon.WhereNotNull().Where(x => x != this))
        {
            ally.RunScriptHook<IScriptOnAllyFaint>(script => script.OnAllyFaint(ally, this));
        }

        // Make sure the OnRemove script is run.
        this.RunScriptHook<IScriptOnRemove>(script => script.OnRemove());

        // Mark the position as unfillable if it can't be filled by any party.
        if (!Battle.CanSlotBeFilled(SideIndex, Position))
        {
            BattleSide.MarkPositionAsUnfillable(Position);
        }
        BattleSide.MarkFaint(Position);
        BattleSide.ForceClearPokemonFromField(Position);

        foreach (var opponent in SeenOpponents)
        {
            if (!opponent.IsUsable)
                continue;
            if (!opponent.AllowedExperience)
                continue;
            opponent.AddExperience(Library.ExperienceGainCalculator.CalculateExperienceGain(this, opponent));
        }

        // Validate the battle state to see if the battle is over.
        Battle.ValidateBattleState();
    }

    /// <inheritdoc />
    public bool Heal(uint heal, bool allowRevive = false, EventBatchId batchId = default, bool forceHeal = false,
        EventHook? customEventHook = null)
    {
        if (IsFainted && !allowRevive)
            return false;

        var maxAmount = BoostedStats.Hp - CurrentHealth;
        if (heal > maxAmount)
            heal = maxAmount;
        if (heal == 0)
            return false;
        if (!forceHeal)
        {
            var prevented = false;
            this.RunScriptHook<IScriptPreventHeal>(x => x.PreventHeal(this, heal, allowRevive, ref prevented));
            if (prevented)
                return false;
        }

        customEventHook ??= Battle.EventHook;
        return _pokemon.Heal(heal, allowRevive, batchId, true, customEventHook);
    }

    /// <inheritdoc />
    public bool SetStatus(StringKey status, IPokemon? originPokemon, EventBatchId batchId = default)
    {
        if (!Library.ScriptResolver.TryResolve(ScriptCategory.Status, status, null, out var statusScript))
            throw new KeyNotFoundException($"Status script {status} not found");

        if (!StatusScript.IsEmpty)
            return false;
        var oldStatus = StatusScript.Script?.Name;
        var selfInflicted = originPokemon == this ||
                            (originPokemon is IBattlePokemon origin && origin.UnderlyingPokemon == _pokemon);

        var preventStatus = false;
        this.RunScriptHook<IScriptPreventStatusChange>(script =>
            script.PreventStatusChange(this, status, selfInflicted, ref preventStatus));
        if (preventStatus)
            return false;

        StatusScript.Set(statusScript);
        statusScript.OnAddedToParent(this);
        Battle.EventHook.Invoke(new StatusChangeEvent(this, oldStatus, status)
        {
            BatchId = batchId,
        });
        this.RunScriptHook<IScriptOnAfterStatusChange>(script =>
            script.OnAfterStatusChange(this, status, originPokemon));
        return true;
    }

    /// <inheritdoc />
    public void ClearStatus(EventBatchId batchId = default)
    {
        var oldStatus = StatusScript.Script?.Name;
        _pokemon.ClearStatus(batchId);
        Battle.EventHook.Invoke(new StatusChangeEvent(this, oldStatus, null)
        {
            BatchId = batchId,
        });
    }

    /// <inheritdoc />
    public ScriptContainer HeldItemTriggerScript { get; } = new();

    /// <inheritdoc />
    public ScriptContainer AbilityScript { get; } = new();

    /// <inheritdoc />
    public IScriptSet Volatile { get; }

    /// <inheritdoc />
    public override int ScriptCount => 4 + BattleSide.ScriptCount;

    /// <inheritdoc />
    public override void GetOwnScripts(List<IEnumerable<ScriptContainer>> scripts)
    {
        scripts.Add(HeldItemTriggerScript);
        scripts.Add(AbilityScript);
        scripts.Add(StatusScript);
        scripts.Add(Volatile);
    }

    /// <inheritdoc />
    public override void CollectScripts(List<IEnumerable<ScriptContainer>> scripts)
    {
        GetOwnScripts(scripts);
        BattleSide.CollectScripts(scripts);
    }

    /// <inheritdoc />
    public override string ToString() => _pokemon.ToString()!;
}