// #define COMMAND_REGISTRY_EXTRA
// #include <MC/CommandRegistry.hpp>
// #include <MC/CommandParameterData.hpp>
// #include <MC/AvailableCommandsPacket.hpp>
// #include <vector>
// #include <RegCommandAPI.h>
// #include <LoggerAPI.h>
// static_assert(offsetof(CommandParameterData, options) == 73);
// static_assert(offsetof(CommandParameterData, name) == 16);
// static_assert(offsetof(CommandParameterData, unk56) == 56);
// static_assert(offsetof(CommandRegistry::Overload, unk) == 40);
// static_assert(sizeof(CommandRegistry::Overload) == 72);
// static_assert(offsetof(CommandRegistry::Signature, alt_symbol) == 96);
// static_assert(sizeof(CommandRegistry::Signature) == 120);
// /*
// void CommandRegistry::registerOverload(std::string const& name, Overload::FactoryFn factory, std::vector<CommandParameterData>&& args)
// {
//     Signature* signature = const_cast<Signature*>(findCommand(name));
//     auto& overload = signature->overloads.emplace_back(CommandVersion{}, factory, std::move(args));
//     registerOverloadInternal(*signature, overload);
// }*/

// extern Logger logger;

// CommandRegistry::Overload::Overload(CommandVersion version,
//                                     FactoryFn factory,
//                                     std::vector<CommandParameterData>&& args)
// : version(version)
// , factory(factory)
// , params(std::forward<std::vector<CommandParameterData>>(args))
// , unk(255){};

// CommandRegistry::Overload::~Overload(){};

// std::vector<std::string> CommandRegistry::getEnumNames() {
//     if (!Global<CommandRegistry>)
//         return {};
//     std::vector<std::string> results;
//     for (auto& e : Global<CommandRegistry>->mEnums)
//         results.push_back(e.name);
//     return results;

//     auto packet = Global<CommandRegistry>->serializeAvailableCommands();
//     return packet.getEnumNames();
// }
// std::vector<std::string> CommandRegistry::getSoftEnumNames() {
//     if (!Global<CommandRegistry>)
//         return {};
//     std::vector<std::string> results;
//     for (auto& e : Global<CommandRegistry>->mSoftEnums)
//         results.push_back(e.name);
//     return results;

//     auto packet = Global<CommandRegistry>->serializeAvailableCommands();
//     return packet.getEnumNames();
// }
// std::vector<std::string> CommandRegistry::getEnumValues(std::string const& name) {
//     if (!Global<CommandRegistry>)
//         return {};
//     std::vector<std::string> results;
//     auto& enums = Global<CommandRegistry>->mEnums;
//     auto iter = std::find_if(enums.begin(), enums.end(), [&](CommandRegistry::Enum const& r) { return r.name == name; });
//     if (iter == enums.end())
//         return results;
//     for (auto& i : iter->values)
//         results.push_back(Global<CommandRegistry>->mEnumValues.at(std::get<3>(i)));
//     return results;

//     auto packet = Global<CommandRegistry>->serializeAvailableCommands();
//     return packet.getEnumValues(name);
// }
// std::vector<std::string> CommandRegistry::getSoftEnumValues(std::string const& name) {
//     if (!Global<CommandRegistry>)
//         return {};
//     std::vector<std::string> results;
//     auto& enums = Global<CommandRegistry>->mSoftEnums;
//     auto iter = std::find_if(enums.begin(), enums.end(), [&](CommandRegistry::SoftEnum const& r) { return r.name == name; });
//     if (iter != enums.end())
//         return iter->list;
//     return {};

//     auto packet = Global<CommandRegistry>->serializeAvailableCommands();
//     return packet.getEnumValues(name);
// }
// std::string CommandRegistry::getCommandFullName(std::string const& name) {
//     if (!Global<CommandRegistry>)
//         return "";
//     auto sig = Global<CommandRegistry>->findCommand(name);
//     if (sig)
//         return sig->name;
//     return "";
// }

