17 files changed, 479 insertions, 262 deletions

diff --git a/src/server/game/AI/CreatureAI.h b/src/server/game/AI/CreatureAI.h
index 0f488e4925a..984cbab6da8 100644
--- a/src/server/game/AI/CreatureAI.h
+++ b/src/server/game/AI/CreatureAI.h
@@ -68,13 +68,14 @@ class TC_GAME_API CreatureAI : public UnitAI
         Creature* DoSummonFlyer(uint32 entry, WorldObject* obj, float flightZ, float radius = 5.0f, Milliseconds despawnTime = 30s, TempSummonType summonType = TEMPSUMMON_CORPSE_TIMED_DESPAWN);
 
     public:
+        // EnumUtils: DESCRIBE THIS (in CreatureAI::)
         enum EvadeReason
         {
             EVADE_REASON_NO_HOSTILES,       // the creature's threat list is empty
             EVADE_REASON_BOUNDARY,          // the creature has moved outside its evade boundary
             EVADE_REASON_NO_PATH,           // the creature was unable to reach its target for over 5 seconds
             EVADE_REASON_SEQUENCE_BREAK,    // this is a boss and the pre-requisite encounters for engaging it are not defeated yet
-            EVADE_REASON_OTHER
+            EVADE_REASON_OTHER,             // anything else
         };
 
         explicit CreatureAI(Creature* creature, uint32 scriptId = {});
