[3.3.5] ChatCommands, the other half: chat command resolution refactor (PR #25463)

(cherry picked from commit 1eca51b417678b9a48b28552925d5694105f82bb)

5 files changed, 621 insertions, 411 deletions

diff --git a/src/server/game/Chat/Chat.cpp b/src/server/game/Chat/Chat.cpp
index 708178e9ab6..59487cde650 100644
--- a/src/server/game/Chat/Chat.cpp
+++ b/src/server/game/Chat/Chat.cpp
@@ -39,7 +39,7 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <sstream>
 
-Player* ChatHandler::GetPlayer() { return m_session ? m_session->GetPlayer() : nullptr; }
+Player* ChatHandler::GetPlayer() const { return m_session ? m_session->GetPlayer() : nullptr; }
 
 char* ChatHandler::LineFromMessage(char*& pos)
 {
@@ -48,56 +48,11 @@ char* ChatHandler::LineFromMessage(char*& pos)
     return start;
 }
 
-// Lazy loading of the command table cache from commands and the
-// ScriptMgr should be thread safe since the player commands,
-// cli commands and ScriptMgr updates are all dispatched one after
-// one inside the world update loop.
-static Optional<std::vector<ChatCommand>> commandTableCache;
-
-std::vector<ChatCommand> const& ChatHandler::getCommandTable()
-{
-    if (!commandTableCache)
-        InitializeCommandTable();
-
-    return *commandTableCache;
-}
-
-void ChatHandler::InitializeCommandTable()
-{
-    // We need to initialize this at top since SetDataForCommandInTable
-    // calls getCommandTable() recursively.
-    commandTableCache = sScriptMgr->GetChatCommands();
-
-    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS);
-    PreparedQueryResult result = WorldDatabase.Query(stmt);
-    if (result)
-    {
-        do
-        {
-            Field* fields = result->Fetch();
-            std::string name = fields[0].GetString();
-
-            SetDataForCommandInTable(*commandTableCache, name.c_str(), fields[1].GetUInt16(), fields[2].GetString(), name);
-        }
-        while (result->NextRow());
-    }
-}
-
-void ChatHandler::invalidateCommandTable()
-{
-    commandTableCache.reset();
-}
-
 char const* ChatHandler::GetTrinityString(uint32 entry) const
 {
     return m_session->GetTrinityString(entry);
 }
 