// #include <Main/Config.h>
// bool CommandRegistry::unregisterCommand(std::string const& name) {
//     if (!LL::globalConfig.debugMode) {
//         logger.error("unregister command is only enabled in debug mode");
//         return false;
//     }
//     logger.warn("Unregister Command \"{}\"!", name);
//     try {
//         auto command = getCommandFullName(name);
//         if (command.empty())
//             return false;
//         auto alias = getAliases(name);
//         auto aliasKey = command + "CommandAliases";
//         static size_t removeIndex = 0;
//         auto iter = std::find_if(mEnums.begin(), mEnums.end(), [](Enum const& e) { return e.name == "CommandName"; });
//         for (auto i = iter->values.begin(); i != iter->values.end();) {
//             auto& enumValue = mEnumValues.at(std::get<3>(*i));
//             if (enumValue == command || std::find(alias.begin(), alias.end(), enumValue) != alias.end()) {
//                 mEnumValueLookup.erase(enumValue);
//                 i = iter->values.erase(i);
//                 enumValue = fmt::format("removed_{}", removeIndex++);
//             } else {
//                 ++i;
//             }
//         }
//         auto aliasIter = std::find_if(mEnums.begin(), mEnums.end(), [&aliasKey](Enum const& e) { return e.name == aliasKey; });
//         if (aliasIter != mEnums.end()) {
//             aliasIter->values.clear();
//             mEnumLookup.erase(aliasIter->name);
//             aliasIter->name = fmt::format("removed_{}", removeIndex++);
//         }
//         auto sig = mSignatures.find(command);
//         if (sig == mSignatures.end())
//             return false;
//         {
//             auto iter = std::remove_if(mCommandSymbols.begin(), mCommandSymbols.end(),
//                                        [&](Symbol const& r) { return r == sig->second.main_symbol || r == sig->second.alt_symbol; });
//             if (iter != mCommandSymbols.end())
//                 mCommandSymbols.erase(iter, mCommandSymbols.end());
//         }
//         //{
//         //    auto iter = std::remove_if(mRules.begin(), mRules.end(),
//         //                               [&](ParseRule const& r) { return r.sym == sig->second.main_symbol || r.sym == sig->second.alt_symbol; });
//         //    if (iter == mRules.end())
//         //        mRules.erase(iter, mRules.end());
//         //};
//         {
//             auto iter = std::remove_if(mFactorizations.begin(), mFactorizations.end(),
//                                        [&](Factorization const& r) { return r.sym == sig->second.main_symbol || r.sym == sig->second.alt_symbol; });
//             if (iter != mFactorizations.end())
//                 mFactorizations.erase(iter, mFactorizations.end());
//         };

//         mSignatures.erase(sig);
//         mAliases.erase(command);
//         return true;
//     } catch (...) {
//         logger.error("Error in CommandRegistry::unregisterCommand");
//     }
//     return false;
// }

