#include "Global.h"
#include "mc/platform/UUID.h"
#include <regex>

ActorUniqueID parseScriptUniqueID(std::string const& uniqueId) {
    return string_utils::isInteger(uniqueId) ? ActorUniqueID(std::stoll(uniqueId)) : ActorUniqueID::INVALID_ID();
}

void Export_Compatibility_API() {
    RemoteCall::exportAs("GMLIB_API", "unregisterRecipe", [](std::string const& id) -> bool {
        return CustomRecipeRegistry::getInstance().unregisterRecipe(id, true);
    });
    RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string const& path) -> void {
        AddonsLoader::addCustomPackPath(path);
    });
    RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> double {
        return GMLevel::getInstance().transform(
                                         [](GMLevel& level) -> double { return level.getServerMspt(); }
        ).value_or(0.0);
    });
    RemoteCall::exportAs("GMLIB_API", "getServerCurrentTps", []() -> float {
        return GMLevel::getInstance().transform(
                                         [](GMLevel& level) -> float { return level.getServerCurrentTps(); }
        ).value_or(0.0);
    });
    RemoteCall::exportAs("GMLIB_API", "getServerAverageTps", []() -> double {
        return GMLevel::getInstance().transform(
                                         [](GMLevel& level) -> double { return level.getServerAverageTps(); }
        ).value_or(0.0);
    });
    RemoteCall::exportAs("GMLIB_API", "getAllPlayerUuids", []() -> std::vector<std::string> {
        std::vector<std::string> result;
        for (auto& player : OfflinePlayer::getAllOfflinePlayers()) {
            result.push_back(player.getUUID().asString());
        }
        return result;
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string const& uuid) -> std::unique_ptr<CompoundTag> {
        if (auto player = OfflinePlayer::fromUuid(mce::UUID::fromString(uuid))) {
            return std::make_unique<CompoundTag>(*player->getNbt());
        }
        return nullptr;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setPlayerNbt",
        [](std::string const& uuid, CompoundTag* nbt, bool forceCreate) -> bool {
            auto player = OfflinePlayer::fromUuid(mce::UUID::fromString(uuid));
            if (player&&player->hasNbt()) return player->setNbt(*nbt);
            return forceCreate ? OfflinePlayer::createNewPlayerNbt(mce::UUID::fromString(uuid), *nbt).has_value()
                               : false;
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "setPlayerNbtTags",
        [](std::string const& uuid, CompoundTag* nbt, std::vector<std::string> tags) -> bool {
            if (auto player = OfflinePlayer::fromUuid(mce::UUID::fromString(uuid))) {
                auto nbt2 = *player->getNbt();
                GMCompoundTag::writeNbtTags(nbt2, *nbt, tags);
                return player->setNbt(nbt2);
            }
            return false;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "deletePlayerNbt", [](std::string const& uuid) -> bool {
        return OfflinePlayer::deletePlayerNbt(mce::UUID::fromString(uuid));
    });
    RemoteCall::exportAs("GMLIB_API", "getAllExperiments", []() -> std::vector<int> {
        return {36, 45, 38, 48, 47, 53, 56, 45, 40};
    });
    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslateKey", [](int id) -> std::string {
        static std::unordered_map<int, std::string> mMap = {
            {36, "createWorldScreen.experimentalbiomes"                    },
            {45, "createWorldScreen.experimentalCreatorFeatures"           },
            {38, "createWorldScreen.experimentalGameTest"                  },
            {48, "createWorldScreen.experimentalThirdPersonCameras"        },
            {47, "createWorldScreen.experimentalFocusTargetCamera"         },
            {53, "createWorldScreen.experimentalVillagerTradesRebalance"   },
            {56, "createWorldScreen.experimentalDataDrivenJigsawStructures"},
            {45, "createWorldScreen.experimentalCameraAimAssist"           },
            {40, "createWorldScreen.experimentalY2025Drop1"                }
        };
        return mMap.contains(id) ? mMap[id] : "";
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "createFloatingText",
        [](std::pair<Vec3, int> pos, std::string const& text, bool papi) -> uint64 {
            return FloatingTextManager::getInstance()
                .addStatic(text, pos.first, pos.second, papi)
                .lock()
                ->getRuntimeID();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](uint64 id, std::string const& text) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->setText(text);
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](uint64 id) -> bool {
        return FloatingTextManager::getInstance().remove(id);
    });
    RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](uint64 id, Player* pl) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->sendTo((GMPlayer&)*pl);
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](uint64 id) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->sendToClients();
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](uint64 id, Player* pl) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->removeFrom((GMPlayer&)*pl);
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](uint64 id) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->removeFromClients();
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](uint64 id, Player* pl) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->update((GMPlayer&)*pl);
            return true;
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](uint64 id) -> bool {
        if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) {
            ft.lock()->updateClients();
            return true;
        }
        return false;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "isVersionMatched",
        [](std::uint16_t a, std::uint16_t b, std::uint16_t c) -> bool {
            return LIB_VERSION >= ll::data::Version(a, b, c, "", "");
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getVersion_LRCA", []() -> std::string { return LIB_VERSION.to_string(); });
    RemoteCall::exportAs("GMLIB_API", "getVersion_GMLIB", []() -> std::string {
        return GMLIB_VERSION_TO_STRING(GMLIB_VERSION_MAJOR) "." GMLIB_VERSION_TO_STRING(
            GMLIB_VERSION_MINOR
        ) "." GMLIB_VERSION_TO_STRING(GMLIB_VERSION_PATCH);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "resourcePackDefaultTranslate",
        [](std::string const& key, std::vector<std::string> params) -> std::string { return I18nAPI::get(key, params); }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "resourcePackTranslate",
        [](std::string const& key, std::vector<std::string> params, std::string const& code) -> std::string {
            return I18nAPI::get(key, params, code);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string const& code) -> void {
        if (GMLevel::getInstance()) {
            I18nAPI::chooseLanguage(code);
        }
    });
    RemoteCall::exportAs("GMLIB_API", "getResourcePackI18nLanguage", []() -> std::string {
        return GMLevel::getInstance().has_value() ? I18nAPI::getCurrentLanguageCode() : "unknown";
    });
    RemoteCall::exportAs("GMLIB_API", "getSupportedLanguages", []() -> std::vector<std::string> {
        return GMLevel::getInstance() ? I18nAPI::getSupportedLanguageCodes() : std::vector<std::string>();
    });
    RemoteCall::exportAs("GMLIB_API", "loadLanguage", [](std::string const& code, std::string const& lang) -> void {
        if (GMLevel::getInstance()) {
            I18nAPI::loadLanguage(code, lang);
        }
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "updateOrCreateLanguageFile",
        [](std::string const&                           code,
           std::unordered_map<std::string, std::string> lang,
           std::string const&                           path) -> void {
            if (GMLevel::getInstance()) {
                I18nAPI::updateOrCreateLanguageFile(path, code, lang);
            }
        }
    );
    RemoteCall::exportAs("GMLIB_API", "loadLanguagePath", [](std::string const& path) -> void {
        if (GMLevel::getInstance()) {
            I18nAPI::loadLanguagesFromDirectory(path);
        }
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerPosition", [](std::string const& uuid) -> std::pair<BlockPos, int> {
        if (auto player = OfflinePlayer::fromUuid(mce::UUID::fromString(uuid))) {
            if (auto pos = player->getPlayerPosition()) {
                return *pos;
            }
        }
        return {
            {0, 0, 0},
            0
        };
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setPlayerPosition",
        [](std::string const& uuid, std::pair<BlockPos, int> pos) -> bool {
            if (auto player = OfflinePlayer::fromUuid(mce::UUID::fromString(uuid))) {
                return player->setPosition(pos.first, pos.second);
            }
            return false;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "playerHasScore", [](std::string const& uuid, std::string const& obj) -> bool {
        return GMScoreboard::getInstance()->getPlayerScore(obj, mce::UUID::fromString(uuid)).has_value();
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerScore", [](std::string const& uuid, std::string const& obj) -> int {
        return GMScoreboard::getInstance()->getPlayerScore(obj, mce::UUID::fromString(uuid)).value_or(0);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "addPlayerScore",
        [](std::string const& uuid, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()
                ->setPlayerScore(obj, mce::UUID::fromString(uuid), value, PlayerScoreSetFunction::Add)
                .has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "reducePlayerScore",
        [](std::string const& uuid, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()
                ->setPlayerScore(obj, mce::UUID::fromString(uuid), value, PlayerScoreSetFunction::Subtract)
                .has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "setPlayerScore",
        [](std::string const& uuid, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()->setPlayerScore(obj, mce::UUID::fromString(uuid), value).has_value();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "resetPlayerScore", [](std::string const& uuid, std::string const& obj) -> bool {
        return GMScoreboard::getInstance()->resetPlayerScore(obj, mce::UUID::fromString(uuid));
    });
    RemoteCall::exportAs("GMLIB_API", "resetPlayerScores", [](std::string const& uuid) -> bool {
        return GMScoreboard::getInstance()->resetPlayerScore(mce::UUID::fromString(uuid));
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "entityHasScore",
        [](std::string const& uniqueId, std::string const& obj) -> bool {
            return GMScoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).has_value();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getEntityScore", [](std::string const& uniqueId, std::string const& obj) -> int {
        return GMScoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).value_or(0);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "addEntityScore",
        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()
                ->setScore(obj, parseScriptUniqueID(uniqueId), value, PlayerScoreSetFunction::Add)
                .has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "reduceEntityScore",
        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()
                ->setScore(obj, parseScriptUniqueID(uniqueId), value, PlayerScoreSetFunction::Subtract)
                .has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "setEntityScore",
        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()->setScore(obj, parseScriptUniqueID(uniqueId), value).has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "resetEntityScore",
        [](std::string const& uniqueId, std::string const& obj) -> bool {
            return GMScoreboard::getInstance()->resetScore(obj, parseScriptUniqueID(uniqueId));
        }
    );
    RemoteCall::exportAs("GMLIB_API", "resetEntityScores", [](std::string const& uniqueId) -> bool {
        return GMScoreboard::getInstance()->resetScore(parseScriptUniqueID(uniqueId));
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "fakePlayerHasScore",
        [](std::string const& name, std::string const& obj) -> bool {
            return GMScoreboard::getInstance()->getScore(obj, name).has_value();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getFakePlayerScore", [](std::string const& name, std::string const& obj) -> int {
        return GMScoreboard::getInstance()->getScore(obj, name).value_or(0);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "addFakePlayerScore",
        [](std::string const& name, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Add).has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "reduceFakePlayerScore",
        [](std::string const& name, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()
                ->setScore(obj, name, value, PlayerScoreSetFunction::Subtract)
                .has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "setFakePlayerScore",
        [](std::string const& name, std::string const& obj, int value) -> bool {
            return GMScoreboard::getInstance()->setScore(obj, name, value).has_value();
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "resetFakePlayerScore",
        [](std::string const& name, std::string const& obj) -> bool {
            return GMScoreboard::getInstance()->resetScore(obj, name);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "resetFakePlayerScores", [](std::string const& name) -> bool {
        return GMScoreboard::getInstance()->resetScore(name);
    });
    RemoteCall::exportAs("GMLIB_API", "addObjective", [](std::string const& obj) -> bool {
        return GMScoreboard::getInstance()->addObjective(obj).has_value();
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "addObjectiveWithDisplayName",
        [](std::string const& obj, std::string const& displayName) -> bool {
            return GMScoreboard::getInstance()->addObjective(obj, displayName).has_value();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getDisplayName", [](std::string const& obj) -> std::string {
        return GMScoreboard::getInstance()->getObjectiveDisplayName(obj).value_or("");
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setDisplayName",
        [](std::string const& obj, std::string const& displayName) -> bool {
            return GMScoreboard::getInstance()->setObjectiveDisplayName(obj, displayName);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "removeObjective", [](std::string const& obj) -> bool {
        return GMScoreboard::getInstance()->removeObjective(obj);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setDisplayObjective",
        [](std::string const& obj, std::string const& slot, int order) -> void {
            return GMScoreboard::getInstance()->setObjectiveDisplay(obj, slot, (ObjectiveSortOrder)order);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "clearDisplayObjective", [](std::string const& slot) -> void {
        return GMScoreboard::getInstance()->clearObjectiveDisplay(slot);
    });
    RemoteCall::exportAs("GMLIB_API", "getAllObjectives", []() -> std::vector<std::string> {
        std::vector<std::string> result;
        for (auto& obj : GMScoreboard::getInstance()->getObjectives()) {
            result.push_back(obj->mName);
        }
        return result;
    });
    RemoteCall::exportAs("GMLIB_API", "getAllScoreboardPlayers", []() -> std::vector<std::string> {
        std::vector<std::string> result;
        for (auto& player : GMScoreboard::getInstance()->getAllPlayers()) {
            result.push_back(player.getUUID().asString());
        }
        return result;
    });
    RemoteCall::exportAs("GMLIB_API", "getAllScoreboardFakePlayers", []() -> std::vector<std::string> {
        std::vector<std::string> result;
        for (auto& name : GMScoreboard::getInstance()->getAllFakePlayers()) {
            result.push_back(name);
        }
        return result;
    });
    RemoteCall::exportAs("GMLIB_API", "getAllScoreboardEntities", []() -> std::vector<std::string> {
        std::vector<std::string> result;
        for (auto& uniqueId : GMScoreboard::getInstance()->getAllEntities()) {
            result.push_back(std::to_string(uniqueId.rawID));
        }
        return result;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "getAllTrackedTargets",
        []() -> std::vector<std::unordered_map<std::string, std::string>> {
            std::vector<std::unordered_map<std::string, std::string>> result;
            for (auto& player : GMScoreboard::getInstance()->getAllPlayers()) {
                result.push_back({
                    {"Type", "Player"                   },
                    {"Uuid", player.getUUID().asString()}
                });
            }
            for (auto& name : GMScoreboard::getInstance()->getAllFakePlayers()) {
                result.push_back({
                    {"Type", "FakePlayer"},
                    {"Name", name        }
                });
            }
            for (auto& uniqueId : GMScoreboard::getInstance()->getAllEntities()) {
                result.push_back({
                    {"Type",     "Entity"                      },
                    {"UniqueId", std::to_string(uniqueId.rawID)}
                });
            }
            return result;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUuid", [](std::string const& uuid) -> Player* {
        return ll::service::getLevel()->getPlayer(mce::UUID::fromString(uuid));
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUniqueId", [](std::string const& uniqueId) -> Actor* {
        return ll::service::getLevel()->getPlayer(parseScriptUniqueID(uniqueId));
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityFromUniqueId", [](std::string const& uniqueId) -> Actor* {
        return ll::service::getLevel()->fetchEntity(parseScriptUniqueID(uniqueId), false);
    });
    RemoteCall::exportAs("GMLIB_API", "getWorldSpawn", []() -> std::pair<BlockPos, int> {
        return {GMLevel::getInstance()->getLevelData().getSpawnPos(), 0};
    });
    RemoteCall::exportAs("GMLIB_API", "setWorldSpawn", [](std::pair<BlockPos, int> pos) -> bool {
        if (pos.second != 0) return false;
        GMLevel::getInstance()->getLevelData().setSpawnPos(pos.first);
        auto pkt           = SetSpawnPositionPacket();
        pkt.mSpawnBlockPos = NetworkBlockPosition(pos.first);
        pkt.mDimensionType = 0;
        pkt.mSpawnPosType  = SpawnPositionType::WorldSpawn;
        pkt.sendToClients();
        return true;
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerSpawnPoint", [](Player* pl) -> std::pair<BlockPos, int> {
        return {pl->mPlayerRespawnPoint->mSpawnBlockPos, pl->mPlayerRespawnPoint->mDimension.get()};
    });
    RemoteCall::exportAs("GMLIB_API", "setPlayerSpawnPoint", [](Player* pl, std::pair<BlockPos, int> pos) -> void {
        pl->setRespawnPosition(pos.first, pos.second);
    });
    RemoteCall::exportAs("GMLIB_API", "clearPlayerSpawnPoint", [](Player* pl) -> void {
        pl->mPlayerRespawnPoint->mSpawnBlockPos = BlockPos::MIN();
        pl->mPlayerRespawnPoint->mDimension     = VanillaDimensions::Undefined();
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "mergePatchJson",
        [](std::string const& oldJson, std::string const& patchJson) -> std::string {
            auto oldData = nlohmann::ordered_json::parse(oldJson);
            auto newData = nlohmann::ordered_json::parse(patchJson);
            oldData.merge_patch(newData);
            return oldData.dump();
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getXuidByUuid", [](std::string const& uuid) -> std::string {
        if (auto uce = UserCache::getInstance()->from(mce::UUID::fromString(uuid))) {
            return uce->mXuid;
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getXuidByName", [](std::string const& name) -> std::string {
        if (auto uce = UserCache::getInstance()->from(name, UserCache::QueryType::Name)) {
            return uce->mXuid;
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getNameByUuid", [](std::string const& uuid) -> std::string {
        if (auto uce = UserCache::getInstance()->from(mce::UUID::fromString(uuid))) {
            return uce->mName;
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getNameByXuid", [](std::string const& xuid) -> std::string {
        if (auto uce = UserCache::getInstance()->from(xuid, UserCache::QueryType::Xuid)) {
            return uce->mName;
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getUuidByXuid", [](std::string const& xuid) -> std::string {
        if (auto uce = UserCache::getInstance()->from(xuid, UserCache::QueryType::Xuid)) {
            return uce->mUuid.asString();
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string {
        if (auto uce = UserCache::getInstance()->from(name, UserCache::QueryType::Name)) {
            return uce->mUuid.asString();
        }
        return "";
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "getAllPlayerInfo",
        []() -> std::vector<std::unordered_map<std::string, std::string>> {
            std::vector<std::unordered_map<std::string, std::string>> result;
            for (auto entry : UserCache::getInstance()->entries()) {
                result.push_back({
                    {"Name", entry.mName           },
                    {"Xuid", entry.mXuid           },
                    {"Uuid", entry.mUuid.asString()}
                });
            }
            return result;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getBlockRuntimeId", [](std::string const& blockName, short legacyData) -> uint {
        return Block::tryGetFromRegistry(blockName, legacyData)
            .transform([](const Block& block) -> uint { return block.mNetworkId; })
            .value_or(0);
    });
    RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKey", [](Block const* block) -> std::string {
        return block->getLegacyBlock().mDescriptionId.get() + ".name";
    });
    RemoteCall::exportAs("GMLIB_API", "getItemTranslateKey", [](ItemStack* item) -> std::string {
        return item->getDescriptionId();
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityTranslateKey", [](Actor* entity) -> std::string {
        return entity->getEntityLocNameString();
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "readNbtFromFile",
        [](std::string const& path, bool isBinary) -> std::unique_ptr<CompoundTag> {
            if (auto nbt = GMCompoundTag::readFromFile(path, isBinary)) {
                return std::make_unique<CompoundTag>(nbt.value());
            }
            return nullptr;
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "saveNbtToFile",
        [](std::string const& path, CompoundTag* nbt, bool isBinary) -> bool {
            return GMCompoundTag::saveToFile(path, *nbt, isBinary);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getBlockDestroySpeed", [](Block const* block) -> float {
        return block->mDirectData->mDestroySpeed;
    });
    RemoteCall::exportAs("GMLIB_API", "getDestroyBlockSpeed", [](ItemStack const* item, Block const* block) -> float {
        return item->getItem()->getDestroySpeed(*item, *block);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "playerDestroyBlock",
        [](Block const* block, std::pair<BlockPos, int> pos, Player* player) -> void {
            return block->playerDestroy(*player, pos.first);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "itemCanDestroyBlock", [](ItemStack const* item, Block const* block) -> bool {
        return std::ranges::any_of(item->mCanDestroy, [block](BlockLegacy const* blockLegacy) {
            return block->getTypeName() == blockLegacy->getTypeName();
        });
    });
    RemoteCall::exportAs("GMLIB_API", "itemCanDestroyInCreative", [](ItemStack const* item) -> bool {
        if (auto itemDef = item->getItem()) {
            return itemDef->canDestroyInCreative();
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "itemCanDestroySpecial", [](ItemStack const* item, Block const* block) -> bool {
        return item->getItem()->canDestroySpecial(*block);
    });
    RemoteCall::exportAs("GMLIB_API", "blockCanDropWithAnyTool", [](Block const* block) -> bool {
        return !block->getLegacyBlock().mRequiresCorrectToolForDrops;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "blockPlayerWillDestroy",
        [](Block const* block, Player* player, std::pair<BlockPos, int> pos) -> bool {
            return block->getLegacyBlock().playerWillDestroy(*player, pos.first, *block);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "playerAttack", [](Player* player, Actor* entity) -> bool {
        return player->attack(*entity, SharedTypes::Legacy::ActorDamageCause::EntityAttack);
    });
    RemoteCall::exportAs("GMLIB_API", "playerPullInEntity", [](Player* player, Actor* entity) -> void {
        if (auto component = player->getEntityContext().tryGetComponent<RideableComponent>()) {
            component->pullInEntity(*player, *entity);
        }
    });
    RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKeyFromName", [](std::string const& blockName) -> std::string {
        return Block::tryGetFromRegistry(blockName)
            .transform([](const Block& block) -> std::string { return block.buildDescriptionName(); })
            .value_or("tile.unknown.name");
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "getBlockLightEmission",
        [](std::string const& blockName, short legacyData) -> char {
            return Block::tryGetFromRegistry(blockName)
                .transform([](const Block& block) -> char { return block.mDirectData->mLightEmission->mValue; })
                .value_or(-1);
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "getGameRules",
        []() -> std::vector<std::unordered_map<std::string, std::string>> {
            std::vector<std::unordered_map<std::string, std::string>> result;
            for (auto& gameRule : ll::service::getLevel()->getGameRules().mGameRules.get()) {
                switch (gameRule.mType) {
                case GameRule::Type::Bool:
                    result.push_back({
                        {"Name",  gameRule.mName                          },
                        {"Type",  "Bool"                                  },
                        {"Value", std::to_string(gameRule.mValue->boolVal)}
                    });
                    break;
                case GameRule::Type::Float:
                    result.push_back({
                        {"Name",  gameRule.mName                           },
                        {"Type",  "Float"                                  },
                        {"Value", std::to_string(gameRule.mValue->floatVal)}
                    });
                    break;
                case GameRule::Type::Int:
                    result.push_back({
                        {"Name",  gameRule.mName                         },
                        {"Type",  "Int"                                  },
                        {"Value", std::to_string(gameRule.mValue->intVal)}
                    });
                    break;
                case GameRule::Type::Invalid:
                    break;
                }
            }
            return result;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getEnchantTypeNameFromId", [](size_t id) -> std::string {
        if (id < Enchant::mEnchants().size()) {
            return Enchant::mEnchants()[id]->mStringId->getString();
        }
        return "";
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "applyEnchant",
        [](ItemStack* item, std::string const& typeName, int level, bool allowNonVanilla) -> bool {
            return EnchantUtils::applyEnchant(
                *item,
                Enchant::mEnchantNameToType()[HashedString(typeName)],
                level,
                allowNonVanilla
            );
        }
    );
    RemoteCall::exportAs("GMLIB_API", "removeEnchants", [](ItemStack* item) -> void { item->removeEnchants(); });
    RemoteCall::exportAs("GMLIB_API", "hasEnchant", [](ItemStack* item, std::string const& typeName) -> bool {
        return EnchantUtils::hasEnchant(Enchant::mEnchantNameToType()[HashedString(typeName)], *item);
    });
    RemoteCall::exportAs("GMLIB_API", "getEnchantLevel", [](ItemStack* item, std::string const& typeName) -> int {
        return EnchantUtils::getEnchantLevel(Enchant::mEnchantNameToType()[HashedString(typeName)], *item);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "getEnchantNameAndLevel",
        [](std::string const& typeName, int level) -> std::string {
            return EnchantUtils::getEnchantNameAndLevel(Enchant::mEnchantNameToType()[HashedString(typeName)], level);
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "dropPlayerItem",
        [](Player* player, ItemStack const* item, bool randomly) -> bool { return player->drop(*item, randomly); }
    );
    RemoteCall::exportAs("GMLIB_API", "getPlayerRuntimeId", [](Player* player) -> uint64 {
        return player->getRuntimeID().rawID;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityRuntimeId", [](Actor* entity) -> uint64 {
        return entity->getRuntimeID().rawID;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityNameTag", [](Actor* entity) -> std::string {
        return entity->getNameTag();
    });
    RemoteCall::exportAs("GMLIB_API", "ItemisUnbreakable", [](ItemStack const* item) -> bool {
        return ((GMItemStack*)item)->isUnbreakable();
    });
    RemoteCall::exportAs("GMLIB_API", "setItemUnbreakable", [](ItemStack const* item, bool value) -> void {
        ((GMItemStack*)item)->setUnbreakable(value);
    });
    RemoteCall::exportAs("GMLIB_API", "getItemShouldKeepOnDeath", [](ItemStack const* item) -> bool {
        return ((GMItemStack*)item)->getShouldKeepOnDeath();
    });
    RemoteCall::exportAs("GMLIB_API", "setItemShouldKeepOnDeath", [](ItemStack const* item, bool value) -> void {
        auto nbt = ((GMItemStack*)item)->getNbt();
        if (value) {
            (*nbt)["tag"]["minecraft:keep_on_death"] = true;
        } else {
            if (nbt->contains("tag") && (*nbt)["tag"].contains("minecraft:keep_on_death")) {
                (*nbt)["tag"].get<CompoundTag>().erase("minecraft:keep_on_death");
            }
        }
        ((GMItemStack*)item)->setNbt(*nbt);
    });
    RemoteCall::exportAs("GMLIB_API", "getItemLockMode", [](ItemStack const* item) -> int {
        return (int)((GMItemStack*)item)->getItemLockMode();
    });
    RemoteCall::exportAs("GMLIB_API", "setItemLockMode", [](ItemStack const* item, int value) -> void {
        ((GMItemStack*)item)->setItemLockMode((ItemLockMode)value);
    });
    RemoteCall::exportAs("GMLIB_API", "getItemRepairCost", [](ItemStack const* item) -> int {
        return item->getBaseRepairCost();
    });
    RemoteCall::exportAs("GMLIB_API", "setItemRepairCost", [](ItemStack* item, int cost) -> void {
        (*item).setRepairCost(cost);
    });
    RemoteCall::exportAs("GMLIB_API", "getItemCanDestroy", [](ItemStack const* item) -> std::vector<std::string> {
        std::vector<std::string> result = {};
        for (auto& block : ((GMItemStack*)item)->mCanDestroy) {
            result.push_back(block->getTypeName());
        }
        return result;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setItemCanDestroy",
        [](ItemStack const* item, std::vector<std::string> blocks) -> void {
            std::vector<const BlockLegacy*> data;
            for (auto& name : blocks) {
                if (auto block = BlockLegacy::tryGetFromRegistry(name)) {
                    data.push_back(block.as_ptr());
                }
            }
            ((GMItemStack*)item)->mCanDestroy = data;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getItemCanPlaceOn", [](ItemStack const* item) -> std::vector<std::string> {
        std::vector<std::string> result = {};
        for (auto& block : ((GMItemStack*)item)->mCanPlaceOn) {
            result.push_back(block->getTypeName());
        }
        return result;
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "setItemCanPlaceOn",
        [](ItemStack const* item, std::vector<std::string> blocks) -> void {
            std::vector<const BlockLegacy*> data;
            for (auto& name : blocks) {
                if (auto block = BlockLegacy::tryGetFromRegistry(name)) {
                    data.push_back(block.as_ptr());
                }
            }
            ((GMItemStack*)item)->mCanPlaceOn = data;
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getPlayerHungry", [](Player* player) -> float {
        return player->getMutableAttribute(Player::HUNGER()).mInstance->mCurrentValue;
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerArmorCoverPercentage", [](Player* player) -> float {
        return player->getArmorCoverPercentage();
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerArmorValue", [](Player* player) -> int {
        return player->getArmorValue();
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityOwnerUniqueId", [](Actor* entity) -> int64 {
        return entity->getOwnerId().rawID;
    });
    RemoteCall::exportAs("GMLIB_API", "getItemCategoryName", [](ItemStack const* item) -> std::string {
        if (auto item2 = item->mItem) {
            return item2->buildCategoryDescriptionName();
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "getItemCustomName", [](ItemStack const* item) -> std::string {
        return item->getCustomName();
    });
    RemoteCall::exportAs("GMLIB_API", "getItemEffecName", [](ItemStack const* item) -> std::string {
        if (auto item2 = item->mItem) {
            return item2->buildEffectDescriptionName(*item);
        }
        return "";
    });
    RemoteCall::exportAs("GMLIB_API", "itemIsFood", [](ItemStack const* item) -> bool {
        if (auto itemDef = item->getItem()) {
            return itemDef->isFood();
        }
        return false;
    });
    RemoteCall::exportAs("GMLIB_API", "setPlayerUIItem", [](Player* player, int slot, ItemStack const* item) -> void {
        player->setPlayerUIItem((PlayerUISlot)slot, *item, false);
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerUIItem", [](Player* player, int slot) -> ItemStack const* {
        return &player->mPlayerUIContainer->getItem(slot);
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "sendInventorySlotPacket",
        [](Player* player, int containerId, int slot, ItemStack const* item) -> void {
            InventorySlotPacket((ContainerID)containerId, slot, *item).sendTo(*player);
        }
    );
    RemoteCall::exportAs("GMLIB_API", "getContainerType", [](Container* container) -> std::string {
        return magic_enum::enum_name(container->mContainerType).data();
    });
    RemoteCall::exportAs("GMLIB_API", "hasPlayerNbt", [](std::string const& uuid) -> bool {
        return OfflinePlayer::fromUuid(mce::UUID::fromString(uuid))
            .transform([&](auto&& player) -> bool { return player.hasNbt(); })
            .value_or(false);
    });
    RemoteCall::exportAs("GMLIB_API", "getItemMaxCount", [](ItemStack const* item) -> int {
        return item->getMaxStackSize();
    });
    RemoteCall::exportAs("GMLIB_API", "entityHasFamily", [](Actor* entity, std::string const& family) -> bool {
        return entity->hasFamily(HashedString(family));
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerDestroyBlockProgress", [](Player* player, Block const* block) -> float {
        return player->getDestroyProgress(*block);
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectVisible", [](Actor* entity, int effectId) -> bool {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mEffectVisible;
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectDuration", [](Actor* entity, int effectId) -> int {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mDuration->mValue;
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationEasy", [](Actor* entity, int effectId) -> int {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mDurationEasy->transform([](auto&& duration) -> int { return duration.mValue; }).value_or(0);
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationHard", [](Actor* entity, int effectId) -> int {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mDurationHard->transform([](auto&& duration) -> int { return duration.mValue; }).value_or(0);
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationNormal", [](Actor* entity, int effectId) -> int {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mDurationNormal->transform(
                                              [](auto&& duration) -> int { return duration.mValue; }
            ).value_or(0);
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectAmplifier", [](Actor* entity, int effectId) -> int {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mAmplifier;
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityEffectAmbient", [](Actor* entity, int effectId) -> bool {
        if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false;
        if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) {
            return effect->mAmbient;
        }
        return 0;
    });
    RemoteCall::exportAs("GMLIB_API", "entityHasEffect", [](Actor* entity, int effectId) -> bool {
        return effectId > 0x24 ? false : entity->hasEffect(*MobEffect::mMobEffects()[effectId]);
    });
    RemoteCall::exportAs("GMLIB_API", "getGameDifficulty", []() -> int {
        return ll::service::getLevel().transform(
                                          [](Level& level) -> int { return (int)level.getDifficulty(); }
        ).value_or(-1);
    });
    RemoteCall::exportAs("GMLIB_API", "setGameDifficulty", [](int difficulty) -> void {
        if (auto level = ll::service::getLevel()) {
            level->setDifficulty((SharedTypes::Legacy::Difficulty)difficulty);
        }
    });
    RemoteCall::exportAs("GMLIB_API", "getDefaultGameMode", []() -> int {
        return ll::service::getLevel().transform(
                                          [](Level& level) -> int { return (int)level.getDefaultGameType(); }
        ).value_or(-1);
    });
    RemoteCall::exportAs("GMLIB_API", "setDefaultGameMode", [](int gameMode) -> void {
        if (auto level = ll::service::getLevel()) {
            level->setDefaultGameType((GameType)gameMode);
        }
    });
    RemoteCall::exportAs(
        "GMLIB_API",
        "registerCustomShapelessRecipe",
        [](std::string const& recipe_id, std::vector<std::string> ingredients, ItemStack* result) -> void {
            if (!GMLevel::getInstance().has_value()) return;
            std::vector<ICustomRecipe::Ingredient> types;
            for (auto& ing : ingredients) {
                types.push_back(ICustomRecipe::Ingredient{ing});
            }
            CustomRecipeRegistry::getInstance().registerShapelessRecipe(
                recipe_id,
                types,
                ItemInstance(*result->getItem(), result->mCount, result->mAuxValue, result->mUserData.get())
            );
        }
    );
    RemoteCall::exportAs(
        "GMLIB_API",
        "registerCustomShapedRecipe",
        [](std::string const&       recipe_id,
           std::vector<std::string> shape,
           std::vector<std::string> ingredients,
           ItemStack*               result) -> void {
            if (!GMLevel::getInstance().has_value()) return;
            std::vector<Recipes::Type> types;
            char                       rt = 'A';
            for (auto& ing : ingredients) {
                auto ingredient = RecipeIngredient{ing, 0, 1};
                types.push_back(Recipes::Type{(Item*)ingredient.getItem(), ingredient.getBlock(), ingredient, rt++});
            }
            auto tmp     = RecipeUnlockingRequirement();
            tmp.mContext = RecipeUnlockingRequirement::UnlockingContext::AlwaysUnlocked;
            ll::service::bedrock::getLevel()->getRecipes().addShapedRecipe(
                recipe_id,
                ItemInstance(*result),
                shape,
                types,
                {"crafting_table"},
                50,
                nullptr,
                tmp,
                SemVersion(
                    1,
                    20,
                    80,
                    {"", Bedrock::StaticOptimizedString::StorageType::Static},
                    {"", Bedrock::StaticOptimizedString::StorageType::Static}
                ),
                true
            );
        }
    );
    RemoteCall::exportAs("GMLIB_API", "entityIsType", [](Actor* entity, int type) -> bool {
        return entity->isType((ActorType)type);
    });
    RemoteCall::exportAs("GMLIB_API", "entityHasType", [](Actor* entity, int type) -> bool {
        return entity->hasType((ActorType)type);
    });
    RemoteCall::exportAs("GMLIB_API", "getEntityTypeId", [](Actor* entity) -> int {
        return (int)entity->getEntityTypeId();
    });
    RemoteCall::exportAs("GMLIB_API", "getPlayerProtocolVersion", [](Player* player) -> int {
        return ((GMPlayer*)player)->getNetworkProtocolVersion();
    });
}