-bool ChatHandler::isAvailable(ChatCommand const& cmd) const
-{
-    return HasPermission(cmd.Permission);
-}
-
 bool ChatHandler::HasPermission(uint32 permission) const
 {
     return m_session->HasPermission(permission);
@@ -158,31 +113,6 @@ bool ChatHandler::HasLowerSecurityAccount(WorldSession* target, uint32 target_ac
     return false;
 }
 
-bool ChatHandler::hasStringAbbr(const char* name, const char* part)
-{
-    // non "" command
-    if (*name)
-    {
-        // "" part from non-"" command
-        if (!*part)
-            return false;
-
-        while (true)
-        {
-            if (!*part || *part == ' ')
-                return true;
-            else if (!*name)
-                return false;
-            else if (tolower(*name) != tolower(*part))
-                return false;
-            ++name; ++part;
-        }
-    }
-    // allow with any for ""
-
-    return true;
-}
-
 void ChatHandler::SendSysMessage(std::string_view str, bool escapeCharacters)
 {
     std::string msg{ str };
@@ -232,171 +162,9 @@ void ChatHandler::SendSysMessage(uint32 entry)
     SendSysMessage(GetTrinityString(entry));
 }
 
-bool ChatHandler::ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd)
+bool ChatHandler::_ParseCommands(std::string_view text)
 {
-    char const* oldtext = text;
-    std::string cmd = "";
-
-    while (*text != ' ' && *text != '\0')
-    {
-        cmd += *text;
-        ++text;
-    }
-
-    while (*text == ' ') ++text;
-
-    for (uint32 i = 0; i < table.size(); ++i)
-    {
-        if (!hasStringAbbr(table[i].Name, cmd.c_str()))
-            continue;
-
-        bool match = false;
-        if (strlen(table[i].Name) > cmd.length())
-        {
-            for (uint32 j = 0; j < table.size(); ++j)
-            {
-                if (!hasStringAbbr(table[j].Name, cmd.c_str()))
-                    continue;
-
-                if (strcmp(table[j].Name, cmd.c_str()) == 0)
-                {
-                    match = true;
-                    break;
-                }
-            }
-        }
-        if (match)
-            continue;
-
-        // select subcommand from child commands list
-        if (!table[i].ChildCommands.empty())
-        {
-            if (!ExecuteCommandInTable(table[i].ChildCommands, text, fullcmd))
-            {
-                if (m_session && !m_session->HasPermission(rbac::RBAC_PERM_COMMANDS_NOTIFY_COMMAND_NOT_FOUND_ERROR))
-                    return false;
-
-                if (text[0] != '\0')
-                    SendSysMessage(LANG_NO_SUBCMD);
-                else
-                    SendSysMessage(LANG_CMD_SYNTAX);
-
-                ShowHelpForCommand(table[i].ChildCommands, text);
-            }
-
-            return true;
-        }
-
-        // must be available and have handler
-        if (!table[i].HasHandler() || !isAvailable(table[i]))
-            continue;
-
-        SetSentErrorMessage(false);
-        // table[i].Name == "" is special case: send original command to handler
-        if (table[i](this, table[i].Name[0] != '\0' ? text : oldtext))
-        {
-            if (!m_session) // ignore console
-                return true;
-
-            Player* player = m_session->GetPlayer();
-            if (!AccountMgr::IsPlayerAccount(m_session->GetSecurity()))
-            {
-                ObjectGuid guid = player->GetTarget();
-                uint32 areaId = player->GetAreaId();
-                std::string areaName = "Unknown";
-                std::string zoneName = "Unknown";
-                if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
-                {
-                    LocaleConstant locale = GetSessionDbcLocale();
-                    areaName = area->AreaName[locale];
-                    if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
-                        zoneName = zone->AreaName[locale];
-                }
-
-                sLog->outCommand(m_session->GetAccountId(), "Command: %s [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
-                    fullcmd.c_str(), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
-                    m_session->GetAccountId(), player->GetPositionX(), player->GetPositionY(),
-                    player->GetPositionZ(), player->GetMapId(),
-                    player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
-                    areaId, areaName.c_str(), zoneName.c_str(),
-                    (player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
-                    guid.ToString().c_str());
-            }
-        }
-        // some commands have custom error messages. Don't send the default one in these cases.
-        else if (!HasSentErrorMessage())
-        {
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-            else
-                SendSysMessage(LANG_CMD_SYNTAX);
-            SetSentErrorMessage(true);
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-bool ChatHandler::SetDataForCommandInTable(std::vector<ChatCommand>& table, char const* text, uint32 permission, std::string const& help, std::string const& fullcommand)
-{
-    std::string cmd = "";
-
-    while (*text != ' ' && *text != '\0')
-    {
-        cmd += *text;
-        ++text;
-    }
-
-    while (*text == ' ') ++text;
-
-    for (uint32 i = 0; i < table.size(); i++)
-    {
-        // for data fill use full explicit command names
-        if (table[i].Name != cmd)
-            continue;
-
-        // select subcommand from child commands list (including "")
-        if (!table[i].ChildCommands.empty())
-        {
-            if (SetDataForCommandInTable(table[i].ChildCommands, text, permission, help, fullcommand))
-                return true;
-            else if (*text)
-                return false;
-
-            // fail with "" subcommands, then use normal level up command instead
-        }
-        // expected subcommand by full name DB content
-        else if (*text)
-        {
-            TC_LOG_ERROR("sql.sql", "Table `command` contains an unexpected subcommand '%s' in command '%s', skipped.", text, fullcommand.c_str());
-            return false;
-        }
-
-        if (table[i].Permission != permission)
-            TC_LOG_INFO("misc", "Table `command` overwrite for command '%s' default permission (%u) by %u", fullcommand.c_str(), table[i].Permission, permission);
-
-        table[i].Permission = permission;
-        table[i].Help          = help;
-        return true;
-    }
-
-    // in case "" command let process by caller
-    if (!cmd.empty())
-    {
-        if (&table == &getCommandTable())
-            TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing command '%s', skipped.", cmd.c_str());
-        else
-            TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing subcommand '%s' in command '%s', skipped.", cmd.c_str(), fullcommand.c_str());
-    }
-
-    return false;
-}
-
-bool ChatHandler::_ParseCommands(char const* text)
-{
-    if (ExecuteCommandInTable(getCommandTable(), text, text))
+    if (Trinity::ChatCommands::TryExecuteCommand(*this, text))
         return true;
 
     // Pretend commands don't exist for regular players
@@ -404,126 +172,32 @@ bool ChatHandler::_ParseCommands(char const* text)
         return false;
 
     // Send error message for GMs
-    SendSysMessage(LANG_NO_CMD);
+    PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(text));
     SetSentErrorMessage(true);
     return true;
 }
 
-bool ChatHandler::ParseCommands(char const* text)
+bool ChatHandler::ParseCommands(std::string_view text)
 {
-    ASSERT(text);
-    ASSERT(*text);
+    ASSERT(!text.empty());
 
-    /// chat case (.command or !command format)
-    if (text[0] != '!' && text[0] != '.')
+    // chat case (.command or !command format)
+    if ((text[0] != '!') && (text[0] != '.'))
         return false;
 
-    /// ignore single . and ! in line
-    if (!text[1])
+    // ignore single . and ! in line
+    if (text.length() < 2)
         return false;
 
-    /// ignore messages staring from many dots.
-    if (text[1] == '!' || text[1] == '.')
+    // ignore messages staring from many dots.
+    if (text[1] == text[0])
         return false;
 
-    return _ParseCommands(text+1);
-}
-
-bool ChatHandler::ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd)
-{
-    std::string list;
-    for (uint32 i = 0; i < table.size(); ++i)
-    {
-        // must be available (ignore handler existence to show command with possible available subcommands)
-        if (!isAvailable(table[i]))
-            continue;
-
-        // for empty subcmd show all available
-        if (*subcmd && !hasStringAbbr(table[i].Name, subcmd))
-            continue;
-
-        if (m_session)
-            list += "\n    ";
-        else
-            list += "\n\r    ";
-
-        list += table[i].Name;
-
-        if (!table[i].ChildCommands.empty())
-            list += " ...";
-    }
-
-    if (list.empty())
+    // ignore messages with separator after .
+    if (text[1] == Trinity::Impl::ChatCommands::COMMAND_DELIMITER)
         return false;
 
-    if (&table == &getCommandTable())
-    {
-        SendSysMessage(LANG_AVIABLE_CMD);
-        PSendSysMessage("%s", list.c_str());
-    }
-    else
-        PSendSysMessage(LANG_SUBCMDS_LIST, cmd, list.c_str());
-
-    return true;
-}
-
-bool ChatHandler::ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd)
-{
-    if (*cmd)
-    {
-        std::string subcmd;
-        if (size_t n = std::string_view(cmd).find(' '); n != std::string_view::npos)
-            subcmd.assign(cmd+n+1);
-
-        for (uint32 i = 0; i < table.size(); ++i)
-        {
-            // must be available (ignore handler existence to show command with possible available subcommands)
-            if (!isAvailable(table[i]))
-                continue;
-
-            if (!hasStringAbbr(table[i].Name, cmd))
-                continue;
-
-            // have subcommand
-            if (!table[i].ChildCommands.empty() && !subcmd.empty())
-            {
-                if (ShowHelpForCommand(table[i].ChildCommands, subcmd.c_str()))
-                    return true;
-            }
-
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-
-            if (!table[i].ChildCommands.empty())
-                if (ShowHelpForSubCommands(table[i].ChildCommands, table[i].Name, subcmd.c_str()))
-                    return true;
-
-            return !table[i].Help.empty();
-        }
-    }
-    else
-    {
-        for (uint32 i = 0; i < table.size(); ++i)
-        {
-            // must be available (ignore handler existence to show command with possible available subcommands)
-            if (!isAvailable(table[i]))
-                continue;
-
-            if (strlen(table[i].Name))
-                continue;
-
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-
-            if (!table[i].ChildCommands.empty())
-                if (ShowHelpForSubCommands(table[i].ChildCommands, "", ""))
-                    return true;
-
-            return !table[i].Help.empty();
-        }
-    }
-
-    return ShowHelpForSubCommands(table, "", cmd);
+    return _ParseCommands(text.substr(1));
 }
 
 Player* ChatHandler::getSelectedPlayer()
@@ -1005,25 +679,19 @@ char const* CliHandler::GetTrinityString(uint32 entry) const
     return sObjectMgr->GetTrinityStringForDBCLocale(entry);
 }
 