diff --git a/src/server/game/AI/enuminfo_CreatureAI.cpp b/src/server/game/AI/enuminfo_CreatureAI.cpp
new file mode 100644
index 00000000000..c2865d4ebc4
--- /dev/null
+++ b/src/server/game/AI/enuminfo_CreatureAI.cpp
@@ -0,0 +1,73 @@
+/*
+ * 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 "CreatureAI.h"
+#include "Define.h"
+#include "SmartEnum.h"
+#include <stdexcept>
+
+namespace Trinity::Impl::EnumUtilsImpl
+{
+
+/****************************************************************************\
+|* data for enum 'CreatureAI::EvadeReason' in 'CreatureAI.h' auto-generated *|
+\****************************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<CreatureAI::EvadeReason>::ToString(CreatureAI::EvadeReason value)
+{
+    switch (value)
+    {
+        case CreatureAI::EVADE_REASON_NO_HOSTILES: return { "EVADE_REASON_NO_HOSTILES", "EVADE_REASON_NO_HOSTILES", "the creature's threat list is empty" };
+        case CreatureAI::EVADE_REASON_BOUNDARY: return { "EVADE_REASON_BOUNDARY", "EVADE_REASON_BOUNDARY", "the creature has moved outside its evade boundary" };
+        case CreatureAI::EVADE_REASON_NO_PATH: return { "EVADE_REASON_NO_PATH", "EVADE_REASON_NO_PATH", "the creature was unable to reach its target for over 5 seconds" };
+        case CreatureAI::EVADE_REASON_SEQUENCE_BREAK: return { "EVADE_REASON_SEQUENCE_BREAK", "EVADE_REASON_SEQUENCE_BREAK", "this is a boss and the pre-requisite encounters for engaging it are not defeated yet" };
+        case CreatureAI::EVADE_REASON_OTHER: return { "EVADE_REASON_OTHER", "EVADE_REASON_OTHER", "anything else" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<CreatureAI::EvadeReason>::Count() { return 5; }
+
+template <>
+TC_API_EXPORT CreatureAI::EvadeReason EnumUtils<CreatureAI::EvadeReason>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return CreatureAI::EVADE_REASON_NO_HOSTILES;
+        case 1: return CreatureAI::EVADE_REASON_BOUNDARY;
+        case 2: return CreatureAI::EVADE_REASON_NO_PATH;
+        case 3: return CreatureAI::EVADE_REASON_SEQUENCE_BREAK;
+        case 4: return CreatureAI::EVADE_REASON_OTHER;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<CreatureAI::EvadeReason>::ToIndex(CreatureAI::EvadeReason value)
+{
+    switch (value)
+    {
+        case CreatureAI::EVADE_REASON_NO_HOSTILES: return 0;
+        case CreatureAI::EVADE_REASON_BOUNDARY: return 1;
+        case CreatureAI::EVADE_REASON_NO_PATH: return 2;
+        case CreatureAI::EVADE_REASON_SEQUENCE_BREAK: return 3;
+        case CreatureAI::EVADE_REASON_OTHER: return 4;
+        default: throw std::out_of_range("value");
+    }
+}
+}
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.h b/src/server/game/Chat/ChatCommands/ChatCommand.h
index 616b4984460..28d84629eea 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommand.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommand.h
@@ -44,32 +44,6 @@ namespace Trinity::Impl::ChatCommands
         }
     };
 
-    template <typename... Ts>
-    struct SingleConsumer<Trinity::ChatCommands::Variant<Ts...>>
-    {
-        using V = std::variant<Ts...>;
-        static constexpr size_t N = std::variant_size_v<V>;
-
-        template <size_t I>
-        static Optional<std::string_view> TryAtIndex(Trinity::ChatCommands::Variant<Ts...>& val, [[maybe_unused]] std::string_view args)
-        {
-            if constexpr (I < N)
-            {
-                if (Optional<std::string_view> next = SingleConsumer<std::variant_alternative_t<I, V>>::TryConsumeTo(val.template emplace<I>(), args))
-                    return next;
-                else
-                    return TryAtIndex<I+1>(val, args);
-            }
-            else
-                return std::nullopt;
-        }
-
-        static Optional<std::string_view> TryConsumeTo(Trinity::ChatCommands::Variant<Ts...>& val, std::string_view args)
-        {
-            return TryAtIndex<0>(val, args);
-        }
-    };
-
     /*
       for backwards compatibility, consumes the rest of the string
       new code should use the Tail/WTail tags defined in ChatCommandTags
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
index df74ac40e26..e3454bc5240 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
@@ -51,7 +51,7 @@ Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<CurrencyTypesEnt
     Optional<std::string_view> next = SingleConsumer<decltype(val)>::TryConsumeTo(val, args);
     if (next)
         data = val.visit(CurrencyTypesVisitor());
-    return args;
+    return next;
 }
 
 struct GameTeleVisitor
@@ -69,6 +69,21 @@ Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<GameTele const*>
     return next;
 }
 
+struct ItemTemplateVisitor
+{
+    using value_type = ItemTemplate const*;
+    value_type operator()(Hyperlink<item> item) const { return item->Item; }
+    value_type operator()(uint32 item) const { return sObjectMgr->GetItemTemplate(item); }
+};
+Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<ItemTemplate const*>::TryConsume(ItemTemplate const*& data, std::string_view args)
+{
+    Variant<Hyperlink<item>, uint32> val;
+    Optional<std::string_view> next = SingleConsumer<decltype(val)>::TryConsumeTo(val, args);
+    if (next)
+        data = val.visit(ItemTemplateVisitor());
+    return next;
+}
+
 struct SpellInfoVisitor
 {
     using value_type = SpellInfo const*;
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
index bdd0be0aace..21f27b45752 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
@@ -33,238 +33,274 @@ struct GameTele;
 namespace Trinity::Impl::ChatCommands
 {
 
-/************************** ARGUMENT HANDLERS *******************************************\
-|* Define how to extract contents of a certain requested type from a string             *|
-|* Must implement the following:                                                        *|
-|* - TryConsume: T&, std::string_view -> Optional<std::string_view>                     *|
-|*   returns nullopt if no match, otherwise tail of argument string                     *|
-|*     - if nullopt is returned, state of T& is indeterminate                           *|
-|*     - otherwise, T& should be initialized to the intended return value               *|
-|*                                                                                      *|
-\****************************************************************************************/
-template <typename T, typename = void>
-struct ArgInfo { static_assert(Trinity::dependant_false_v<T>, "Invalid command parameter type - see ChatCommandArgs.h for possible types"); };
-
-// catch-all for number types
-template <typename T>
-struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>>>
-{
-    static Optional<std::string_view> TryConsume(T& val, std::string_view args)
+    /************************** ARGUMENT HANDLERS *******************************************\
+    |* Define how to extract contents of a certain requested type from a string             *|
+    |* Must implement the following:                                                        *|
+    |* - TryConsume: T&, std::string_view -> Optional<std::string_view>                     *|
+    |*   returns nullopt if no match, otherwise tail of argument string                     *|
+    |*     - if nullopt is returned, state of T& is indeterminate                           *|
+    |*     - otherwise, T& should be initialized to the intended return value               *|
+    |*                                                                                      *|
+    \****************************************************************************************/
+    template <typename T, typename = void>
+    struct ArgInfo { static_assert(Trinity::dependant_false_v<T>, "Invalid command parameter type - see ChatCommandArgs.h for possible types"); };
+
+    // catch-all for number types
+    template <typename T>
+    struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>>>
     {
-        auto [token, tail] = tokenize(args);
-        if (token.empty())
-            return std::nullopt;
+        static Optional<std::string_view> TryConsume(T& val, std::string_view args)
+        {
+            auto [token, tail] = tokenize(args);
+            if (token.empty())
+                return std::nullopt;
 
-        if (Optional<T> v = StringTo<T>(token, 0))
-            val = *v;
-        else
-            return std::nullopt;
+            if (Optional<T> v = StringTo<T>(token, 0))
+                val = *v;
+            else
+                return std::nullopt;
+
+            if constexpr (std::is_floating_point_v<T>)
+            {
+                if (!std::isfinite(val))
+                    return std::nullopt;
+            }
+
+            return tail;
+        }
+    };
 
-        if constexpr (std::is_floating_point_v<T>)
+    // string_view
+    template <>
+    struct ArgInfo<std::string_view, void>
+    {
+        static Optional<std::string_view> TryConsume(std::string_view& val, std::string_view args)
         {
-            if (!std::isfinite(val))
+            auto [token, next] = tokenize(args);
+            if (token.empty())
                 return std::nullopt;
+            val = token;
+            return next;
         }
+    };
 
-        return tail;
-    }
-};
-
-// string_view
-template <>
-struct ArgInfo<std::string_view, void>
-{
-    static Optional<std::string_view> TryConsume(std::string_view& val, std::string_view args)
-    {
-        auto [token, next] = tokenize(args);
-        if (token.empty())
-            return std::nullopt;
-        val = token;
-        return next;
-    }
-};
-
-// string
-template <>
-struct ArgInfo<std::string, void>
-{
-    static Optional<std::string_view> TryConsume(std::string& val, std::string_view args)
-    {
-        std::string_view view;
-        Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(view, args);
-        if (next)
-            val.assign(view);
-        return next;
-    }
-};
-
-// wstring
-template <>
-struct ArgInfo<std::wstring, void>
-{
-    static Optional<std::string_view> TryConsume(std::wstring& val, std::string_view args)
+    // string
+    template <>
+    struct ArgInfo<std::string, void>
     {
-        std::string_view utf8view;
-        Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(utf8view, args);
-
-        if (next && Utf8toWStr(utf8view, val))
+        static Optional<std::string_view> TryConsume(std::string& val, std::string_view args)
+        {
+            std::string_view view;
+            Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(view, args);
+            if (next)
+                val.assign(view);
             return next;
-        else
-            return std::nullopt;
-    }
-};
+        }
+    };
 
