#define CATCH_CONFIG_RUNNER
#include <PkmnLib/ScriptResolving/AngelScript/AngelScriptResolver.hpp>
#include <filesystem>
#include "../extern/catch.hpp"
#include "BuildData/BuildItems.hpp"
#include "BuildData/BuildMoves.hpp"
#include "BuildData/BuildNatures.hpp"
#include "BuildData/BuildSpecies.hpp"
#include "BuildData/BuildTypes.hpp"
#include "BuildData/GrowthRatesBuilder.hpp"
#include "Library.hpp"

static const char* ScriptsPath = nullptr;

// static constexpr const char* GetCategoryPath(CreatureLib::Battling::ScriptResolver::ScriptCategory category){
//     switch (category){
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Attack: return "Moves";
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Talent: return "Abilities";
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Status: return "Status";
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Creature: return "Pokemon";
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Battle: return "Battle";
//         case CreatureLib::Battling::ScriptResolver::ScriptCategory::Side: return "Side";
//     }
// }

// static const char* LoadFunc(CreatureLib::Battling::ScriptResolver::ScriptCategory category, const char* scriptName){
//     auto categoryStr = GetCategoryPath(category);
//     char fullPath[strlen(ScriptsPath) + 1 + strlen(categoryStr) + 1 + strlen(scriptName) + 3];
//     strcpy(fullPath, ScriptsPath);
//     strcat(fullPath, "/");
//     strcat(fullPath, categoryStr);
//     strcat(fullPath, "/");
//     strcat(fullPath, scriptName);
//     strcat(fullPath, ".as");
//     std::ifstream in(fullPath);
//     std::string contents((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
//     char res[contents.size()];
//     return strcpy(res, contents.c_str());
// }

int main(int argc, char* argv[]) {
    Catch::Session session;

    std::string workingDirectory = "";
    std::string typesFile = "Types.csv";
    std::string naturesFile = "Natures.csv";
    std::string pokemonFile = "Pokemon.json";
    std::string moveFile = "Moves.json";
    std::string itemsFile = "Items.json";
    std::string growthRatesFile = "GrowthRates.json";
    std::string scriptsPath = "Scripts";

    using namespace Catch::clara;
    auto cli = session.cli() | Opt(workingDirectory, "Working Directory")["--workdir"]("Which work directory to use.") |
               Opt(pokemonFile, "Species")["--species"]("Which species file to load.") |
               Opt(typesFile, "Types")["--types"]("Which Types file to load.") |
               Opt(naturesFile, "Natures")["--natures"]("Which Natures file to load.") |
               Opt(moveFile, "Moves")["--moves"]("Which Moves file to load.") |
               Opt(itemsFile, "Items")["--items"]("Which Items file to load.") |
               Opt(growthRatesFile, "Growthrates")["--growthrates"]("Which Growthrates file to load.") |
               Opt(scriptsPath, "Scripts")["--scripts"]("Which Scripts path to load scripts from.");

    session.cli(cli);

    int returnCode = session.applyCommandLine(argc, argv);
    if (returnCode != 0) // Indicates a command line error
        return returnCode;
    if (session.config().showHelp())
        return 0;

    if (!workingDirectory.empty()) {
        chdir(workingDirectory.c_str());
    }

    auto typesLibrary = BuildTypes::Build(typesFile);
    auto natureLibrary = BuildNatures::Build(naturesFile);
    auto speciesLibrary = BuildSpecies::BuildLibrary(pokemonFile, typesLibrary);
    auto movesLibrary = BuildMoves::Build(moveFile, typesLibrary);
    auto itemsLibrary = BuildItems::Build(itemsFile);
    auto growthRates = GrowthRatesBuilder::Build(growthRatesFile);
    ScriptsPath = scriptsPath.c_str();

    if (typesLibrary == nullptr || speciesLibrary == nullptr || natureLibrary == nullptr || movesLibrary == nullptr ||
        itemsLibrary == nullptr || growthRates == nullptr)
        return 1;

    auto settings = new PkmnLib::Library::LibrarySettings(100, 4, 4096);
    auto staticLibrary = new PkmnLib::Library::PokemonLibrary(settings, speciesLibrary, movesLibrary, itemsLibrary,
                                                              growthRates, typesLibrary, natureLibrary);

    auto scriptResolver = PkmnLib::Battling::BattleLibrary::CreateScriptResolver();

    auto battleLib = new PkmnLib::Battling::BattleLibrary(
        staticLibrary, new PkmnLib::Battling::StatCalculator(), new PkmnLib::Battling::DamageLibrary(),
        new PkmnLib::Battling::ExperienceLibrary(), scriptResolver, new PkmnLib::Battling::MiscLibrary());

    scriptResolver->Initialize(battleLib);

    auto asScriptResolver = dynamic_cast<AngelScriptResolver*>(scriptResolver);

    for (const auto& dirEntry : std::filesystem::recursive_directory_iterator(ScriptsPath)) {
        if (dirEntry.is_directory())
            continue;
        if (dirEntry.path().parent_path().stem() == "Interfaces")
            continue;
        if (dirEntry.path().extension() != ".as")
            continue;
        std::ifstream in(dirEntry.path());
        std::string contents((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
        asScriptResolver->CreateScript(dirEntry.path().c_str(), contents.c_str());
    }

    asScriptResolver->CreateScript("TriggerEffectChance", R"(
namespace Battle{
[Battle effect=TriggerEffectChance]
class TriggerEffectChance : PkmnScript {
    void ModifyEffectChance(ExecutingMove@ attack, Pokemon@ target, float& chance) override{chance = 10000;} }
})");
    asScriptResolver->CreateScript("BlockEffectChance", R"(
namespace Battle{
[Battle effect=BlockEffectChance]
class BlockEffectChance : PkmnScript {
    void ModifyEffectChance(ExecutingMove@ attack, Pokemon@ target, float& chance) override{chance = -10000;} }
})");
    asScriptResolver->CreateScript("SaveEffectChance", R"(
namespace Battle{
[Battle effect=SaveEffectChance]
class SaveEffectChance : PkmnScript {
    float _chance = 0;
    void ModifyEffectChance(ExecutingMove@ attack, Pokemon@ target, float& chance) override{_chance = chance;}
    float GetChance() { return _chance; }
}
})");

    asScriptResolver->FinalizeModule();

    Library::SetStaticLib(staticLibrary);
    Library::SetLibrary(battleLib);

    return session.run();
}