-bool CliHandler::isAvailable(ChatCommand const& cmd) const
-{
-    // skip non-console commands in console case
-    return cmd.AllowConsole;
-}
-
 void CliHandler::SendSysMessage(std::string_view str, bool /*escapeCharacters*/)
 {
     m_print(m_callbackArg, str);
     m_print(m_callbackArg, "\r\n");
 }
 
-bool CliHandler::ParseCommands(char const* str)
+bool CliHandler::ParseCommands(std::string_view str)
 {
-    if (!str[0])
+    if (str.empty())
         return false;
     // Console allows using commands both with and without leading indicator
     if (str[0] == '.' || str[0] == '!')
-        ++str;
+        str = str.substr(1);
     return _ParseCommands(str);
 }
 
@@ -1093,14 +761,12 @@ LocaleConstant CliHandler::GetSessionDbLocaleIndex() const
 
 std::string const AddonChannelCommandHandler::PREFIX = "TrinityCore";
 
-bool AddonChannelCommandHandler::ParseCommands(char const* str)
+bool AddonChannelCommandHandler::ParseCommands(std::string_view str)
 {
-    char opcode = str[0];
-    if (!opcode) // str[0] is opcode
+    if (str.length() < 5)
         return false;
-    if (!str[1] || !str[2] || !str[3] || !str[4]) // str[1] through str[4] is 4-character command counter
-        return false;
-    echo = str+1;
+    char opcode = str[0];
+    echo = &str[1];
 
     switch (opcode)
     {
@@ -1109,10 +775,12 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
             return true;
         case 'h': // h Issue human-readable command
         case 'i': // i Issue command
+        {
             if (!str[5])
                 return false;
             humanReadable = (opcode == 'h');
-            if (_ParseCommands(str + 5)) // actual command starts at str[5]
+            std::string_view cmd = str.substr(5);
+            if (_ParseCommands(cmd)) // actual command starts at str[5]
             {
                 if (!hadAck)
                     SendAck();
@@ -1123,10 +791,11 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
             }
             else
             {
-                SendSysMessage(LANG_NO_CMD);
+                PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmd));
                 SendFailed();
             }
             return true;
+        }
         default:
             return false;
     }