-// enum
-template <typename T>
-struct ArgInfo<T, std::enable_if_t<std::is_enum_v<T>>>
-{
-    static std::map<std::string, Optional<T>> MakeSearchMap()
+    // wstring
+    template <>
+    struct ArgInfo<std::wstring, void>
     {
-        std::map<std::string, Optional<T>> map;
-        for (T val : EnumUtils::Iterate<T>())
+        static Optional<std::string_view> TryConsume(std::wstring& val, std::string_view args)
         {
-            EnumText text = EnumUtils::ToString(val);
+            std::string_view utf8view;
+            Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(utf8view, args);
 
-            std::string title(text.Title);
-            strToLower(title);
-            std::string constant(text.Constant);
-            strToLower(constant);
-
-            auto [constantIt, constantNew] = map.try_emplace(constant, val);
-            if (!constantNew)
-                constantIt->second = std::nullopt;
+            if (next && Utf8toWStr(utf8view, val))
+                return next;
+            else
+                return std::nullopt;
+        }
+    };
 
-            if (title != constant)
+    // enum
+    template <typename T>
+    struct ArgInfo<T, std::enable_if_t<std::is_enum_v<T>>>
+    {
+        static std::map<std::string, Optional<T>> MakeSearchMap()
+        {
+            std::map<std::string, Optional<T>> map;
+            for (T val : EnumUtils::Iterate<T>())
             {
-                auto [titleIt, titleNew] = map.try_emplace(title, val);
-                if (!titleNew)
-                    titleIt->second = std::nullopt;
+                EnumText text = EnumUtils::ToString(val);
+
+                std::string title(text.Title);
+                strToLower(title);
+                std::string constant(text.Constant);
+                strToLower(constant);
+
+                auto [constantIt, constantNew] = map.try_emplace(constant, val);
+                if (!constantNew)
+                    constantIt->second = std::nullopt;
+
+                if (title != constant)
+                {
+                    auto [titleIt, titleNew] = map.try_emplace(title, val);
+                    if (!titleNew)
+                        titleIt->second = std::nullopt;
+                }
             }
+            return map;
         }
-        return map;
-    }
 
-    static inline std::map<std::string, Optional<T>> const SearchMap = MakeSearchMap();
+        static inline std::map<std::string, Optional<T>> const SearchMap = MakeSearchMap();
 
-    static T const* Match(std::string s)
-    {
-        strToLower(s);
+        static T const* Match(std::string s)
+        {
+            strToLower(s);
 
-        auto it = SearchMap.lower_bound(s);
-        if (it == SearchMap.end() || !StringStartsWith(it->first, s)) // not a match
-            return nullptr;
+            auto it = SearchMap.lower_bound(s);
+            if (it == SearchMap.end() || !StringStartsWith(it->first, s)) // not a match
+                return nullptr;
 
-        if (it->first != s) // we don't have an exact match - check if it is unique
-        {
-            auto it2 = it;
-            ++it2;
-            if (it2 != SearchMap.end() && StringStartsWith(it2->first, s)) // not unique
+            if (it->first != s) // we don't have an exact match - check if it is unique
+            {
+                auto it2 = it;
+                ++it2;
+                if (it2 != SearchMap.end() && StringStartsWith(it2->first, s)) // not unique
+                    return nullptr;
+            }
+
+            if (it->second)
+                return &*it->second;
+            else
                 return nullptr;
         }
 
-        if (it->second)
-            return &*it->second;
-        else
-            return nullptr;
-    }
+        static Optional<std::string_view> TryConsume(T& val, std::string_view args)
+        {
+            std::string strVal;
+            Optional<std::string_view> next = ArgInfo<std::string>::TryConsume(strVal, args);
 
-    static Optional<std::string_view> TryConsume(T& val, std::string_view args)
-    {
-        std::string strVal;
-        Optional<std::string_view> next = ArgInfo<std::string>::TryConsume(strVal, args);
+            if (next)
+            {
+                if (T const* match = Match(strVal))
+                {
+                    val = *match;
+                    return next;
+                }
+            }
 
-        if (next)
-        {
-            if (T const* match = Match(strVal))
+            // Value not found. Try to parse arg as underlying type and cast it to enum type
+            using U = std::underlying_type_t<T>;
+            U uVal = 0;
+            next = ArgInfo<U>::TryConsume(uVal, args);
+            if (next && EnumUtils::IsValid<T>(uVal))
             {
-                val = *match;
+                val = static_cast<T>(uVal);
                 return next;
             }
+
+            return std::nullopt;
         }
+    };
 
-        // Value not found. Try to parse arg as underlying type and cast it to enum type
-        using U = std::underlying_type_t<T>;
-        U uVal = 0;
-        next = ArgInfo<U>::TryConsume(uVal, args);
-        if (next && EnumUtils::IsValid<T>(uVal))
+    // a container tag
+    template <typename T>
+    struct ArgInfo<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>>
+    {
+        static Optional<std::string_view> TryConsume(T& tag, std::string_view args)
         {
-            val = static_cast<T>(uVal);
-            return next;
+            return tag.TryConsume(args);
         }
+    };
 
-        return std::nullopt;
-    }
-};
-
-// a container tag
-template <typename T>
-struct ArgInfo<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>>
-{
-    static Optional<std::string_view> TryConsume(T& tag, std::string_view args)
+    // non-empty vector
+    template <typename T>
+    struct ArgInfo<std::vector<T>, void>
     {
-        return tag.TryConsume(args);
-    }
-};
+        static Optional<std::string_view> TryConsume(std::vector<T>& val, std::string_view args)
+        {
+            val.clear();
+            Optional<std::string_view> next = ArgInfo<T>::TryConsume(val.emplace_back(), args);
 
-template <typename T>
-struct ArgInfo<std::vector<T>, void>
-{
-    static Optional<std::string_view> TryConsume(std::vector<T>& val, std::string_view args)
-    {
-        val.clear();
-        Optional<std::string_view> next = ArgInfo<T>::TryConsume(val.emplace_back(), args);
+            if (!next)
+                return std::nullopt;
 
-        if (!next)
-            return std::nullopt;
+            while (Optional<std::string_view> next2 = ArgInfo<T>::TryConsume(val.emplace_back(), *next))
+                next = next2;
 
-        while (Optional<std::string_view> next2 = ArgInfo<T>::TryConsume(val.emplace_back(), *next))
-            next = next2;
+            val.pop_back();
+            return next;
+        }
+    };
 
-        val.pop_back();
-        return next;
-    }
-};
+    // fixed-size array
+    template <typename T, size_t N>
+    struct ArgInfo<std::array<T, N>, void>
+    {
+        static Optional<std::string_view> TryConsume(std::array<T, N>& val, std::string_view args)
+        {
+            Optional<std::string_view> next = args;
+            for (T& t : val)
+                if (!(next = ArgInfo<T>::TryConsume(t, *next)))
+                    return std::nullopt;
+            return next;
+        }
+    };
 
