#ifndef PKMNLIB_ANGELSCRIPTSCRIPT_HPP
#define PKMNLIB_ANGELSCRIPTSCRIPT_HPP
#include <CreatureLib/Battling/ScriptHandling/BattleScript.hpp>
#include <CreatureLib/Battling/ScriptHandling/ScriptCategory.hpp>
#define ANGELSCRIPT_DLL_LIBRARY_IMPORT
#include <angelscript.h>
#include <scriptarray/scriptarray.h>
#include <scripthandle/scripthandle.h>
#include "../../Battling/PkmnScript.hpp"
#include "AngelScriptTypeInfo.hpp"
#include "TypeRegistry/NativeArray.hpp"

class AngelScriptResolver;
class ContextPool;

class AngelScriptScript final : public PkmnLib::Battling::PkmnScript {
private:
    AngelScriptResolver* _resolver = nullptr;
    AngelScriptTypeInfo* _type = nullptr;
    ContextPool* _ctxPool = nullptr;

    asIScriptObject* _obj = nullptr;
    NativeArray<ArbUt::List<CreatureLib::Library::EffectParameter*>>*
    GetEffectParameters(const ArbUt::List<CreatureLib::Library::EffectParameter*>& ls);

public:
    AngelScriptScript(const ArbUt::OptionalBorrowedPtr<void>& owner, asITypeInfo* ownerType,
                      AngelScriptResolver* resolver, AngelScriptTypeInfo* type, asIScriptObject* obj,
                      ContextPool* ctxPool);

    ~AngelScriptScript() override { _obj->Release(); }

    BattleScript* Clone(const ArbUt::OptionalBorrowedPtr<void>& owner) override;

    inline asIScriptObject* GetRawAngelscriptObject() const noexcept { return _obj; }

    [[nodiscard]] const ArbUt::StringView& GetName() const noexcept override { return _type->GetName(); }
    const AngelScriptTypeInfo* GetType() const noexcept { return _type; }

    asIScriptFunction* PrepareMethod(const ArbUt::BasicStringView& name, asIScriptContext* ctx) {
        auto func = _type->GetFunction(name);
        ctx->Prepare(func);
        ctx->SetObject(_obj);
        return func;
    }

    ContextPool* GetContextPool() { return _ctxPool; }

    CScriptHandle* GetAngelscriptOwner();
    void OnInitialize(const CreatureLib::Battling::BattleLibrary*,
                      const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters) override;
    void Stack() override;

    void OnRemove() override;

    void OnBeforeTurn(const CreatureLib::Battling::BaseTurnChoice* choice) override;