diff --git a/src/server/game/Chat/Chat.h b/src/server/game/Chat/Chat.h
index edb5858ac7c..5af87f472e9 100644
--- a/src/server/game/Chat/Chat.h
+++ b/src/server/game/Chat/Chat.h
@@ -20,9 +20,7 @@
 
 #include "ObjectGuid.h"
 #include "StringFormat.h"
-#include <vector>
 
-class ChatCommand;
 class ChatHandler;
 class Creature;
 class GameObject;
@@ -39,8 +37,10 @@ enum LocaleConstant : uint8;
 class TC_GAME_API ChatHandler
 {
     public:
+        bool IsConsole() const { return (m_session == nullptr); }
         WorldSession* GetSession() { return m_session; }
-        Player* GetPlayer();
+        WorldSession const* GetSession() const { return m_session; }
+        Player* GetPlayer() const;
         explicit ChatHandler(WorldSession* session) : m_session(session), sentErrorMessage(false) { }
         virtual ~ChatHandler() { }
 
@@ -70,19 +70,12 @@ class TC_GAME_API ChatHandler
             return Trinity::StringFormat(GetTrinityString(entry), std::forward<Args>(args)...);
         }
 
-        bool _ParseCommands(char const* text);
-        virtual bool ParseCommands(char const* text);
-
-        static std::vector<ChatCommand> const& getCommandTable();
-        static void InitializeCommandTable();
-        static void invalidateCommandTable();
+        bool _ParseCommands(std::string_view text);
+        virtual bool ParseCommands(std::string_view text);
 
         void SendGlobalSysMessage(const char *str);
 
-        bool hasStringAbbr(const char* name, const char* part);
-
         // function with different implementation for chat/console
-        virtual bool isAvailable(ChatCommand const& cmd) const;
         virtual bool IsHumanReadable() const { return true; }
         virtual bool HasPermission(uint32 permission) const;
         virtual std::string GetNameLink() const;
@@ -119,13 +112,8 @@ class TC_GAME_API ChatHandler
         Creature* GetCreatureFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid);
         bool HasSentErrorMessage() const { return sentErrorMessage; }
         void SetSentErrorMessage(bool val){ sentErrorMessage = val; }
-
-        bool ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd);
     protected:
         explicit ChatHandler() : m_session(nullptr), sentErrorMessage(false) { }     // for CLI subclass
-        static bool SetDataForCommandInTable(std::vector<ChatCommand>& table, const char* text, uint32 permission, std::string const& help, std::string const& fullcommand);
-        bool ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd);
-        bool ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd);
 
     private:
         WorldSession* m_session;                           // != nullptr for chat command call and nullptr for CLI command
@@ -142,10 +130,9 @@ class TC_GAME_API CliHandler : public ChatHandler
 
         // overwrite functions
         char const* GetTrinityString(uint32 entry) const override;
-        bool isAvailable(ChatCommand const& cmd) const override;
         bool HasPermission(uint32 /*permission*/) const override { return true; }
         void SendSysMessage(std::string_view, bool escapeCharacters) override;
-        bool ParseCommands(char const* str) override;
+        bool ParseCommands(std::string_view str) override;
         std::string GetNameLink() const override;
         bool needReportToTarget(Player* chr) const override;
         LocaleConstant GetSessionDbcLocale() const override;
@@ -162,7 +149,7 @@ class TC_GAME_API AddonChannelCommandHandler : public ChatHandler
         static std::string const PREFIX;
 
         using ChatHandler::ChatHandler;