-template <typename T, size_t N>
-struct ArgInfo<std::array<T, N>, void>
-{
-    static Optional<std::string_view> TryConsume(std::array<T, N>& val, std::string_view args)
+    // variant
+    template <typename... Ts>
+    struct ArgInfo<Trinity::ChatCommands::Variant<Ts...>>
     {
-        Optional<std::string_view> next = args;
-        for (T& t : val)
-            if (!(next = ArgInfo<T>::TryConsume(t, *next)))
+        using V = std::variant<Ts...>;
+        static constexpr size_t N = std::variant_size_v<V>;
+
+        template <size_t I>
+        static Optional<std::string_view> TryAtIndex(Trinity::ChatCommands::Variant<Ts...>& val, [[maybe_unused]] std::string_view args)
+        {
+            if constexpr (I < N)
+            {
+                if (Optional<std::string_view> next = ArgInfo<std::variant_alternative_t<I, V>>::TryConsume(val.template emplace<I>(), args))
+                    return next;
+                else
+                    return TryAtIndex<I + 1>(val, args);
+            }
+            else
                 return std::nullopt;
-        return next;
-    }
-};
+        }
 
-// AchievementEntry* from numeric id or link
-template <>
-struct TC_GAME_API ArgInfo<AchievementEntry const*>
-{
-    static Optional<std::string_view> TryConsume(AchievementEntry const*&, std::string_view);
-};
+        static Optional<std::string_view> TryConsume(Trinity::ChatCommands::Variant<Ts...>& val, std::string_view args)
+        {
+            return TryAtIndex<0>(val, args);
+        }
+    };
 
-// CurrencyTypesEntry* from numeric id or link
-template <>
-struct TC_GAME_API ArgInfo<CurrencyTypesEntry const*>
-{
-    static Optional<std::string_view> TryConsume(CurrencyTypesEntry const*&, std::string_view);
-};
+    // AchievementEntry* from numeric id or link
+    template <>
+    struct TC_GAME_API ArgInfo<AchievementEntry const*>
+    {
+        static Optional<std::string_view> TryConsume(AchievementEntry const*&, std::string_view);
+    };
 
-// GameTele* from string name or link
-template <>
-struct TC_GAME_API ArgInfo<GameTele const*>
-{
-    static Optional<std::string_view> TryConsume(GameTele const*&, std::string_view);
-};
+    // CurrencyTypesEntry* from numeric id or link
+    template <>
+    struct TC_GAME_API ArgInfo<CurrencyTypesEntry const*>
+    {
+        static Optional<std::string_view> TryConsume(CurrencyTypesEntry const*&, std::string_view);
+    };
 
-// SpellInfo const* from spell id or link
-template <>
-struct TC_GAME_API ArgInfo<SpellInfo const*>
-{
-    static Optional<std::string_view> TryConsume(SpellInfo const*&, std::string_view);
-};
+    // GameTele* from string name or link
+    template <>
+    struct TC_GAME_API ArgInfo<GameTele const*>
+    {
+        static Optional<std::string_view> TryConsume(GameTele const*&, std::string_view);
+    };
+
+    // ItemTemplate* from numeric id or link
+    template <>
+    struct TC_GAME_API ArgInfo<ItemTemplate const*>
+    {
+        static Optional<std::string_view> TryConsume(ItemTemplate const*&, std::string_view);
+    };
+
+    // SpellInfo const* from spell id or link
+    template <>
+    struct TC_GAME_API ArgInfo<SpellInfo const*>
+    {
+        static Optional<std::string_view> TryConsume(SpellInfo const*&, std::string_view);
+    };
 
 }
 
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h b/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h
index c6cf4f8ad94..712d0c37d48 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h
@@ -65,6 +65,12 @@ namespace Trinity::Impl::ChatCommands
         static constexpr bool value = (std::is_assignable_v<T&, Ts> && ...);
     };
 
