#include <filesystem>
#include <EventAPI.h>
#include <LLAPI.h>
#include <ServerAPI.h>
#include <RegCommandAPI.h>
#include <MC/CommandOrigin.hpp>
#include <MC/CommandOutput.hpp>
#include <MC/CommandPosition.hpp>
#include <MC/CommandRegistry.hpp>
#include <MC/Packet.hpp>
#include <MC/ServerPlayer.hpp>
#include <MC/VanillaDimensions.hpp>
#include <Main/Config.h>
#include <Main/PluginManager.h>
#include "../ScriptEngine/Main/Configs.h"

using namespace RegisterCommandHelper;
using namespace LL;

//static_assert(sizeof(CommandSelector<Player>) == 200);

class TeleportDimensionCommand : public Command {

    enum class DimensionType {
        OverWorld,
        Nether,
        TheEnd,
    } DimensionId;
    CommandSelector<Actor> Victim;
    CommandPosition CommandPos;
    bool Victim_isSet = false;
    bool CommandPos_isSet = false;

    Vec3 getTargetPos(CommandOrigin const& ori, Actor* actor) const {
        if (CommandPos_isSet)
            return CommandPos.getPosition(ori, {0, 0, 0});
        auto pos = actor->getPosition();
        Vec3 result = pos;
        int actorDimensionId = actor->getDimensionId();
        switch (DimensionId) {
            case TeleportDimensionCommand::DimensionType::OverWorld:
                if (actorDimensionId == 1)
                    result = {pos.x * 8, pos.y, pos.z * 8};
                break;
            case TeleportDimensionCommand::DimensionType::Nether:
                if (actorDimensionId != 1)
                    result = {pos.x / 8, pos.y, pos.z / 8};
                break;
            case TeleportDimensionCommand::DimensionType::TheEnd:
                if (actorDimensionId != 2)
                    result = {100, 50, 0};
                break;
            default:
                break;
        }
        return result;
    }

    bool teleportTarget(CommandOrigin const& ori, CommandOutput& output, Actor* actor) const {
        auto dim = VanillaDimensions::toString((int)DimensionId);
        auto pos = getTargetPos(ori, actor);
        actor->teleport(pos, (int)DimensionId);
        output.trSuccess("ll.cmd.tpdim.success", actor->getNameTag(), dim, pos.x, pos.y, pos.z);
        return true;
    }

    bool teleportTargets(CommandOrigin const& ori, CommandOutput& output, CommandSelectorResults<Actor>& actors) const {
        auto dim = VanillaDimensions::toString((int)DimensionId);
        std::string names;
        for (auto& actor : actors) {
            std::string actorName = actor->getNameTag();
            if (actorName.empty()) {
                actorName = actor->getTypeName();
            }
            names.append(", ").append(actorName);
            if (actor->teleport(getTargetPos(ori, actor), (int)DimensionId)) {
                output.success();
            }
        }
        if (output.getSuccessCount() == 0) {
            output.trError("ll.cmd.tpdim.error.noActorTeleported");
            return false;
        } else {
            std::string message = fmt::format("Teleported {} to {}", names.substr(2), dim);
            if (CommandPos_isSet) {
                auto pos = CommandPos.getPosition(ori, {0, 0, 0});
                message.append(fmt::format(" ({:2f}, {:2f}, {:2f})", pos.x, pos.y, pos.z));
            }
            output.addMessage(message);
            return true;
        }
    }

public:
    void execute(CommandOrigin const& ori, CommandOutput& output) const override {
        output.setLanguageCode(ori);
        if ((int)DimensionId < 0 || (int)DimensionId > 2) {
            output.trError("ll.cmd.tpdim.invalidDimid", (int)DimensionId);
            return;
        }
        if (Victim_isSet) {
            auto result = Victim.results(ori);
            if (result.empty())
                output.trError("ll.cmd.tpdim.error.noActorSpecified");
            else if (result.count() == 1)
                teleportTarget(ori, output, *result.begin());
            else
                teleportTargets(ori, output, result);
        } else {
            auto actor = ori.getEntity();
            if (!actor)
                output.trError("ll.cmd.tpdim.error.noActorSpecified");
            else
                teleportTarget(ori, output, actor);
        }
    }