-        bool ParseCommands(char const* str) override;
+        bool ParseCommands(std::string_view str) override;
         void SendSysMessage(std::string_view, bool escapeCharacters) override;
         using ChatHandler::SendSysMessage;
         bool IsHumanReadable() const override { return humanReadable; }
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.cpp b/src/server/game/Chat/ChatCommands/ChatCommand.cpp
new file mode 100644
index 00000000000..865979999d7
--- /dev/null
+++ b/src/server/game/Chat/ChatCommands/ChatCommand.cpp
@@ -0,0 +1,466 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ChatCommand.h"
+
+#include "AccountMgr.h"
+#include "Chat.h"
+#include "DatabaseEnv.h"
+#include "DB2Stores.h"
+#include "Log.h"
+#include "Map.h"
+#include "Player.h"
+#include "ScriptMgr.h"
+#include "WorldSession.h"
+
+using ChatSubCommandMap = std::map<std::string_view, Trinity::Impl::ChatCommands::ChatCommandNode, StringCompareLessI_T>;
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::LoadFromBuilder(ChatCommandBuilder const& builder)
+{
+    if (std::holds_alternative<ChatCommandBuilder::InvokerEntry>(builder._data))
+    {
+        ASSERT(!_invoker, "Duplicate blank sub-command.");
+        std::tie(_invoker, _permission) = std::get<ChatCommandBuilder::InvokerEntry>(builder._data);
+    }
+    else
+        LoadCommandsIntoMap(this, _subCommands, std::get<ChatCommandBuilder::SubCommandEntry>(builder._data));
+}
+
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandsIntoMap(ChatCommandNode* blank, ChatSubCommandMap& map, Trinity::ChatCommands::ChatCommandTable const& commands)
+{
+    for (ChatCommandBuilder const& builder : commands)
+    {
+        if (builder._name.empty())
+        {
+            ASSERT(blank, "Empty name command at top level is not permitted.");
+            blank->LoadFromBuilder(builder);
+        }
+        else
+        {
+            std::vector<std::string_view> const tokens = Trinity::Tokenize(builder._name, COMMAND_DELIMITER, false);
+            ASSERT(!tokens.empty(), "Invalid command name '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(builder._name));
+            ChatSubCommandMap* subMap = &map;
+            for (size_t i = 0, n = (tokens.size() - 1); i < n; ++i)
+                subMap = &((*subMap)[tokens[i]]._subCommands);
+            ((*subMap)[tokens.back()]).LoadFromBuilder(builder);
+        }
+    }
+}
+
+static ChatSubCommandMap COMMAND_MAP;
+/*static*/ ChatSubCommandMap const& Trinity::Impl::ChatCommands::ChatCommandNode::GetTopLevelMap()
+{
+    if (COMMAND_MAP.empty())
+        LoadCommandMap();
+    return COMMAND_MAP;
+}
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap() { COMMAND_MAP.clear(); }
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap()
+{
+    InvalidateCommandMap();
+    LoadCommandsIntoMap(nullptr, COMMAND_MAP, sScriptMgr->GetChatCommands());
+
+    if (PreparedQueryResult result = WorldDatabase.Query(WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS)))
+    {
+        do
+        {
+            Field* fields = result->Fetch();
+            std::string_view const name = fields[0].GetStringView();
+            uint16 const permission = fields[1].GetUInt16();
+            std::string_view const help = fields[2].GetStringView();
+
+            ChatCommandNode* cmd = nullptr;
+            ChatSubCommandMap* map = &COMMAND_MAP;
+            for (std::string_view key : Trinity::Tokenize(name, COMMAND_DELIMITER, false))
+            {
+                auto it = map->find(key);
+                if (it != map->end())
+                {
+                    cmd = &it->second;
+                    map = &cmd->_subCommands;
+                }
+                else
+                {
+                    TC_LOG_ERROR("sql.sql", "Table `command` contains data for non-existant command '" STRING_VIEW_FMT "'. Skipped.", STRING_VIEW_FMT_ARG(name));
+                    cmd = nullptr;
+                    break;
+                }
+            }
+
+            if (!cmd)
+                continue;
+
+            if (cmd->_invoker && (cmd->_permission.RequiredPermission != permission))
+            {
+                TC_LOG_WARN("sql.sql", "Table `command` has permission %u for '" STRING_VIEW_FMT "' which does not match the core (%u). Overriding.",
+                    permission, STRING_VIEW_FMT_ARG(name), cmd->_permission.RequiredPermission);
+
+                cmd->_permission.RequiredPermission = static_cast<rbac::RBACPermissions>(permission);
+            }
+
+            cmd->_help.assign(help);
+        } while (result->NextRow());
+    }
+
+    for (auto const& [name, cmd] : COMMAND_MAP)
+        cmd.AssertCommandHelp(name);
+}
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::AssertCommandHelp(std::string_view name) const
+{
+    if (_invoker && _help.empty())
+        TC_LOG_WARN("sql.sql", "Table `command` is missing help text for (sub-)command '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(name));
+
+    for (auto const& [name, cmd] : _subCommands)
+        cmd.AssertCommandHelp(name);
+}
+
+static void LogCommandUsage(WorldSession const& session, uint32 permission, std::string_view cmdStr)
+{
+    if (AccountMgr::IsPlayerAccount(session.GetSecurity()))
+        return;
+
+    if (sAccountMgr->GetRBACPermission(rbac::RBAC_ROLE_PLAYER)->GetLinkedPermissions().count(permission))
+        return;
+
+    Player* player = session.GetPlayer();
+    ObjectGuid targetGuid = player->GetTarget();
+    uint32 areaId = player->GetAreaId();
+    std::string areaName = "Unknown";
+    std::string zoneName = "Unknown";
+    if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
+    {
+        LocaleConstant locale = session.GetSessionDbcLocale();
+        areaName = area->AreaName[locale];
+        if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
+            zoneName = zone->AreaName[locale];
+    }
+
+    sLog->outCommand(session.GetAccountId(), "Command: " STRING_VIEW_FMT " [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
+        STRING_VIEW_FMT_ARG(cmdStr), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
+        session.GetAccountId(), player->GetPositionX(), player->GetPositionY(),
+        player->GetPositionZ(), player->GetMapId(),
+        player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
+        areaId, areaName.c_str(), zoneName.c_str(),
+        (player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
+        targetGuid.ToString().c_str());
+}
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelp(ChatHandler& handler) const
+{
+    if (IsInvokerVisible(handler))
+        handler.SendSysMessage(_help);
+    bool header = false;
+    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
+    {
+        bool const subCommandHasSubCommand = it->second.HasVisibleSubCommands(handler);
+        if (!subCommandHasSubCommand && !it->second.IsInvokerVisible(handler))
+            continue;
+        if (!header)
+        {
+            handler.SendSysMessage(LANG_SUBCMDS_LIST);
+            header = true;
+        }
+        handler.PSendSysMessage(subCommandHasSubCommand ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
+    }
+}
+
+namespace Trinity::Impl::ChatCommands
+{
+    struct FilteredCommandListIterator
+    {
+        public:
+            FilteredCommandListIterator(ChatSubCommandMap const& map, ChatHandler const& handler, std::string_view token)
+                : _handler{ handler }, _token{ token }, _it{ map.lower_bound(token) }, _end{ map.end() }
+            {
+                _skip();
+            }
+
+            decltype(auto) operator*() const { return _it.operator*(); }
+            decltype(auto) operator->() const { return _it.operator->(); }
+            FilteredCommandListIterator& operator++()
+            {
+                ++_it;
+                _skip();
+                return *this;
+            }
+            explicit operator bool() const { return (_it != _end); }
+            bool operator!() const { return !static_cast<bool>(*this); }
+
+        private:
+            void _skip()
+            {
+                if ((_it != _end) && !StringStartsWithI(_it->first, _token))
+                    _it = _end;
+                while ((_it != _end) && !_it->second.IsVisible(_handler))
+                {
+                    ++_it;
+                    if ((_it != _end) && !StringStartsWithI(_it->first, _token))
+                        _it = _end;
+                }
+            }
+            ChatHandler const& _handler;
+            std::string_view const _token;
+            ChatSubCommandMap::const_iterator _it, _end;
+
+    };
+}
+
+/*static*/ bool Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(ChatHandler& handler, std::string_view cmdStr)
+{
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+
+    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
+        cmdStr.remove_prefix(1);
+    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
+        cmdStr.remove_suffix(1);
+    std::string_view oldTail = cmdStr;
+    while (!oldTail.empty())
+    {
+        /* oldTail = token DELIMITER newTail */
+        auto [token, newTail] = tokenize(oldTail);
+        ASSERT(!token.empty());
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+            break; /* no matching subcommands found */
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - print possibilities and return */
+                if (cmd)
+                    handler.PSendSysMessage(LANG_SUBCMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                else
+                    handler.PSendSysMessage(LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
+                do
+                {
+                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
+                } while (++it2);
+
+                return true;
+            }
+        }
+
+        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+
+        oldTail = newTail;
+    }
+
+    if (cmd)
+    { /* if we matched a command at some point, invoke it */
+        handler.SetSentErrorMessage(false);
+        if (cmd->IsInvokerVisible(handler) && cmd->_invoker(&handler, oldTail))
+        { /* invocation succeeded, log this */
+            if (!handler.IsConsole())
+                LogCommandUsage(*handler.GetSession(), cmd->_permission.RequiredPermission, cmdStr);
+        }
+        else if (!handler.HasSentErrorMessage())
+        { /* invocation failed, we should show usage */
+            cmd->SendCommandHelp(handler);
+            handler.SetSentErrorMessage(true);
+        }
+        return true;
+    }
+
+    return false;
+}
+
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(ChatHandler& handler, std::string_view cmdStr)
+{
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+    for (std::string_view token : Trinity::Tokenize(cmdStr, COMMAND_DELIMITER, false))
+    {
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+        { /* no matching subcommands found */
+            if (cmd)
+            {
+                cmd->SendCommandHelp(handler);
+                handler.PSendSysMessage(LANG_SUBCMD_INVALID, STRING_VIEW_FMT_ARG(token));
+            }
+            else
+                handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(token));
+            return;
+        }
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - print possibilities and return */
+                handler.PSendSysMessage(cmd ? LANG_SUBCMD_AMBIGUOUS : LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
+                do
+                {
+                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
+                } while (++it2);
+
+                return;
+            }
+        }
+
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+    }
+
+    if (cmd)
+        cmd->SendCommandHelp(handler);
+    else if (cmdStr.empty())
+    {
+        FilteredCommandListIterator it(*map, handler, "");
+        if (!it)
+            return;
+        handler.SendSysMessage(LANG_AVAILABLE_CMDS);
+        do
+        {
+            handler.PSendSysMessage(it->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
+        } while (++it);
+    }
+    else
+        handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmdStr));
+}
+
+/*static*/ std::vector<std::string> Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmdStr)
+{
+    std::string path;
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+
+    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
+        cmdStr.remove_prefix(1);
+    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
+        cmdStr.remove_suffix(1);
+    std::string_view oldTail = cmdStr;
+    while (!oldTail.empty())
+    {
+        /* oldTail = token DELIMITER newTail */
+        auto [token, newTail] = tokenize(oldTail);
+        ASSERT(!token.empty());
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+            break; /* no matching subcommands found */
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - terminate here and show possibilities */
+                std::vector<std::string> vec;
+                auto possibility = ([prefix = std::string_view(path), suffix = std::string_view(newTail)](std::string_view match)
+                {
+                    if (prefix.empty())
+                    {
+                        return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                            STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
+                    }
+                    else
+                    {
+                        return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                            STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
+                    }
+                });
+
+                vec.emplace_back(possibility(it1->first));
+
+                do vec.emplace_back(possibility(it2->first));
+                while (++it2);
+
+                return vec;
+            }
+        }
+
+        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
+        if (path.empty())
+            path.assign(it1->first);
+        else
+        {
+            path = Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(it1->first));
+        }
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+
+        oldTail = newTail;
+    }
+
+    if (!oldTail.empty())
+    { /* there is some trailing text, leave it as is */
+        if (cmd)
+        { /* if we matched a command at some point, auto-complete it */
+            return {
+                Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                    STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(oldTail))
+            };
+        }
+        else
+            return {};
+    }
+    else
+    { /* offer all subcommands */
+        auto possibility = ([prefix = std::string_view(path)](std::string_view match)
+        {
+            if (prefix.empty())
+                return std::string(match);
+            else
+            {
+                return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                    STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match));
+            }
+        });
+
+        std::vector<std::string> vec;
+        for (FilteredCommandListIterator it(*map, handler, ""); it; ++it)
+            vec.emplace_back(possibility(it->first));
+        return vec;
+    }
+}
+
+bool Trinity::Impl::ChatCommands::ChatCommandNode::IsInvokerVisible(ChatHandler const& who) const
+{
+    if (!_invoker)
+        return false;
+    if (who.IsConsole() && (_permission.AllowConsole == Trinity::ChatCommands::Console::No))
+        return false;
+    return who.HasPermission(_permission.RequiredPermission);
+}
+
+bool Trinity::Impl::ChatCommands::ChatCommandNode::HasVisibleSubCommands(ChatHandler const& who) const
+{
+    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
+        if (it->second.IsVisible(who))
+            return true;
+    return false;
+}
+
+void Trinity::ChatCommands::LoadCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap(); }
+void Trinity::ChatCommands::InvalidateCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap(); }
+bool Trinity::ChatCommands::TryExecuteCommand(ChatHandler& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(handler, cmd); }
+void Trinity::ChatCommands::SendCommandHelpFor(ChatHandler& handler, std::string_view cmd) { Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(handler, cmd); }
+std::vector<std::string> Trinity::ChatCommands::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(handler, cmd); }
+
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.h b/src/server/game/Chat/ChatCommands/ChatCommand.h
index 41be7e74c1a..25fcff415c1 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommand.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommand.h
@@ -24,14 +24,31 @@
 #include "Define.h"
 #include "Errors.h"
 #include "Optional.h"