+    template <typename... Ts>
+    struct are_all_assignable<void, Ts...>
+    {
+        static constexpr bool value = false;
+    };
+
     template <std::size_t index, typename T1, typename... Ts>
     struct get_nth : get_nth<index-1, Ts...> { };
 
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandTags.h b/src/server/game/Chat/ChatCommands/ChatCommandTags.h
index 3c8c778d5ea..cf6df77da8d 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandTags.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandTags.h
@@ -65,7 +65,7 @@ namespace Trinity::ChatCommands
 
         static bool Match(char const* pos)
         {
-            if (*(pos++) != c1)
+            if (std::toupper(*(pos++)) != std::toupper(c1))
                 return false;
             else if constexpr (sizeof...(chars) > 0)
                 return ExactSequence<chars...>::Match(pos);
@@ -151,10 +151,6 @@ namespace Trinity::ChatCommands
     using namespace ::Trinity::Hyperlinks::LinkTags;
 }
 
-/************************** VARIANT TAG LOGIC *********************************\
-|* This has some special handling over in ChatCommand.h                       *|
-\******************************************************************************/
-
 namespace Trinity::Impl
 {
     template <typename T>
diff --git a/src/server/game/Chat/Hyperlinks.h b/src/server/game/Chat/Hyperlinks.h
index 963262018d5..4b04e706e75 100644
--- a/src/server/game/Chat/Hyperlinks.h
+++ b/src/server/game/Chat/Hyperlinks.h
@@ -263,7 +263,7 @@ namespace Trinity::Hyperlinks
         make_base_tag(gameobject, ObjectGuid::LowType);
         make_base_tag(gameobject_entry, uint32);
         make_base_tag(itemset, uint32);
-        make_base_tag(player, std::string const&);
+        make_base_tag(player, std::string_view);
         make_base_tag(skill, uint32);
         make_base_tag(taxinode, uint32);
         make_base_tag(tele, uint32);
diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index 740811c3132..3324a836751 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -22034,7 +22034,7 @@ void Player::StopCastingCharm()
     }
 }
 
-void Player::Say(std::string const& text, Language language, WorldObject const* /*= nullptr*/)
+void Player::Say(std::string_view text, Language language, WorldObject const* /*= nullptr*/)
 {
     std::string _text(text);
     sScriptMgr->OnPlayerChat(this, CHAT_MSG_SAY, language, _text);
@@ -22060,7 +22060,7 @@ void Player::Say(uint32 textId, WorldObject const* target /*= nullptr*/)
     Talk(textId, CHAT_MSG_SAY, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
 }
 
-void Player::Yell(std::string const& text, Language language, WorldObject const* /*= nullptr*/)
+void Player::Yell(std::string_view text, Language language, WorldObject const* /*= nullptr*/)
 {
     std::string _text(text);
     sScriptMgr->OnPlayerChat(this, CHAT_MSG_YELL, language, _text);
@@ -22073,7 +22073,7 @@ void Player::Yell(uint32 textId, WorldObject const* target /*= nullptr*/)
     Talk(textId, CHAT_MSG_YELL, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_YELL), target);
 }
 