    static void setup(CommandRegistry* registry) {
        registry->registerCommand(
            "tpdim", "Teleport to Dimension", CommandPermissionLevel::GameMasters,
            {(CommandFlagValue)0}, {(CommandFlagValue)0x80});
        registry->addEnum<DimensionType>("DimensionType",
                                         {
                                             {"overworld", DimensionType::OverWorld},
                                             {"o", DimensionType::OverWorld},
                                             {"nether", DimensionType::Nether},
                                             {"n", DimensionType::Nether},
                                             {"end", DimensionType::TheEnd},
                                             {"e", DimensionType::TheEnd},
                                         });
        auto dimensionTypeParam = makeMandatory<CommandParameterDataType::ENUM>(&TeleportDimensionCommand::DimensionId,
                                                                                "Dimension", "DimensionType");
        auto dimensionIdParam = makeMandatory((int TeleportDimensionCommand::*)&TeleportDimensionCommand::DimensionId,
                                              "DimensionId");
        auto victimParam = makeMandatory(&TeleportDimensionCommand::Victim, "victim",
                                         &TeleportDimensionCommand::Victim_isSet);
        auto positionParam = makeOptional(&TeleportDimensionCommand::CommandPos,
                                          "Position", &TeleportDimensionCommand::CommandPos_isSet);

        registry->registerOverload<TeleportDimensionCommand>(
            "tpdim", victimParam, dimensionTypeParam, positionParam);
        registry->registerOverload<TeleportDimensionCommand>(
            "tpdim", victimParam, dimensionIdParam, positionParam);
        // registry->registerOverload<TeleportDimensionCommand>(
        //     "tpdim", dimensionTypeParam, positionParam);
        registry->registerOverload<TeleportDimensionCommand>(
            "tpdim", dimensionIdParam, positionParam);
    }
};

void LLListPluginsCommand(CommandOutput& output) {
    auto plugins = LL::getAllPlugins();
    output.trSuccess("ll.cmd.listPlugin.overview", plugins.size());

    std::ostringstream oss;
    for (auto& [name, plugin] : plugins) {
        string pluginName = name;
        if (pluginName.find("§") == string::npos)
            pluginName = "§b" + pluginName;
        string desc = plugin->desc;
        if (desc.find("§") == string::npos)
            desc = "§7" + desc;

        auto fileName = UTF82String(std::filesystem::path(str2wstr(plugin->filePath)).filename().u8string());
        oss << fmt::format("- {} §a[v{}] §8({})\n  {}\n",
                           pluginName, plugin->version.toString(), fileName, desc);
    }
    output.success(oss.str() + '\n');
    output.trAddMessage("ll.cmd.listPlugin.tip");
}

void LLPluginInfoCommand(CommandOutput& output, const string& pluginName) {
    auto plugin = LL::getPlugin(pluginName);
    if (plugin) {
        std::map<std::string, std::string> outs;
        std::ostringstream oss;
        auto fn = UTF82String(std::filesystem::path(str2wstr(plugin->filePath)).filename().u8string());
        string pluginType = plugin->type == Plugin::PluginType::ScriptPlugin ? "Script Plugin" : "DLL Plugin";

        output.trAddMessage("ll.cmd.pluginInfo.title", pluginName);

        outs.emplace("Name", fmt::format("{} ({})", plugin->name, fn));
        outs.emplace("Description", plugin->desc);
        outs.emplace("Version", "v" + plugin->version.toString(true));
        outs.emplace("Type", pluginType);
        outs.emplace("File Path", plugin->filePath);
        outs.merge(plugin->others);
        size_t width = 10;
        for (auto& [k, _] : outs)
            width = std::max(width, k.length());
        for (auto& [k, v] : outs) {
            if (k != "PluginType" && k != "PluginFilePath")
                oss << "- §l" << std::setw(width) << std::left << k << "§r: " << v << std::endl;
        }
        auto text = oss.str();
        text.pop_back();
        output.success(text, {});
    } else {
        output.trError("ll.cmd.pluginInfo.error.pluginNotFound", pluginName);
    }
}