+#include "RBAC.h"
 #include "StringFormat.h"
+#include "Util.h"
 #include <cstddef>
+#include <map>
+#include <utility>
 #include <tuple>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 class ChatHandler;
 
+namespace Trinity::ChatCommands
+{
+    enum class Console : bool
+    {
+        No = false,
+        Yes = true
+    };
+
+    struct ChatCommandBuilder;
+    using ChatCommandTable = std::vector<ChatCommandBuilder>;
+}
+
 namespace Trinity::Impl::ChatCommands
 {
     // forward declaration
@@ -97,63 +114,134 @@ namespace Trinity::Impl::ChatCommands
     }
 
     template <typename T> struct HandlerToTuple { static_assert(Trinity::dependant_false_v<T>, "Invalid command handler signature"); };
-    template <typename... Ts> struct HandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
+    template <typename... Ts> struct HandlerToTuple<bool(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
     template <typename T> using TupleType = typename HandlerToTuple<T>::type;
-}
-
 
-class TC_GAME_API ChatCommand
-{
-    using wrapper_func = bool(void*, ChatHandler*, char const*);
-
-    public:
+    struct CommandInvoker
+    {
+        CommandInvoker() : _wrapper(nullptr), _handler(nullptr) {}
         template <typename TypedHandler>
-        ChatCommand(char const* name, uint32 permission, bool allowConsole, TypedHandler handler, std::string help)
-            : Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands({})
+        CommandInvoker(TypedHandler& handler)
         {
-            _wrapper = [](void* handler, ChatHandler* chatHandler, char const* argsStr)
+            _wrapper = [](void* handler, ChatHandler* chatHandler, std::string_view argsStr)
             {
-                using Tuple = Trinity::Impl::ChatCommands::TupleType<TypedHandler>;
+                using Tuple = TupleType<TypedHandler>;
 
                 Tuple arguments;
                 std::get<0>(arguments) = chatHandler;
-                Trinity::Impl::ChatCommands::ChatCommandResult result = Trinity::Impl::ChatCommands::ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
+                ChatCommandResult result = ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
                 if (result)
-                    return std::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments));
+                    return std::apply(reinterpret_cast<TypedHandler*>(handler), std::move(arguments));
                 else
                 {
                     if (result.HasErrorMessage())
-                        Trinity::Impl::ChatCommands::SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
+                        SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
                     return false;
                 }
             };
             _handler = reinterpret_cast<void*>(handler);
         }
 
