#ifndef CREATURELIB_SCRIPT_HPP
#define CREATURELIB_SCRIPT_HPP

#include <Arbutils/Collections/List.hpp>
#include <Arbutils/Memory/Memory.hpp>
#include <Arbutils/Misc.hpp>
#include "../../Library/EffectParameter.hpp"
#include "../../Library/Items/Item.hpp"
#include "../../Library/Statistic.hpp"
#include "../Models/DamageSource.hpp"

namespace CreatureLib::Battling {
    class BaseTurnChoice;
    class AttackTurnChoice;
    class SwitchTurnChoice;
    class FleeTurnChoice;
    class ExecutingAttack;
    class Creature;
    class BattleLibrary;

    class BattleScript {
        ArbUt::OptionalBorrowedPtr<void> _owner;
        size_t _suppressed = 0;

    public:
        BattleScript(const ArbUt::OptionalBorrowedPtr<void>& owner) { _owner = owner; };
        NO_COPY_OR_MOVE(BattleScript);

        inline ArbUt::OptionalBorrowedPtr<void> GetOwner() const noexcept { return _owner; }
        inline bool IsSuppressed() const noexcept { return _suppressed > 0; }
        inline void Suppress() { _suppressed++; }
        inline void Unsuppress() {
            if (_suppressed > 0)
                _suppressed--;
        }

        virtual ~BattleScript() = default;

        virtual BattleScript* non_null Clone(const ArbUt::OptionalBorrowedPtr<void>& owner) = 0;

        virtual void Stack(){};
        virtual void OnRemove(){};

        [[nodiscard]] virtual const ArbUt::StringView& GetName() const noexcept = 0;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"

        virtual void OnInitialize(const BattleLibrary* non_null,
                                  const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){};
        virtual void OnBeforeTurn(const BaseTurnChoice* non_null choice){};

        virtual void ChangeSpeed(BaseTurnChoice* non_null choice, u32* non_null speed){};
        virtual void ChangePriority(AttackTurnChoice* non_null choice, i8* non_null priority){};
        virtual void ChangeAttack(AttackTurnChoice* non_null choice, ArbUt::StringView* non_null outAttack){};
        virtual void ModifyNumberOfHits(AttackTurnChoice* non_null choice, u8* non_null numberOfHits){};
        virtual void PreventAttack(ExecutingAttack* non_null attack, bool* non_null outResult){};
        virtual void FailAttack(ExecutingAttack* non_null attack, bool* non_null outFailed){};
        virtual void StopBeforeAttack(ExecutingAttack* non_null attack, bool* non_null outResult){};
        virtual void OnBeforeAttack(ExecutingAttack* non_null attack){};

        virtual void FailIncomingAttack(ExecutingAttack* non_null attack, Creature* non_null target,
                                        bool* non_null outResult){};
        virtual void IsInvulnerable(ExecutingAttack* non_null attack, Creature* non_null target,
                                    bool* non_null outResult){};
        virtual void OnAttackMiss(ExecutingAttack* non_null attack, Creature* non_null target){};
        virtual void ChangeAttackType(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitNumber,
                                      u8* non_null outType){};
        virtual void ChangeEffectiveness(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitNumber,
                                         float* non_null effectiveness){};
        virtual void BlockCritical(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitNumber,
                                   bool* non_null blockCritical){};

        virtual void OverrideBasePower(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                       u8* non_null basePower){};
        virtual void ChangeDamageStatsUser(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                           Creature* non_null* non_null statsUser){};

        virtual void BypassDefensiveStat(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                         bool* non_null bypass){};
        virtual void BypassOffensiveStat(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                         bool* non_null bypass){};
        virtual void ModifyStatModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                        float* non_null modifier){};
        virtual void ModifyDamageModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                          float* non_null modifier){};
        virtual void OverrideDamage(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                    u32* non_null damage){};
        virtual void OverrideIncomingDamage(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                            u32* non_null damage){};

        virtual void OnIncomingHit(const ExecutingAttack* non_null attack, Creature* non_null target, u8 hitNumber){};
        virtual void OnFaintingOpponent(const ExecutingAttack* non_null attack, Creature* non_null target,
                                        u8 hitNumber){};

        virtual void PreventStatBoostChange(Creature* non_null target, Library::Statistic stat, i8 diffAmount,
                                            bool selfInflicted, bool* non_null prevent){};
        virtual void ModifyStatBoostChange(Creature* non_null target, Library::Statistic stat,
                                           i8* non_null diffAmount){};
        virtual void PreventSecondaryEffects(const ExecutingAttack* non_null attack, Creature* non_null target,
                                             u8 hitNumber, bool* non_null outResult){};
        virtual void OnSecondaryEffect(const ExecutingAttack* non_null attack, Creature* non_null target,
                                       u8 hitNumber){};

        virtual void OnAfterHits(const ExecutingAttack* non_null attack, Creature* non_null target){};

        virtual void PreventSelfSwitch(const SwitchTurnChoice* non_null choice, bool* non_null outResult){};
        virtual void PreventOpponentSwitch(const SwitchTurnChoice* non_null choice, bool* non_null outResult){};

        virtual void ModifyEffectChance(const ExecutingAttack* non_null attack, Creature* non_null target,
                                        float* non_null chance){};
        virtual void ModifyIncomingEffectChance(const ExecutingAttack* non_null attack, Creature* non_null target,
                                                float* non_null chance){};

        virtual void OnFail(Creature* non_null target){};
        virtual void OnOpponentFail(Creature* non_null target){};

        virtual void PreventRunAway(const FleeTurnChoice* non_null choice, bool* non_null result){};
        virtual void PreventOpponentRunAway(const FleeTurnChoice* non_null choice, bool* non_null result){};

        virtual void OnEndTurn(){};
        virtual void OnDamage(Creature* non_null, DamageSource, u32 oldHealth, u32 newHealth){};
        virtual void OnFaint(Creature* non_null, DamageSource){};
        virtual void OnSwitchIn(Creature* non_null){};

        virtual void OnAfterHeldItemConsume(Creature* non_null, const Library::Item* non_null){};

#pragma GCC diagnostic pop
    };
}

#endif // CREATURELIB_SCRIPT_HPP