void LLVersionCommand(CommandOutput& output) {
    output.trSuccess("ll.cmd.version.msg", LL::getBdsVersion(), LL::getLoaderVersionString(), LL::getServerProtocolVersion());
}

void LLHelpCommand(CommandOutput& output) {
    output.trSuccess("ll.cmd.help.msg");
}

void LLLoadPluginCommand(CommandOutput& output, const string& path) {
    // if (!LL::isDebugMode())
    //     return;
    if (PluginManager::loadPlugin(path, true)) {
        output.trSuccess("ll.cmd.loadPlugin.success", path);
    } else {
        output.trError("ll.cmd.loadPlugin.fail", path);
    }
}

void LLUnloadPluginCommand(CommandOutput& output, const string& pluginName) {
    // if (!LL::isDebugMode())
    //     return;
    if (PluginManager::unloadPlugin(pluginName, true)) {
        output.trSuccess("ll.cmd.unloadPlugin.success", pluginName);
    } else {
        output.trError("ll.cmd.unloadPlugin.fail", pluginName);
    }
}

void LLReloadPluginCommand(CommandOutput& output, const string& pluginName, bool reloadAll) {
    // if (!LL::isDebugMode())
    //     return;
    if (!reloadAll) {
        if (PluginManager::reloadPlugin(pluginName, true)) {
            output.trSuccess("ll.cmd.reloadPlugin.success", pluginName);
        } else {
            output.trError("ll.cmd.reloadPlugin.fail", pluginName);
        }
    } else {
        int cnt = PluginManager::reloadAllPlugins(true);
        if (cnt > 0) {
            output.trSuccess("ll.cmd.reloadAllPlugins.success", cnt);
        } else {
            output.trError("ll.cmd.reloadAllPlugins.fail");
        }
    }
}

class LLCommand : public Command {

    enum class Operation {
        Version,
        List,
        Help,
        Load,
        Unload,
        Reload
    };

    Operation operation;
    bool hasUpgradeOption, hasPluginNameSet;
    CommandRawText pluginNameToDoOperation;

public:
    void execute(CommandOrigin const& ori, CommandOutput& output) const override {
        output.setLanguageCode(ori);
        std::string pluginName = "";
        if (hasPluginNameSet) {
            pluginName = pluginNameToDoOperation;
            if (pluginName.size() > 1 && pluginName[0] == '"' && pluginName[pluginName.size() - 1] == '"' && pluginName[pluginName.size() - 2] != '\\') {
                pluginName.erase(0, 1);
                pluginName.pop_back();
            }
        }
        switch (operation) {
            case Operation::Version:
                LLVersionCommand(output);
                break;
            case Operation::List:
                if (!hasPluginNameSet)
                    LLListPluginsCommand(output);
                else
                    LLPluginInfoCommand(output, pluginName);
                break;
            case Operation::Load:
                if (hasPluginNameSet)
                    LLLoadPluginCommand(output, pluginName);
                else
                    output.trError("ll.cmd.error.noPathSpecified");
                break;
            case Operation::Unload:
                if (hasPluginNameSet)
                    LLUnloadPluginCommand(output, pluginName);
                else
                    output.trError("ll.cmd.error.noNameSpecified");
                break;
            case Operation::Reload:
                if (hasPluginNameSet)
                    LLReloadPluginCommand(output, pluginName, false);
                else
                    LLReloadPluginCommand(output, "", true);
                break;
            case Operation::Help:
                LLHelpCommand(output);
                break;
            default:
                break;
        }
    }

