#include "RegisterBattleClass.hpp"
#include <CreatureLib/Battling/Models/Battle.hpp>
#include <CreatureLib/Battling/Models/BattleSide.hpp>
#include <scripthandle/scripthandle.h>
#include <type_traits>
#include "../../../../Battling/Battle/Battle.hpp"
#include "../../../../Battling/Pokemon/Pokemon.hpp"
#include "../../AngelScriptResolver.hpp"
#include "../../AngelscriptUserdata.hpp"
#include "../HelperFile.hpp"

void RegisterBattleClass::Register(asIScriptEngine* non_null engine) {
    RegisterChoiceQueue(engine);
    RegisterBattleRandom(engine);
    RegisterBattleSide(engine);
    RegisterBattle(engine);
}

void RegisterBattleClass::RegisterChoiceQueue(asIScriptEngine* non_null engine) {
    [[maybe_unused]] int r = engine->RegisterObjectType("ChoiceQueue", 0, asOBJ_REF | asOBJ_NOCOUNT);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("ChoiceQueue", "bool MovePokemonChoiceNext(Pokemon@ target)",
                                     asMETHOD(CreatureLib::Battling::ChoiceQueue, MoveCreatureChoiceNext),
                                     asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("ChoiceQueue", "const BaseTurnChoice@ Peek() const",
                                     asMETHOD(CreatureLib::Battling::ChoiceQueue, Peek), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("ChoiceQueue", "bool HasNext() const",
                                     asMETHOD(CreatureLib::Battling::ChoiceQueue, HasNext), asCALL_THISCALL);
    Ensure(r >= 0);
}

void RegisterBattleClass::RegisterBattleRandom(asIScriptEngine* non_null engine) {
    [[maybe_unused]] int r = engine->RegisterObjectType("BattleRandom", 0, asOBJ_REF | asOBJ_NOCOUNT);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleRandom",
                                     "bool EffectChance(float chance, ExecutingMove@ move, Pokemon@ target )",
                                     asMETHOD(CreatureLib::Battling::BattleRandom, EffectChance), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleRandom", "int Get()",
                                     asMETHODPR(CreatureLib::Battling::BattleRandom, Get, (), int32_t),
                                     asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleRandom", "int Get(int max)",
                                     asMETHODPR(CreatureLib::Battling::BattleRandom, Get, (int32_t), int32_t),
                                     asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleRandom", "int Get(int min, int max)",
                                     asMETHODPR(CreatureLib::Battling::BattleRandom, Get, (int32_t, int32_t), int32_t),
                                     asCALL_THISCALL);
    Ensure(r >= 0);
}

CreatureLib::Battling::BattleSide* GetBattleSideWrapper(PkmnLib::Battling::Battle* non_null battle, u8 index) {
    EnsureNotNull(battle);
    return battle->GetSides()[index];
}

CreatureLib::Battling::BattleParty* GetPartyWrapper(PkmnLib::Battling::Battle* non_null battle, u8 index) {
    EnsureNotNull(battle);
    return battle->GetParties()[index];
}

CreatureLib::Battling::BattleParty* FindPartyWrapper(PkmnLib::Battling::Battle* non_null battle,
                                                     PkmnLib::Battling::Pokemon* non_null p) {
    EnsureNotNull(battle);
    EnsureNotNull(p);
    auto v = battle->FindPartyForCreature(p);
    if (v.HasValue()) {
        return v.GetValue();
    }
    return {};
}

static CScriptHandle Battle_AddVolatileWrapper(PkmnLib::Battling::Battle* non_null obj, const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    auto handle = CScriptHandle();
    auto* resolver = static_cast<AngelScriptResolver*>(obj->GetLibrary()->GetScriptResolver().get());
    auto script = static_cast<AngelScriptScript*>(obj->AddVolatileScript(name))->GetRawAngelscriptObject();
    handle.Set(script, resolver->GetBaseType("PkmnScript"));
    return handle;
}

static CScriptHandle Battle_GetVolatileWrapper(PkmnLib::Battling::Battle* non_null obj, const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    auto handle = CScriptHandle();
    auto* resolver = static_cast<AngelScriptResolver*>(obj->GetLibrary()->GetScriptResolver().get());
    auto* s = static_cast<AngelScriptScript*>(obj->GetVolatileScript(name).GetValue());
    if (s == nullptr) {
        return handle;
    }
    auto* script = s->GetRawAngelscriptObject();
    handle.Set(script, resolver->GetBaseType("PkmnScript"));
    return handle;
}

static CScriptHandle BattleSide_AddVolatileWrapper(CreatureLib::Battling::BattleSide* non_null obj,
                                                   const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    auto handle = CScriptHandle();
    auto* resolver = static_cast<AngelScriptResolver*>(obj->GetBattle()->GetLibrary()->GetScriptResolver().get());
    auto script = static_cast<AngelScriptScript*>(obj->AddVolatileScript(name))->GetRawAngelscriptObject();
    handle.Set(script, resolver->GetBaseType("PkmnScript"));
    return handle;
}

static CScriptHandle BattleSide_GetVolatileWrapper(CreatureLib::Battling::BattleSide* non_null obj,
                                                   const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    auto handle = CScriptHandle();
    auto* resolver = static_cast<AngelScriptResolver*>(obj->GetBattle()->GetLibrary()->GetScriptResolver().get());
    auto s = obj->GetVolatileScript(name).ForceAs<AngelScriptScript>();
    if (!s.HasValue()) {
        return handle;
    }
    auto* script = s.GetValue()->GetRawAngelscriptObject();
    handle.Set(script, resolver->GetBaseType("PkmnScript"));
    return handle;
}

static bool Battle_HasVolatileWrapper(PkmnLib::Battling::Battle* non_null obj, const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    return obj->HasVolatileScript(name);
}
static bool BattleSide_HasVolatileWrapper(CreatureLib::Battling::BattleSide* non_null obj,
                                          const ArbUt::StringView& name) {
    EnsureNotNull(obj);
    return obj->HasVolatileScript(name);
}

static u8 GetPokemonIndexWrapper(CreatureLib::Battling::BattleSide* non_null obj, PkmnLib::Battling::Pokemon* pokemon) {
    EnsureNotNull(obj);
    return obj->GetCreatureIndex(pokemon);
}

static PkmnLib::Battling::Pokemon* GetPokemonWrapper(CreatureLib::Battling::BattleSide* non_null obj, u8 index) {
    EnsureNotNull(obj);
    return dynamic_cast<PkmnLib::Battling::Pokemon*>(obj->GetCreature(index).GetValue());
}

void RegisterBattleClass::RegisterBattleSide(asIScriptEngine* engine) {
    int r = engine->RegisterObjectMethod(
        "BattleSide", "bool SwapPositions(uint8 a, uint8 b)",
        asMETHODPR(CreatureLib::Battling::BattleSide, SwapPositions, (u8 a, u8 b), bool), asCALL_THISCALL);
    Ensure(r >= 0);

    REGISTER_GETTER("BattleSide", "uint8 get_SideIndex() const property", CreatureLib::Battling::BattleSide,
                    GetSideIndex);
    REGISTER_GETTER("BattleSide", "bool get_IsDefeated() const property", CreatureLib::Battling::BattleSide,
                    IsDefeated);
    REGISTER_GETTER("BattleSide", "bool get_HasFled() const property", CreatureLib::Battling::BattleSide, HasFled);
    REGISTER_GETTER("BattleSide", "Battle@ get_Battle() const property", CreatureLib::Battling::BattleSide, GetBattle);

    REGISTER_GETTER("BattleSide", "narray<Pokemon>@ get_Pokemon() const property", CreatureLib::Battling::BattleSide,
                    GetCreatures);
    r = engine->RegisterObjectMethod("BattleSide", "uint8 GetPokemonIndex(const Pokemon@ pokemon) const",
                                     asFUNCTION(GetPokemonIndexWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleSide", "Pokemon@ GetPokemon(uint8 index) const",
                                     asFUNCTION(GetPokemonWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);

    r = engine->RegisterObjectMethod("BattleSide", "ref@ AddVolatile(const constString &in name)",
                                     asFUNCTION(BattleSide_AddVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleSide", "ref@ GetVolatile(const constString &in name)",
                                     asFUNCTION(BattleSide_GetVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod(
        "BattleSide", "void RemoveVolatile(const constString &in name) const",
        asMETHODPR(CreatureLib::Battling::BattleSide, RemoveVolatileScript, (const ArbUt::BasicStringView&), void),
        asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("BattleSide", "bool HasVolatile(const constString &in name) const",
                                     asFUNCTION(BattleSide_HasVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
}

void RegisterBattleClass::RegisterBattle(asIScriptEngine* engine) {
    REGISTER_GETTER("Battle", "const BattleLibrary@ get_Library() const property", CreatureLib::Battling::Battle,
                    GetLibrary);
    REGISTER_GETTER("Battle", "bool get_CanFlee() const property", CreatureLib::Battling::Battle, CanFlee);
    REGISTER_GETTER("Battle", "uint get_CurrentTurn() const property", CreatureLib::Battling::Battle, GetCurrentTurn);
    REGISTER_GETTER("Battle", "uint8 get_PokemonPerSide() const property", CreatureLib::Battling::Battle,
                    GetCreaturesPerSide);
    REGISTER_GETTER("Battle", "BattleRandom@ get_Random() const property", CreatureLib::Battling::Battle, GetRandom);
    REGISTER_GETTER("Battle", "ChoiceQueue@ get_TurnQueue() const property", CreatureLib::Battling::Battle,
                    GetCurrentTurnQueue);
    REGISTER_GETTER("Battle", "narray<BattleSide>@ get_Sides() const property", CreatureLib::Battling::Battle,
                    GetSides);
    REGISTER_GETTER("Battle", "narray<BattleParty>@ get_Parties() const property", CreatureLib::Battling::Battle,
                    GetParties);
    REGISTER_GETTER("Battle", "BattleHistory@ get_History() const property", CreatureLib::Battling::Battle, GetHistory);

    auto r = engine->RegisterObjectMethod("Battle", "bool CanUse(BaseTurnChoice@ choice)",
                                          asMETHOD(PkmnLib::Battling::Battle, CanUse), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "ref@ AddVolatile(const constString &in name)",
                                     asFUNCTION(Battle_AddVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "ref@ GetVolatile(const constString &in name)",
                                     asFUNCTION(Battle_GetVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod(
        "Battle", "void RemoveVolatile(const constString &in name) const",
        asMETHODPR(PkmnLib::Battling::Battle, RemoveVolatileScript, (const ArbUt::BasicStringView&), void),
        asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod(
        "Battle", "bool SetWeather(const constString &in name) const",
        asMETHODPR(PkmnLib::Battling::Battle, SetWeather, (const ArbUt::StringView&), bool), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "void ClearWeather(const constString &in name) const",
                                     asMETHODPR(PkmnLib::Battling::Battle, ClearWeather, (), void), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod(
        "Battle", "const constString& GetWeatherName() const",
        asMETHODPR(PkmnLib::Battling::Battle, GetWeatherName, (), const ArbUt::StringView&), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "void SuppressWeather() const",
                                     asMETHOD(PkmnLib::Battling::Battle, SuppressWeather), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "void UnsuppressWeather() const",
                                     asMETHOD(PkmnLib::Battling::Battle, UnsuppressWeather), asCALL_THISCALL);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "BattleSide@ GetBattleSide(uint8 index)",
                                     asFUNCTION(GetBattleSideWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "BattleParty@ GetParty(uint8 index)", asFUNCTION(GetPartyWrapper),
                                     asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "BattleParty@ FindPartyForPokemon(Pokemon@ pokemon)",
                                     asFUNCTION(FindPartyWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
    r = engine->RegisterObjectMethod("Battle", "bool HasVolatile(const constString &in name) const",
                                     asFUNCTION(Battle_HasVolatileWrapper), asCALL_CDECL_OBJFIRST);
    Ensure(r >= 0);
}