    void ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, ArbUt::StringView* outAttack) override;

    void ModifyNumberOfHits(CreatureLib::Battling::AttackTurnChoice* choice, u8* numberOfHits) override;
    void PreventAttack(CreatureLib::Battling::ExecutingAttack* attack, bool* outResult) override;

    void FailAttack(CreatureLib::Battling::ExecutingAttack* attack, bool* outFailed) override;

    void StopBeforeAttack(CreatureLib::Battling::ExecutingAttack* attack, bool* outResult) override;

    void OnBeforeAttack(CreatureLib::Battling::ExecutingAttack* attack) override;

    void FailIncomingAttack(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                            bool* outResult) override;
    void IsInvulnerable(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                        bool* outResult) override;
    void OnAttackMiss(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target) override;

    void ChangeAttackType(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                          uint8_t hitNumber, uint8_t* outType) override;

    void BlockCritical(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                       uint8_t hitNumber, bool* blockCritical) override;
    void ChangeEffectiveness(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                             uint8_t hitNumber, float* effectiveness) override;

    void PreventStatBoostChange(CreatureLib::Battling::Creature* target, CreatureLib::Library::Statistic stat,
                                int8_t diffAmount, bool* prevent) override;
    void ModifyStatBoostChange(CreatureLib::Battling::Creature* target, CreatureLib::Library::Statistic stat,
                               int8_t* diffAmount) override;
    void PreventSecondaryEffects(const CreatureLib::Battling::ExecutingAttack* attack,
                                 CreatureLib::Battling::Creature* target, uint8_t hitNumber, bool* outResult) override;

    void OnIncomingHit(const CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                       uint8_t hitNumber) override;
    void OnFaintingOpponent(const CreatureLib::Battling::ExecutingAttack* attack,
                            CreatureLib::Battling::Creature* target, u8 hitNumber) override;
    void OnSecondaryEffect(const CreatureLib::Battling::ExecutingAttack* attack,
                           CreatureLib::Battling::Creature* target, uint8_t hitNumber) override;

    void OnAfterHits(const CreatureLib::Battling::ExecutingAttack* attack,
                     CreatureLib::Battling::Creature* target) override;

    void PreventSelfSwitch(const CreatureLib::Battling::SwitchTurnChoice* choice, bool* outResult) override;

    void ModifyEffectChance(const CreatureLib::Battling::ExecutingAttack* attack,
                            CreatureLib::Battling::Creature* target, float* chance) override;
    void ModifyIncomingEffectChance(const CreatureLib::Battling::ExecutingAttack* attack,
                                    CreatureLib::Battling::Creature* target, float* chance) override;

    void OverrideBasePower(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                           uint8_t hitIndex, uint8_t* basePower) override;
    void ChangeDamageStatsUser(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                               uint8_t hitIndex, CreatureLib::Battling::Creature** statsUser) override;
    void BypassDefensiveStat(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                             uint8_t hitIndex, bool* bypass) override;
    void BypassOffensiveStat(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                             uint8_t hitIndex, bool* bypass) override;
    void ModifyStatModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                            uint8_t hitIndex, float* modifier) override;
    void ModifyDamageModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                              uint8_t hitIndex, float* modifier) override;
    void OverrideDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                        uint8_t hitIndex, uint32_t* damage) override;
    void OverrideIncomingDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                                uint8_t hitIndex, uint32_t* damage) override;

    void ChangePriority(CreatureLib::Battling::AttackTurnChoice* choice, int8_t* priority) override;
    void OnFail(CreatureLib::Battling::Creature* target) override;
    void OnOpponentFail(CreatureLib::Battling::Creature* target) override;

    void PreventRunAway(const CreatureLib::Battling::FleeTurnChoice* choice, bool* result) override;
    void PreventOpponentRunAway(const CreatureLib::Battling::FleeTurnChoice* choice, bool* result) override;
    void PreventOpponentSwitch(const CreatureLib::Battling::SwitchTurnChoice* choice, bool* outResult) override;
    void OnEndTurn() override;
    void OnDamage(CreatureLib::Battling::Creature* creature, CreatureLib::Battling::DamageSource source,
                  [[maybe_unused]] u32 oldHealth, [[maybe_unused]] u32 newHealth) override;
    void OnFaint(CreatureLib::Battling::Creature* creature, CreatureLib::Battling::DamageSource source) override;
    void OnSwitchIn(CreatureLib::Battling::Creature* creature) override;
    void OnAfterHeldItemConsume(CreatureLib::Battling::Creature* creature,
                                const CreatureLib::Library::Item* item) override;

    ////////////////////
    // PkmnLib methods//
    ////////////////////

    void PreventIncomingCritical(CreatureLib::Battling::ExecutingAttack* attack,
                                 CreatureLib::Battling::Creature* target, uint8_t hit, bool* preventCrit) override;
    void ModifyCriticalStage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                             uint8_t hit, uint8_t* critStage) override;
    void OverrideCriticalModifier(CreatureLib::Battling::ExecutingAttack* attack,
                                  CreatureLib::Battling::Creature* target, uint8_t hit, float* critModifier) override;
    void OverrideSTABModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
                              uint8_t hit, float* stabModifier) override;

    void ModifyExperienceGain(CreatureLib::Battling::Creature* faintedMon, CreatureLib::Battling::Creature* winningMon,
                              uint32_t* experienceGain) override;
    void DoesShareExperience(CreatureLib::Battling::Creature* faintedMon, CreatureLib::Battling::Creature* winningMon,
                             bool* shareExperience) override;

    void BlockWeather(CreatureLib::Battling::Battle* battle, bool* blockWeather) override;

    void ModifyOffensiveStatValue(CreatureLib::Battling::ExecutingAttack* attack,
                                  CreatureLib::Battling::Creature* target, u8 hitIndex, float* modifier) override;
    void ModifyDefensiveStatValue(CreatureLib::Battling::ExecutingAttack* attack,
                                  CreatureLib::Battling::Creature* target, u8 hitIndex, float* modifier) override;
};

#undef CALL_HOOK
#endif // PKMNLIB_ANGELSCRIPTSCRIPT_HPP