// inline void CommandRegistry::printAll() const {
//     logger.error("mRules");
//     for (auto& rule : mRules) {
//         logger.warn("{}", rule.toDebugString());
//     }
//     logger.error("mParseTableMap");
//     for (auto& [key, table] : mParseTableMap) {
//         logger.warn("{}: {}", key, table.toDebugString());
//     }
//     logger.error("mOptionals");
//     for (auto& optional : mOptionals) {
//         logger.warn("{}", optional.toDebugString());
//     }
//     logger.error("mEnums");
//     for (auto& en : mEnums) {
//         logger.warn("{}", en.toDebugString());
//     }
//     logger.error("mFactorizations");
//     for (auto& i : mFactorizations) {
//         logger.warn("{}", i.toDebugString());
//     }
//     logger.error("mCommandSymbols");
//     for (auto& i : mCommandSymbols) {
//         logger.warn("{}", i.toDebugString());
//     }
//     logger.error("mSignatures");
//     for (auto& [k, v] : mSignatures) {
//         logger.warn("{}: {}", k, v.toDebugString());
//     }
//     logger.error("mConstrainedValues");
//     for (auto& i : mConstrainedValues) {
//         logger.warn("{}", i.toDebugString());
//     }
// }
// inline void CommandRegistry::printSize() const {
//     static auto log = std::unordered_map<std::string, std::string>{
//         {"mRules                   ", ""},
//         {"mParseTableMap           ", ""},
//         {"mOptionals               ", ""},
//         {"mEnumValues              ", ""},
//         {"mEnums                   ", ""},
//         {"mFactorizations          ", ""},
//         {"mPostfixes               ", ""},
//         {"mEnumLookup              ", ""},
//         {"mEnumValueLookup         ", ""},
//         {"mCommandSymbols          ", ""},
//         {"mSignatures              ", ""},
//         {"mTypeLookup              ", ""},
//         {"unk376                   ", ""},
//         {"mAliases                 ", ""},
//         {"mSemanticConstraints     ", ""},
//         {"mSemanticConstraintLookup", ""},
//         {"mConstrainedValues       ", ""},
//         {"mConstrainedValueLookup  ", ""},
//         {"mSoftEnums               ", ""},
//         {"mSoftEnumLookup          ", ""},
//         {"mStateStack              ", ""},
//         {"mEnumsValues             ", ""},
//         {"mConstrainedValuesValues ", ""},
//     };
//     auto mEnumsValuesSize = ([&]() -> size_t {
//         size_t size = 0;
//         for (auto& i : mEnums) {
//             size += i.values.size();
//         }
//         return size;
//     })();
//     auto mConstrainedValuesSize = ([&]() -> size_t {
//         size_t size = 0;
//         for (auto& i : mConstrainedValues) {
//             size += i.mConstraints.size();
//         }
//         return size;
//     })();
//     log["mRules                   "].append(fmt::format(", {:4}", mRules.size()));
//     log["mParseTableMap           "].append(fmt::format(", {:4}", mParseTableMap.size()));
//     log["mOptionals               "].append(fmt::format(", {:4}", mOptionals.size()));
//     log["mEnumValues              "].append(fmt::format(", {:4}", mEnumValues.size()));
//     log["mEnums                   "].append(fmt::format(", {:4}", mEnums.size()));
//     log["mFactorizations          "].append(fmt::format(", {:4}", mFactorizations.size()));
//     log["mPostfixes               "].append(fmt::format(", {:4}", mPostfixes.size()));
//     log["mEnumLookup              "].append(fmt::format(", {:4}", mEnumLookup.size()));
//     log["mEnumValueLookup         "].append(fmt::format(", {:4}", mEnumValueLookup.size()));
//     log["mCommandSymbols          "].append(fmt::format(", {:4}", mCommandSymbols.size()));
//     log["mSignatures              "].append(fmt::format(", {:4}", mSignatures.size()));
//     log["mTypeLookup              "].append(fmt::format(", {:4}", mTypeLookup.size()));
//     log["unk376                   "].append(fmt::format(", {:4}", unk376.size()));
//     log["mAliases                 "].append(fmt::format(", {:4}", mAliases.size()));
//     log["mSemanticConstraints     "].append(fmt::format(", {:4}", mSemanticConstraints.size()));
//     log["mSemanticConstraintLookup"].append(fmt::format(", {:4}", mSemanticConstraintLookup.size()));
//     log["mConstrainedValues       "].append(fmt::format(", {:4}", mConstrainedValues.size()));
//     log["mConstrainedValueLookup  "].append(fmt::format(", {:4}", mConstrainedValueLookup.size()));
//     log["mSoftEnums               "].append(fmt::format(", {:4}", mSoftEnums.size()));
//     log["mSoftEnumLookup          "].append(fmt::format(", {:4}", mSoftEnumLookup.size()));
//     log["mStateStack              "].append(fmt::format(", {:4}", mStateStack.size()));
//     log["mEnumsValues             "].append(fmt::format(", {:4}", mEnumsValuesSize));
//     log["mConstrainedValuesValues "].append(fmt::format(", {:4}", mConstrainedValuesSize));
//     for (auto& [k, v] : log) {
//         logger.warn("{}{}", k, v);
//     }
// }