-        ChatCommand(char const* name, uint32 permission, bool allowConsole, std::nullptr_t, std::string help, std::vector<ChatCommand> childCommands = {})
-            : Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands(std::move(childCommands))
-        {
-            _wrapper = nullptr;
-            _handler = nullptr;
-        }
-
-        bool operator()(ChatHandler* chatHandler, char const* args) const
+        explicit operator bool() const { return (_wrapper != nullptr); }
+        bool operator()(ChatHandler* chatHandler, std::string_view args) const
         {
             ASSERT(_wrapper && _handler);
             return _wrapper(_handler, chatHandler, args);
         }
 
-        bool HasHandler() const { return !!_handler; }
-
-        char const* Name;
-        uint32 Permission;
-        bool AllowConsole;
-        std::string Help;
-        std::vector<ChatCommand> ChildCommands;
-
     private:
+        using wrapper_func = bool(void*, ChatHandler*, std::string_view);
         wrapper_func* _wrapper;
         void* _handler;
-};
+    };
+
+    struct CommandPermissions
+    {
+        CommandPermissions() : RequiredPermission{}, AllowConsole{} {}
+        CommandPermissions(rbac::RBACPermissions perm, Trinity::ChatCommands::Console console) : RequiredPermission{ perm }, AllowConsole{ console } {}
+        rbac::RBACPermissions RequiredPermission;
+        Trinity::ChatCommands::Console AllowConsole;
+    };
+
+    class ChatCommandNode
+    {
+        friend struct FilteredCommandListIterator;
+        using ChatCommandBuilder = Trinity::ChatCommands::ChatCommandBuilder;
+
+        public:
+            static void LoadCommandMap();
+            static void InvalidateCommandMap();
+            static bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
+            static void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
+            static std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
+
+            ChatCommandNode() : _invoker{}, _permission{}, _help{}, _subCommands{} {}
+
+        private:
+            static std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> const& GetTopLevelMap();
+            static void LoadCommandsIntoMap(ChatCommandNode* blank, std::map<std::string_view, ChatCommandNode, StringCompareLessI_T>& map, Trinity::ChatCommands::ChatCommandTable const& commands);
+
+            void LoadFromBuilder(ChatCommandBuilder const& builder);
+            ChatCommandNode(ChatCommandNode&& other) = default;
+
+            void AssertCommandHelp(std::string_view name) const;
+            void SendCommandHelp(ChatHandler& handler) const;
+
+            bool IsVisible(ChatHandler const& who) const { return (IsInvokerVisible(who) || HasVisibleSubCommands(who)); }
+            bool IsInvokerVisible(ChatHandler const& who) const;
+            bool HasVisibleSubCommands(ChatHandler const& who) const;
+
+            CommandInvoker _invoker;
+            CommandPermissions _permission;
+            std::string _help;
+            std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> _subCommands;
+    };
+}
+
+namespace Trinity::ChatCommands
+{
+    struct ChatCommandBuilder
+    {
+        friend class Trinity::Impl::ChatCommands::ChatCommandNode;
+        using InvokerEntry = std::pair<Trinity::Impl::ChatCommands::CommandInvoker, Trinity::Impl::ChatCommands::CommandPermissions>;
+        using SubCommandEntry = std::reference_wrapper<std::vector<ChatCommandBuilder> const>;
+
+        template <typename TypedHandler>
+        ChatCommandBuilder(char const* name, TypedHandler& handler, rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
+        {}
+        ChatCommandBuilder(char const* name, std::vector<ChatCommandBuilder> const& subCommands)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<SubCommandEntry>, subCommands }
+        {}
+        ChatCommandBuilder(ChatCommandBuilder const&) = default;
+
+        /* deprecated: char const* parameters to command handlers */
+        [[deprecated]] ChatCommandBuilder(char const* name, bool(&handler)(ChatHandler*, char const*), rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
+        {}
+
+        /* deprecated: old-style command table format */
+        template <typename TypedHandler>
+        [[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions permission, bool console, TypedHandler* handler, char const*)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(*handler), std::forward_as_tuple(permission, static_cast<Trinity::ChatCommands::Console>(console)) }
+        {}
+        [[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions, bool, std::nullptr_t, char const*, std::vector <ChatCommandBuilder> const& sub)
+            : _name{ ASSERT_NOTNULL(name) }, _data { std::in_place_type<SubCommandEntry>, sub }
+        {}
+
+    private:
+        std::string_view _name;
+        std::variant<InvokerEntry, SubCommandEntry> _data;
+    };
+
+    TC_GAME_API void LoadCommandMap();
+    TC_GAME_API void InvalidateCommandMap();
+    TC_GAME_API bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
+    TC_GAME_API void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
+    TC_GAME_API std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
+}
+
+// backwards compatibility with old patches
+using ChatCommand [[deprecated]] = Trinity::ChatCommands::ChatCommandBuilder;
 
 #endif
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
index 8d2af4e7930..5d51e7c6da6 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
@@ -81,7 +81,7 @@ namespace Trinity::Impl::ChatCommands
     template <>
     struct ArgInfo<char const*, void>
     {
-        static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = args.data(); return std::string_view(); }
+        static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = (args.empty() ? "" : args.data()); return std::string_view(); }
     };
 
     // string_view