    static void setup(CommandRegistry* registry) {
        // Register Cmd
        registry->registerCommand("ll", "LiteLoaderBDS plugin operations",
                                  CommandPermissionLevel::Console, {(CommandFlagValue)0}, {(CommandFlagValue)0x80});

        // Register softenum
        vector<string> pluginList;
        for (auto& [name, p] : LL::getAllPlugins()) {
            pluginList.push_back(name);
        }
        registry->addSoftEnum("PluginName", pluginList);

        // ll version & help
        registry->addEnum<Operation>("Operation_Common", {{"version", Operation::Version},
                                                          {"help", Operation::Help}});
        registry->registerOverload<LLCommand>(
            "ll",
            makeMandatory<CommandParameterDataType::ENUM>(&LLCommand::operation, "Operation", "Operation_Common").addOptions((CommandParameterOption)1));

        // ll load
        registry->addEnum<Operation>("Operation_FreeFilePath", {
                                                                   {"load", Operation::Load},
                                                               });
        registry->registerOverload<LLCommand>(
            "ll",
            makeMandatory<CommandParameterDataType::ENUM>(&LLCommand::operation, "Operation", "Operation_FreeFilePath").addOptions((CommandParameterOption)1),
            makeMandatory<CommandParameterDataType::NORMAL>(&LLCommand::pluginNameToDoOperation, "pluginPath", nullptr, &LLCommand::hasPluginNameSet));

        // ll unload
        registry->addEnum<Operation>("Operation_MustPluginName", {
                                                                     {"unload", Operation::Unload},
                                                                 });
        registry->registerOverload<LLCommand>(
            "ll",
            makeMandatory<CommandParameterDataType::ENUM>(&LLCommand::operation, "Operation", "Operation_MustPluginName").addOptions((CommandParameterOption)1),
            makeMandatory<CommandParameterDataType::SOFT_ENUM>((std::string LLCommand::*)&LLCommand::pluginNameToDoOperation, "pluginName", "PluginName", &LLCommand::hasPluginNameSet));

        // ll list & reload
        registry->addEnum<Operation>("Operation_OptionalPluginName", {
                                                                         {"list", Operation::List},
                                                                         {"plugins", Operation::List},
                                                                         {"reload", Operation::Reload},
                                                                     });
        registry->registerOverload<LLCommand>(
            "ll",
            makeMandatory<CommandParameterDataType::ENUM>(&LLCommand::operation, "Operation", "Operation_OptionalPluginName").addOptions((CommandParameterOption)1),
            makeOptional<CommandParameterDataType::SOFT_ENUM>((std::string LLCommand::*)&LLCommand::pluginNameToDoOperation, "pluginName", "PluginName", &LLCommand::hasPluginNameSet));
    }
};

class VersionCommand : public Command {

public:
    void execute(CommandOrigin const& ori, CommandOutput& output) const override {
        output.setLanguageCode(ori);
#ifdef DEBUG
        Logger("CommandOrigin").warn(ori.serialize().toSNBT());
#endif // DEBUG
        LLVersionCommand(output);
    }

    static void setup(CommandRegistry* registry) {
        registry->registerCommand("version", "Get the version of this server",
                                  CommandPermissionLevel::GameMasters, {(CommandFlagValue)0}, {(CommandFlagValue)0x80});
        registry->registerOverload<VersionCommand>("version");
    }
};

void RegisterCommands() {
    Event::RegCmdEvent::subscribe([](Event::RegCmdEvent ev) { // Register commands
        LLCommand::setup(ev.mCommandRegistry);
        VersionCommand::setup(ev.mCommandRegistry);
        if (LL::globalConfig.enableTpdimCommand) {
            TeleportDimensionCommand::setup(ev.mCommandRegistry);
        }
        return true;
    });
}