-void Player::TextEmote(std::string const& text, WorldObject const* /*= nullptr*/, bool /*= false*/)
+void Player::TextEmote(std::string_view text, WorldObject const* /*= nullptr*/, bool /*= false*/)
 {
     std::string _text(text);
     sScriptMgr->OnPlayerChat(this, CHAT_MSG_EMOTE, LANG_UNIVERSAL, _text);
@@ -22101,7 +22101,7 @@ void Player::TextEmote(uint32 textId, WorldObject const* target /*= nullptr*/, b
     Talk(textId, CHAT_MSG_EMOTE, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
 }
 
-void Player::Whisper(std::string const& text, Language language, Player* target, bool /*= false*/)
+void Player::Whisper(std::string_view text, Language language, Player* target, bool /*= false*/)
 {
     ASSERT(target);
 
diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
index f79818ffec8..1a69fb98b8d 100644
--- a/src/server/game/Entities/Player/Player.h
+++ b/src/server/game/Entities/Player/Player.h
@@ -1224,16 +1224,16 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void SetBattlePetData(BattlePets::BattlePet const* pet = nullptr);
 
         /// Handles said message in regular chat based on declared language and in config pre-defined Range.
-        void Say(std::string const& text, Language language, WorldObject const* = nullptr) override;
+        void Say(std::string_view text, Language language, WorldObject const* = nullptr) override;
         void Say(uint32 textId, WorldObject const* target = nullptr) override;
         /// Handles yelled message in regular chat based on declared language and in config pre-defined Range.
-        void Yell(std::string const& text, Language language, WorldObject const* = nullptr) override;
+        void Yell(std::string_view text, Language language, WorldObject const* = nullptr) override;
         void Yell(uint32 textId, WorldObject const* target = nullptr) override;
         /// Outputs an universal text which is supposed to be an action.
-        void TextEmote(std::string const& text, WorldObject const* = nullptr, bool = false) override;
+        void TextEmote(std::string_view text, WorldObject const* = nullptr, bool = false) override;
         void TextEmote(uint32 textId, WorldObject const* target = nullptr, bool isBossEmote = false) override;
         /// Handles whispers from Addons and players based on sender, receiver's guid and language.
-        void Whisper(std::string const& text, Language language, Player* receiver, bool = false) override;
+        void Whisper(std::string_view text, Language language, Player* receiver, bool = false) override;
         void Whisper(uint32 textId, Player* target, bool isBossWhisper = false) override;
         void WhisperAddon(std::string const& text, std::string const& prefix, bool isLogged, Player* receiver);
 
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index b582cb833c9..8e490b828c8 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -13160,7 +13160,7 @@ bool Unit::IsHighestExclusiveAuraEffect(SpellInfo const* spellInfo, AuraType aur
     return true;
 }
 
-void Unit::Talk(std::string const& text, ChatMsg msgType, Language language, float textRange, WorldObject const* target)
+void Unit::Talk(std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const* target)
 {
     Trinity::CustomChatTextBuilder builder(this, msgType, text, language, target);
     Trinity::LocalizedDo<Trinity::CustomChatTextBuilder> localizer(builder);
@@ -13168,22 +13168,22 @@ void Unit::Talk(std::string const& text, ChatMsg msgType, Language language, flo
     Cell::VisitWorldObjects(this, worker, textRange);
 }
 
-void Unit::Say(std::string const& text, Language language, WorldObject const* target /*= nullptr*/)
+void Unit::Say(std::string_view text, Language language, WorldObject const* target /*= nullptr*/)
 {
     Talk(text, CHAT_MSG_MONSTER_SAY, language, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
 }
 
-void Unit::Yell(std::string const& text, Language language, WorldObject const* target /*= nullptr*/)
+void Unit::Yell(std::string_view text, Language language, WorldObject const* target /*= nullptr*/)
 {
     Talk(text, CHAT_MSG_MONSTER_YELL, language, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_YELL), target);
 }
 
-void Unit::TextEmote(std::string const& text, WorldObject const* target /*= nullptr*/, bool isBossEmote /*= false*/)
+void Unit::TextEmote(std::string_view text, WorldObject const* target /*= nullptr*/, bool isBossEmote /*= false*/)
 {
     Talk(text, isBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, LANG_UNIVERSAL, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
 }
 
-void Unit::Whisper(std::string const& text, Language language, Player* target, bool isBossWhisper /*= false*/)
+void Unit::Whisper(std::string_view text, Language language, Player* target, bool isBossWhisper /*= false*/)
 {
     if (!target)
         return;
diff --git a/src/server/game/Entities/Unit/Unit.h b/src/server/game/Entities/Unit/Unit.h
index b1fcabf673a..50e27c7f32b 100644
--- a/src/server/game/Entities/Unit/Unit.h
+++ b/src/server/game/Entities/Unit/Unit.h
@@ -1833,11 +1833,11 @@ class TC_GAME_API Unit : public WorldObject
         bool IsHighestExclusiveAura(Aura const* aura, bool removeOtherAuraApplications = false);
         bool IsHighestExclusiveAuraEffect(SpellInfo const* spellInfo, AuraType auraType, int32 effectAmount, uint32 auraEffectMask, bool removeOtherAuraApplications = false);
 
-        virtual void Talk(std::string const& text, ChatMsg msgType, Language language, float textRange, WorldObject const* target);
-        virtual void Say(std::string const& text, Language language, WorldObject const* target = nullptr);
-        virtual void Yell(std::string const& text, Language language, WorldObject const* target = nullptr);
-        virtual void TextEmote(std::string const& text, WorldObject const* target = nullptr, bool isBossEmote = false);
-        virtual void Whisper(std::string const& text, Language language, Player* target, bool isBossWhisper = false);
+        virtual void Talk(std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const* target);
+        virtual void Say(std::string_view text, Language language, WorldObject const* target = nullptr);
+        virtual void Yell(std::string_view text, Language language, WorldObject const* target = nullptr);
+        virtual void TextEmote(std::string_view text, WorldObject const* target = nullptr, bool isBossEmote = false);
+        virtual void Whisper(std::string_view text, Language language, Player* target, bool isBossWhisper = false);
         virtual void Talk(uint32 textId, ChatMsg msgType, float textRange, WorldObject const* target);
         virtual void Say(uint32 textId, WorldObject const* target = nullptr);
         virtual void Yell(uint32 textId, WorldObject const* target = nullptr);
diff --git a/src/server/game/Globals/ObjectAccessor.cpp b/src/server/game/Globals/ObjectAccessor.cpp
index 19545d81b7c..d7e8739d9ca 100644
--- a/src/server/game/Globals/ObjectAccessor.cpp
+++ b/src/server/game/Globals/ObjectAccessor.cpp
@@ -78,28 +78,28 @@ template class TC_GAME_API HashMapHolder<Transport>;
 
 namespace PlayerNameMapHolder
 {
-typedef std::unordered_map<std::string, Player*> MapType;
-static MapType PlayerNameMap;
+    typedef std::unordered_map<std::string, Player*> MapType;
+    static MapType PlayerNameMap;
 
-void Insert(Player* p)
-{
-    PlayerNameMap[p->GetName()] = p;
-}
+    void Insert(Player* p)
+    {
+        PlayerNameMap[p->GetName()] = p;
+    }
 
-void Remove(Player* p)
-{
-    PlayerNameMap.erase(p->GetName());
-}
+    void Remove(Player* p)
+    {
+        PlayerNameMap.erase(p->GetName());
+    }
 
-Player* Find(std::string const& name)
-{
-    std::string charName(name);
-    if (!normalizePlayerName(charName))
-        return nullptr;
+    Player* Find(std::string_view name)
+    {
+        std::string charName(name);
+        if (!normalizePlayerName(charName))
+            return nullptr;
 
-    auto itr = PlayerNameMap.find(charName);
-    return (itr != PlayerNameMap.end()) ? itr->second : nullptr;
-}
+        auto itr = PlayerNameMap.find(charName);
+        return (itr != PlayerNameMap.end()) ? itr->second : nullptr;
+    }
 } // namespace PlayerNameMapHolder
 
 WorldObject* ObjectAccessor::GetWorldObject(WorldObject const& p, ObjectGuid const& guid)
@@ -264,7 +264,7 @@ Player* ObjectAccessor::FindPlayer(ObjectGuid const& guid)
     return player && player->IsInWorld() ? player : nullptr;
 }
 
-Player* ObjectAccessor::FindPlayerByName(std::string const& name)
+Player* ObjectAccessor::FindPlayerByName(std::string_view name)
 {
     Player* player = PlayerNameMapHolder::Find(name);
     if (!player || !player->IsInWorld())
@@ -284,7 +284,7 @@ Player* ObjectAccessor::FindConnectedPlayer(ObjectGuid const& guid)
     return HashMapHolder<Player>::Find(guid);
 }
 
-Player* ObjectAccessor::FindConnectedPlayerByName(std::string const& name)
+Player* ObjectAccessor::FindConnectedPlayerByName(std::string_view name)
 {
     return PlayerNameMapHolder::Find(name);
 }
diff --git a/src/server/game/Globals/ObjectAccessor.h b/src/server/game/Globals/ObjectAccessor.h
index b5bb368041d..1ff11bb6b77 100644
--- a/src/server/game/Globals/ObjectAccessor.h
+++ b/src/server/game/Globals/ObjectAccessor.h
@@ -81,12 +81,12 @@ namespace ObjectAccessor
     // these functions return objects if found in whole world
     // ACCESS LIKE THAT IS NOT THREAD SAFE
     TC_GAME_API Player* FindPlayer(ObjectGuid const&);
-    TC_GAME_API Player* FindPlayerByName(std::string const& name);
+    TC_GAME_API Player* FindPlayerByName(std::string_view name);
     TC_GAME_API Player* FindPlayerByLowGUID(ObjectGuid::LowType lowguid);
 
     // this returns Player even if he is not in world, for example teleporting
     TC_GAME_API Player* FindConnectedPlayer(ObjectGuid const&);
-    TC_GAME_API Player* FindConnectedPlayerByName(std::string const& name);
+    TC_GAME_API Player* FindConnectedPlayerByName(std::string_view name);
 
     // when using this, you must use the hashmapholder's lock
     TC_GAME_API HashMapHolder<Player>::MapType const& GetPlayers();
diff --git a/src/server/game/Movement/MovementDefines.h b/src/server/game/Movement/MovementDefines.h
index 224d1399a31..51c588c703b 100644
--- a/src/server/game/Movement/MovementDefines.h
+++ b/src/server/game/Movement/MovementDefines.h
@@ -24,6 +24,7 @@
 
 #define SPEED_CHARGE 42.0f // assume it is 25 yard per 0.6 second
 
+// EnumUtils: DESCRIBE THIS
 enum MovementGeneratorType : uint8
 {
     IDLE_MOTION_TYPE                = 0,     // IdleMovementGenerator.h
@@ -45,7 +46,7 @@ enum MovementGeneratorType : uint8
     EFFECT_MOTION_TYPE              = 16,
     SPLINE_CHAIN_MOTION_TYPE        = 17,    // SplineChainMovementGenerator.h
     FORMATION_MOTION_TYPE           = 18,    // FormationMovementGenerator.h
-    MAX_MOTION_TYPE                          // limit
+    MAX_MOTION_TYPE                          // SKIP
 };
 
 enum MovementGeneratorMode : uint8
diff --git a/src/server/game/Movement/enuminfo_MovementDefines.cpp b/src/server/game/Movement/enuminfo_MovementDefines.cpp
new file mode 100644
index 00000000000..e22c45c5174
--- /dev/null
+++ b/src/server/game/Movement/enuminfo_MovementDefines.cpp
@@ -0,0 +1,115 @@
+/*
+ * 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 "MovementDefines.h"
+#include "Define.h"
+#include "SmartEnum.h"
+#include <stdexcept>
+
+namespace Trinity::Impl::EnumUtilsImpl
+{
+
+/*******************************************************************************\
+|* data for enum 'MovementGeneratorType' in 'MovementDefines.h' auto-generated *|
+\*******************************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<MovementGeneratorType>::ToString(MovementGeneratorType value)
+{
+    switch (value)
+    {
+        case IDLE_MOTION_TYPE: return { "IDLE_MOTION_TYPE", "IDLE_MOTION_TYPE", "IdleMovementGenerator.h" };
+        case RANDOM_MOTION_TYPE: return { "RANDOM_MOTION_TYPE", "RANDOM_MOTION_TYPE", "RandomMovementGenerator.h" };
+        case WAYPOINT_MOTION_TYPE: return { "WAYPOINT_MOTION_TYPE", "WAYPOINT_MOTION_TYPE", "WaypointMovementGenerator.h" };
+        case MAX_DB_MOTION_TYPE: return { "MAX_DB_MOTION_TYPE", "MAX_DB_MOTION_TYPE", "Below motion types can't be set in DB." };
+        case CONFUSED_MOTION_TYPE: return { "CONFUSED_MOTION_TYPE", "CONFUSED_MOTION_TYPE", "ConfusedMovementGenerator.h" };
+        case CHASE_MOTION_TYPE: return { "CHASE_MOTION_TYPE", "CHASE_MOTION_TYPE", "ChaseMovementGenerator.h" };
+        case HOME_MOTION_TYPE: return { "HOME_MOTION_TYPE", "HOME_MOTION_TYPE", "HomeMovementGenerator.h" };
+        case FLIGHT_MOTION_TYPE: return { "FLIGHT_MOTION_TYPE", "FLIGHT_MOTION_TYPE", "FlightPathMovementGenerator.h" };
+        case POINT_MOTION_TYPE: return { "POINT_MOTION_TYPE", "POINT_MOTION_TYPE", "PointMovementGenerator.h" };
+        case FLEEING_MOTION_TYPE: return { "FLEEING_MOTION_TYPE", "FLEEING_MOTION_TYPE", "FleeingMovementGenerator.h" };
+        case DISTRACT_MOTION_TYPE: return { "DISTRACT_MOTION_TYPE", "DISTRACT_MOTION_TYPE", "IdleMovementGenerator.h" };
+        case ASSISTANCE_MOTION_TYPE: return { "ASSISTANCE_MOTION_TYPE", "ASSISTANCE_MOTION_TYPE", "PointMovementGenerator.h" };
+        case ASSISTANCE_DISTRACT_MOTION_TYPE: return { "ASSISTANCE_DISTRACT_MOTION_TYPE", "ASSISTANCE_DISTRACT_MOTION_TYPE", "IdleMovementGenerator.h" };
+        case TIMED_FLEEING_MOTION_TYPE: return { "TIMED_FLEEING_MOTION_TYPE", "TIMED_FLEEING_MOTION_TYPE", "FleeingMovementGenerator.h" };
+        case FOLLOW_MOTION_TYPE: return { "FOLLOW_MOTION_TYPE", "FOLLOW_MOTION_TYPE", "FollowMovementGenerator.h" };
+        case ROTATE_MOTION_TYPE: return { "ROTATE_MOTION_TYPE", "ROTATE_MOTION_TYPE", "IdleMovementGenerator.h" };
+        case EFFECT_MOTION_TYPE: return { "EFFECT_MOTION_TYPE", "EFFECT_MOTION_TYPE", "" };
+        case SPLINE_CHAIN_MOTION_TYPE: return { "SPLINE_CHAIN_MOTION_TYPE", "SPLINE_CHAIN_MOTION_TYPE", "SplineChainMovementGenerator.h" };
+        case FORMATION_MOTION_TYPE: return { "FORMATION_MOTION_TYPE", "FORMATION_MOTION_TYPE", "FormationMovementGenerator.h" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementGeneratorType>::Count() { return 19; }
+
+template <>
+TC_API_EXPORT MovementGeneratorType EnumUtils<MovementGeneratorType>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return IDLE_MOTION_TYPE;
+        case 1: return RANDOM_MOTION_TYPE;
+        case 2: return WAYPOINT_MOTION_TYPE;
+        case 3: return MAX_DB_MOTION_TYPE;
+        case 4: return CONFUSED_MOTION_TYPE;
+        case 5: return CHASE_MOTION_TYPE;
+        case 6: return HOME_MOTION_TYPE;
+        case 7: return FLIGHT_MOTION_TYPE;
+        case 8: return POINT_MOTION_TYPE;
+        case 9: return FLEEING_MOTION_TYPE;
+        case 10: return DISTRACT_MOTION_TYPE;
+        case 11: return ASSISTANCE_MOTION_TYPE;
+        case 12: return ASSISTANCE_DISTRACT_MOTION_TYPE;
+        case 13: return TIMED_FLEEING_MOTION_TYPE;
+        case 14: return FOLLOW_MOTION_TYPE;
+        case 15: return ROTATE_MOTION_TYPE;
+        case 16: return EFFECT_MOTION_TYPE;
+        case 17: return SPLINE_CHAIN_MOTION_TYPE;
+        case 18: return FORMATION_MOTION_TYPE;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementGeneratorType>::ToIndex(MovementGeneratorType value)
+{
+    switch (value)
+    {
+        case IDLE_MOTION_TYPE: return 0;
+        case RANDOM_MOTION_TYPE: return 1;
+        case WAYPOINT_MOTION_TYPE: return 2;
+        case MAX_DB_MOTION_TYPE: return 3;
+        case CONFUSED_MOTION_TYPE: return 4;
+        case CHASE_MOTION_TYPE: return 5;
+        case HOME_MOTION_TYPE: return 6;
+        case FLIGHT_MOTION_TYPE: return 7;
+        case POINT_MOTION_TYPE: return 8;
+        case FLEEING_MOTION_TYPE: return 9;
+        case DISTRACT_MOTION_TYPE: return 10;
+        case ASSISTANCE_MOTION_TYPE: return 11;
+        case ASSISTANCE_DISTRACT_MOTION_TYPE: return 12;
+        case TIMED_FLEEING_MOTION_TYPE: return 13;
+        case FOLLOW_MOTION_TYPE: return 14;
+        case ROTATE_MOTION_TYPE: return 15;
+        case EFFECT_MOTION_TYPE: return 16;
+        case SPLINE_CHAIN_MOTION_TYPE: return 17;
+        case FORMATION_MOTION_TYPE: return 18;
+        default: throw std::out_of_range("value");
+    }
+}
+}
diff --git a/src/server/game/Texts/ChatTextBuilder.h b/src/server/game/Texts/ChatTextBuilder.h
index 94ae1339652..40edaeebae7 100644
--- a/src/server/game/Texts/ChatTextBuilder.h
+++ b/src/server/game/Texts/ChatTextBuilder.h
@@ -71,7 +71,7 @@ namespace Trinity
     class CustomChatTextBuilder
     {
         public:
-            CustomChatTextBuilder(WorldObject const* obj, ChatMsg msgType, std::string const& text, Language language = LANG_UNIVERSAL, WorldObject const* target = nullptr)
+            CustomChatTextBuilder(WorldObject const* obj, ChatMsg msgType, std::string_view text, Language language = LANG_UNIVERSAL, WorldObject const* target = nullptr)
                 : _source(obj), _msgType(msgType), _text(text), _language(language), _target(target) { }
 
             ChatPacketSender* operator()(LocaleConstant locale) const;