#if TESTS_BUILD and ANGELSCRIPT
#include <doctest.h>
#include "../../../../TestLibrary/TestLibrary.hpp"
#include "../../../../src/Battling/Battle/Battle.hpp"
#include "../../../../src/Battling/Pokemon/CreatePokemon.hpp"
#include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
#include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"

static std::unordered_map<const char*, const char*> _scripts =
    std::unordered_map<const char*, const char*>{{"testScript1", R"(
namespace Pokemon{
[Pokemon effect=testScript1]
class testScript1 : PkmnScript {
    bool testGetPokemonIndex(BattleSide@ b, const Pokemon@ pokemon){ return b.GetPokemonIndex(pokemon) == 0; }

    bool testGetSides(BattleSide@ a, BattleSide@ b, Battle@ battle) {
        return battle.Sides.At(0) is a;
    }
}}
)"}};

struct ScriptData {
    AngelScriptScript* Script = nullptr;
    AngelScriptResolver* Resolver = nullptr;
    asIScriptFunction* Func = nullptr;
    asIScriptContext* Context = nullptr;

    ~ScriptData() {
        Script->GetContextPool()->ReturnContextToPool(Context);
        delete Script;
    }
};

static AngelScriptResolver* _resolverCache = nullptr;
static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary* mainLib) {
    if (_resolverCache == nullptr) {
        _resolverCache = dynamic_cast<AngelScriptResolver*>(PkmnLib::Battling::BattleLibrary::CreateScriptResolver());
        _resolverCache->Initialize(mainLib);
        _resolverCache->CreateScript("testScript1", _scripts["testScript1"]);
        _resolverCache->FinalizeModule();
    }
    return _resolverCache;
}

static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
    auto lib = GetScriptResolver(mainLib);
    auto s = lib->LoadScript(nullptr, ScriptCategory::Creature, "testScript1"_cnc).TakeOwnership();
    auto script = dynamic_cast<AngelScriptScript*>(s);
    REQUIRE(script != nullptr);

    auto ctxPool = script->GetContextPool();
    auto ctx = ctxPool->RequestContext();

    auto func = script->PrepareMethod(funcName, ctx);
    REQUIRE(func != nullptr);

    return {.Script = script, .Resolver = lib, .Func = func, .Context = ctx};
}

TEST_CASE("Validate Battle Side GetPokemonIndex") {
    auto mainLib = TestLibrary::GetLibrary();

    auto mon = PkmnLib::Battling::CreatePokemon(mainLib, "testSpecies"_cnc, 30).Build();
    auto mon2 = PkmnLib::Battling::CreatePokemon(mainLib, "testSpecies"_cnc, 30).Build();

    auto userParty = CreatureLib::Battling::CreatureParty({mon});
    auto targetParty = CreatureLib::Battling::CreatureParty({mon2});
    auto battle = PkmnLib::Battling::Battle(
        mainLib, {
                     new CreatureLib::Battling::BattleParty(&userParty, {CreatureLib::Battling::CreatureIndex(0, 0)}),
                     new CreatureLib::Battling::BattleParty(&targetParty, {CreatureLib::Battling::CreatureIndex(1, 0)}),
                 });

    battle.SwitchCreature(0, 0, mon);
    battle.SwitchCreature(1, 0, mon2);

    auto data = GetScript(mainLib, "testGetPokemonIndex"_cnc);
    data.Context->SetArgObject(0, battle.GetSides()[0]);
    data.Context->SetArgObject(1, mon);

    REQUIRE(data.Context->Execute() == asEXECUTION_FINISHED);
    REQUIRE((bool)data.Context->GetReturnWord());
}

TEST_CASE("Validate Battle GetBattleSides") {
    auto mainLib = TestLibrary::GetLibrary();
    auto battle = new PkmnLib::Battling::Battle(mainLib, {});

    auto data = GetScript(mainLib, "testGetSides"_cnc);
    data.Context->SetArgObject(0, battle->GetSides()[0].GetRaw());
    data.Context->SetArgObject(1, battle->GetSides()[1].GetRaw());
    data.Context->SetArgObject(2, battle);

    REQUIRE(data.Context->Execute() == asEXECUTION_FINISHED);
    REQUIRE((bool)data.Context->GetReturnWord());

    delete battle;
}

#endif