diff --git a/conf/playerbots.conf.dist b/conf/playerbots.conf.dist
index d9f194747..b3a3d2ab0 100644
--- a/conf/playerbots.conf.dist
+++ b/conf/playerbots.conf.dist
@@ -651,9 +651,14 @@ AiPlayerbot.BotTaxiGapJitterMs = 100
 
 ####################################################################################################
 # PROFESSIONS
-# Note: Random bots currently do not get professions
 #
 
+# Percentage of randombots in each class bucket that receive a class-matching
+# weighted profession combination. The remaining randombots use the weighted
+# random sane-pair profession pool.
+# Default: 30
+AiPlayerbot.ClassMatchingProfessionChance = 30
+
 # Automatically adds the 'master fishing' strategy to bots that have the fishing skill when the bots master fishes.
 # Default: 1 (Enabled)
 AiPlayerbot.EnableFishingWithMaster = 1
diff --git a/src/Bot/Factory/PlayerbotFactory.cpp b/src/Bot/Factory/PlayerbotFactory.cpp
index 11f301feb..9dfae8987 100644
--- a/src/Bot/Factory/PlayerbotFactory.cpp
+++ b/src/Bot/Factory/PlayerbotFactory.cpp
@@ -5,6 +5,7 @@
 
 #include "PlayerbotFactory.h"
 
+#include <array>
 #include <utility>
 
 #include "AccountMgr.h"
@@ -47,10 +48,11 @@ static std::vector<uint32> initSlotsOrder = {EQUIPMENT_SLOT_TRINKET1, EQUIPMENT_
     EQUIPMENT_SLOT_LEGS, EQUIPMENT_SLOT_HANDS, EQUIPMENT_SLOT_NECK, EQUIPMENT_SLOT_BODY, EQUIPMENT_SLOT_WAIST,
     EQUIPMENT_SLOT_FEET, EQUIPMENT_SLOT_WRISTS, EQUIPMENT_SLOT_FINGER1, EQUIPMENT_SLOT_FINGER2, EQUIPMENT_SLOT_BACK};
 
-uint32 PlayerbotFactory::tradeSkills[] = {SKILL_ALCHEMY,        SKILL_ENCHANTING,  SKILL_SKINNING,  SKILL_TAILORING,
-                                          SKILL_LEATHERWORKING, SKILL_ENGINEERING, SKILL_HERBALISM, SKILL_MINING,
-                                          SKILL_BLACKSMITHING,  SKILL_COOKING,     SKILL_FIRST_AID, SKILL_FISHING,
-                                          SKILL_JEWELCRAFTING};
+uint32 PlayerbotFactory::tradeSkills[] = {SKILL_ALCHEMY,         SKILL_ENCHANTING,   SKILL_SKINNING,
+                                          SKILL_TAILORING,       SKILL_LEATHERWORKING, SKILL_ENGINEERING,
+                                          SKILL_HERBALISM,       SKILL_INSCRIPTION,  SKILL_MINING,
+                                          SKILL_BLACKSMITHING,   SKILL_COOKING,      SKILL_FIRST_AID,
+                                          SKILL_FISHING,         SKILL_JEWELCRAFTING};
 
 std::list<uint32> PlayerbotFactory::classQuestIds;
 std::list<uint32> PlayerbotFactory::specialQuestIds;
@@ -58,6 +60,264 @@ std::vector<uint32> PlayerbotFactory::enchantSpellIdCache;
 std::vector<uint32> PlayerbotFactory::enchantGemIdCache;
 std::unordered_map<uint32, std::vector<uint32>> PlayerbotFactory::trainerIdCache;
 
+bool PlayerbotFactory::IsPrimaryTradeSkill(uint16 skillId)
+{
+    SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillId);
+    return skillLine && skillLine->categoryId == SKILL_CATEGORY_PROFESSION;
+}
+
+bool PlayerbotFactory::IsGatheringTradeSkill(uint16 skillId)
+{
+    switch (skillId)
+    {
+        case SKILL_HERBALISM:
+        case SKILL_MINING:
+        case SKILL_SKINNING:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool PlayerbotFactory::IsCraftingTradeSkill(uint16 skillId)
+{
+    return IsPrimaryTradeSkill(skillId) && !IsGatheringTradeSkill(skillId);
+}
+
+uint32 PlayerbotFactory::GetProfessionStarterSpell(uint16 skillId)
+{
+    static constexpr std::array<std::pair<uint16, uint32>, 14> ProfessionStarterSpells = {{
+        {SKILL_ALCHEMY, 2259},
+        {SKILL_BLACKSMITHING, 2018},
+        {SKILL_COOKING, 2550},
+        {SKILL_ENCHANTING, 7411},
+        {SKILL_ENGINEERING, 4036},
+        {SKILL_FIRST_AID, 3273},
+        {SKILL_FISHING, 7620},
+        {SKILL_HERBALISM, 2366},
+        {SKILL_INSCRIPTION, 45357},
+        {SKILL_JEWELCRAFTING, 25229},
+        {SKILL_LEATHERWORKING, 2108},
+        {SKILL_MINING, 2575},
+        {SKILL_SKINNING, 8613},
+        {SKILL_TAILORING, 3908}
+    }};
+
+    for (auto const& [professionSkill, starterSpell] : ProfessionStarterSpells)
+    {
+        if (professionSkill == skillId)
+            return starterSpell;
+    }
+
+    return 0;
+}
+
+std::vector<PlayerbotFactory::WeightedProfessionPair> PlayerbotFactory::GetClassProfessionPairs(Player* bot)
+{
+    switch (bot->getClass())
+    {
+        case CLASS_WARRIOR:
+            return {{SKILL_MINING, SKILL_BLACKSMITHING, 45},
+                    {SKILL_MINING, SKILL_ENGINEERING, 30},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 15},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 10}};
+        case CLASS_PALADIN:
+            return {{SKILL_MINING, SKILL_BLACKSMITHING, 45},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 30},
+                    {SKILL_MINING, SKILL_ENGINEERING, 15},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 10}};
+        case CLASS_DEATH_KNIGHT:
+            return {{SKILL_MINING, SKILL_BLACKSMITHING, 45},
+                    {SKILL_MINING, SKILL_ENGINEERING, 35},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 20}};
+        case CLASS_HUNTER:
+            return {{SKILL_SKINNING, SKILL_LEATHERWORKING, 45},
+                    {SKILL_MINING, SKILL_ENGINEERING, 35},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 10},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 10}};
+        case CLASS_ROGUE:
+            return {{SKILL_SKINNING, SKILL_LEATHERWORKING, 35},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 25},
+                    {SKILL_MINING, SKILL_ENGINEERING, 25},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 10},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 5}};
+        case CLASS_DRUID:
+            return {{SKILL_SKINNING, SKILL_LEATHERWORKING, 35},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 35},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 20},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 10}};
+        case CLASS_SHAMAN:
+            return {{SKILL_HERBALISM, SKILL_ALCHEMY, 35},
+                    {SKILL_SKINNING, SKILL_LEATHERWORKING, 25},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 25},
+                    {SKILL_MINING, SKILL_JEWELCRAFTING, 15}};
+        case CLASS_PRIEST:
+            return {{SKILL_TAILORING, SKILL_ENCHANTING, 45},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 30},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 25}};
+        case CLASS_MAGE:
+            return {{SKILL_TAILORING, SKILL_ENCHANTING, 50},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 25},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 25}};
+        case CLASS_WARLOCK:
+        default:
+            return {{SKILL_TAILORING, SKILL_ENCHANTING, 50},
+                    {SKILL_HERBALISM, SKILL_ALCHEMY, 25},
+                    {SKILL_HERBALISM, SKILL_INSCRIPTION, 25}};
+    }
+}
+
+std::vector<PlayerbotFactory::WeightedProfessionPair> PlayerbotFactory::GetRandomProfessionPairs()
+{
+    return {{SKILL_MINING, SKILL_BLACKSMITHING, 20},
+            {SKILL_MINING, SKILL_ENGINEERING, 18},
+            {SKILL_MINING, SKILL_JEWELCRAFTING, 16},
+            {SKILL_SKINNING, SKILL_LEATHERWORKING, 18},
+            {SKILL_HERBALISM, SKILL_ALCHEMY, 18},
+            {SKILL_HERBALISM, SKILL_INSCRIPTION, 14},
+            {SKILL_TAILORING, SKILL_ENCHANTING, 10},
+            {SKILL_HERBALISM, SKILL_MINING, 6},
+            {SKILL_HERBALISM, SKILL_SKINNING, 5},
+            {SKILL_MINING, SKILL_SKINNING, 5}};
+}
+
+std::pair<uint16, uint16> PlayerbotFactory::ChooseProfessionPair(
+    std::vector<WeightedProfessionPair> const& professionPairs)
+{
+    uint32 totalWeight = 0;
+    for (WeightedProfessionPair const& pair : professionPairs)
+        totalWeight += pair.weight;
+
+    if (!totalWeight)
+        return {SKILL_HERBALISM, SKILL_ALCHEMY};
+
+    uint32 roll = urand(1, totalWeight);
+    for (WeightedProfessionPair const& pair : professionPairs)
+    {
+        if (roll <= pair.weight)
+            return {pair.firstSkill, pair.secondSkill};
+
+        roll -= pair.weight;
+    }
+
+    WeightedProfessionPair const& fallback = professionPairs.back();
+    return {fallback.firstSkill, fallback.secondSkill};
+}
+
+bool PlayerbotFactory::HasProfessionPair(std::vector<WeightedProfessionPair> const& professionPairs,
+                                         uint16 firstSkill, uint16 secondSkill)
+{
+    for (WeightedProfessionPair const& pair : professionPairs)
+    {
+        if (pair.firstSkill == firstSkill && pair.secondSkill == secondSkill)
+            return true;
+    }
+
+    return false;
+}
+
+uint16 PlayerbotFactory::ChooseSingleProfession(std::vector<WeightedProfessionPair> const& professionPairs)
+{
+    std::vector<std::pair<uint16, uint32>> gatheringSkills;
+    std::vector<std::pair<uint16, uint32>> craftingSkills;
+
+    auto addWeightedSkill = [](std::vector<std::pair<uint16, uint32>>& skills, uint16 skillId, uint32 weight)
+    {
+        for (std::pair<uint16, uint32>& skill : skills)
+        {
+            if (skill.first == skillId)
+            {
+                skill.second += weight;
+                return;
+            }
+        }
+
+        skills.push_back({skillId, weight});
+    };
+
+    for (WeightedProfessionPair const& pair : professionPairs)
+    {
+        if (IsGatheringTradeSkill(pair.firstSkill))
+            addWeightedSkill(gatheringSkills, pair.firstSkill, pair.weight);
+        if (IsCraftingTradeSkill(pair.firstSkill))
+            addWeightedSkill(craftingSkills, pair.firstSkill, pair.weight);
+
+        if (IsGatheringTradeSkill(pair.secondSkill))
+            addWeightedSkill(gatheringSkills, pair.secondSkill, pair.weight);
+        if (IsCraftingTradeSkill(pair.secondSkill))
+            addWeightedSkill(craftingSkills, pair.secondSkill, pair.weight);
+    }
+
+    std::vector<std::pair<uint16, uint32>>* selectedPool = nullptr;
+    if (!gatheringSkills.empty() && !craftingSkills.empty())
+        selectedPool = urand(0, 1) == 0 ? &gatheringSkills : &craftingSkills;
+    else if (!gatheringSkills.empty())
+        selectedPool = &gatheringSkills;
+    else if (!craftingSkills.empty())
+        selectedPool = &craftingSkills;
+
+    if (!selectedPool || selectedPool->empty())
+        return SKILL_HERBALISM;
+
+    uint32 totalWeight = 0;
+    for (std::pair<uint16, uint32> const& skill : *selectedPool)
+        totalWeight += skill.second;
+
+    if (!totalWeight)
+        return selectedPool->front().first;
+
+    uint32 roll = urand(1, totalWeight);
+    for (std::pair<uint16, uint32> const& skill : *selectedPool)
+    {
+        if (roll <= skill.second)
+            return skill.first;
+
+        roll -= skill.second;
+    }
+
+    return selectedPool->back().first;
+}
+
+uint32 PlayerbotFactory::GetStoredOrRandomValue(Player* bot,
+                                                std::string const& key,
+                                                uint32 minValue,
+                                                uint32 maxValue)
+{
+    uint32 value = sRandomPlayerbotMgr.GetValue(bot, key);
+    if (value < minValue || value > maxValue)
+    {
+        value = urand(minValue, maxValue);
+        sRandomPlayerbotMgr.SetValue(bot, key, value);
+    }
+
+    return value;
+}
+
+bool PlayerbotFactory::HasAnySpell(Player* bot, std::vector<uint32> const& spells)
+{
+    for (uint32 spellId : spells)
+    {
+        if (bot->HasSpell(spellId))
+            return true;
+    }
+
+    return false;
+}
+
+bool PlayerbotFactory::LearnProfessionSpecialization(Player* bot,
+                                                     ProfessionSpecializationSpell knownSpell,
+                                                     ProfessionSpecializationSpell learnSpell)
+{
+    uint32 const knownSpellId = static_cast<uint32>(knownSpell);
+    uint32 const learnSpellId = static_cast<uint32>(learnSpell);
+
+    if (bot->HasSpell(knownSpellId) || !sSpellMgr->GetSpellInfo(learnSpellId))
+        return false;
+
+    bot->CastSpell(bot, learnSpellId, true);
+    return bot->HasSpell(knownSpellId);
+}
+
 PlayerbotFactory::PlayerbotFactory(Player* bot, uint32 level, uint32 itemQuality, uint32 gearScoreLimit)
     : level(level), itemQuality(itemQuality), gearScoreLimit(gearScoreLimit), bot(bot)
 {
@@ -2250,69 +2510,278 @@ bool PlayerbotFactory::CanEquipUnseenItem(uint8 slot, uint16& dest, uint32 item)
 
 void PlayerbotFactory::InitTradeSkills()
 {
+    if (!sRandomPlayerbotMgr.IsRandomBot(bot))
+        return;
+
+    uint32 const maxPrimaryTradeSkills =
+        std::min<uint32>(2, sWorld->getIntConfig(CONFIG_MAX_PRIMARY_TRADE_SKILL));
+
     uint16 firstSkill = sRandomPlayerbotMgr.GetValue(bot, "firstSkill");
     uint16 secondSkill = sRandomPlayerbotMgr.GetValue(bot, "secondSkill");
-    if (!firstSkill || !secondSkill)
+    ProfessionRollType professionRollType =
+        static_cast<ProfessionRollType>(sRandomPlayerbotMgr.GetValue(bot, "professionRollType"));
+
+    if (professionRollType != ProfessionRollType::Class && professionRollType != ProfessionRollType::Random)
     {
-        std::vector<uint32> firstSkills;
-        std::vector<uint32> secondSkills;
+        professionRollType = urand(1, 100) <= sPlayerbotAIConfig.classMatchingProfessionChance
+                                 ? ProfessionRollType::Class
+                                 : ProfessionRollType::Random;
+        sRandomPlayerbotMgr.SetValue(bot, "professionRollType", static_cast<uint32>(professionRollType));
+    }
 
-        switch (bot->getClass())
-        {
-            case CLASS_WARRIOR:
-            case CLASS_PALADIN:
-            case CLASS_DEATH_KNIGHT:
-                firstSkills.push_back(SKILL_MINING);
-                secondSkills.push_back(SKILL_BLACKSMITHING);
-                secondSkills.push_back(SKILL_ENGINEERING);
-                secondSkills.push_back(SKILL_JEWELCRAFTING);
-                break;
-            case CLASS_SHAMAN:
-            case CLASS_DRUID:
-            case CLASS_HUNTER:
-            case CLASS_ROGUE:
-                firstSkills.push_back(SKILL_SKINNING);
-                secondSkills.push_back(SKILL_LEATHERWORKING);
-                break;
-            default:
-                firstSkills.push_back(SKILL_TAILORING);
-                secondSkills.push_back(SKILL_ENCHANTING);
-        }
+    std::vector<WeightedProfessionPair> professionPairs = professionRollType == ProfessionRollType::Class
+                                                              ? GetClassProfessionPairs(bot)
+                                                              : GetRandomProfessionPairs();
 
-        switch (urand(0, 6))
+    bool const hasStoredProfessionPair = firstSkill && secondSkill && firstSkill != secondSkill &&
+                                         IsPrimaryTradeSkill(firstSkill) && IsPrimaryTradeSkill(secondSkill) &&
+                                         HasProfessionPair(professionPairs, firstSkill, secondSkill);
+    bool const keepExistingProfessionPair = maxPrimaryTradeSkills < 2 && hasStoredProfessionPair;
+
+    if (maxPrimaryTradeSkills == 1 && !keepExistingProfessionPair)
+    {
+        if (!IsPrimaryTradeSkill(firstSkill) || secondSkill != 0)
         {
-            case 0:
-                firstSkill = SKILL_HERBALISM;
-                secondSkill = SKILL_ALCHEMY;
-                break;
-            case 1:
-                firstSkill = SKILL_HERBALISM;
-                secondSkill = SKILL_MINING;
-                break;
-            case 2:
-                firstSkill = SKILL_MINING;
-                secondSkill = SKILL_SKINNING;
-                break;
-            case 3:
-                firstSkill = SKILL_HERBALISM;
-                secondSkill = SKILL_SKINNING;
-                break;
-            default:
-                firstSkill = firstSkills[urand(0, firstSkills.size() - 1)];
-                secondSkill = secondSkills[urand(0, secondSkills.size() - 1)];
-                break;
+            firstSkill = ChooseSingleProfession(professionPairs);
+            secondSkill = 0;
+
+            sRandomPlayerbotMgr.SetValue(bot, "firstSkill", firstSkill);
+            sRandomPlayerbotMgr.SetValue(bot, "secondSkill", secondSkill);
         }
+    }
+    else if (maxPrimaryTradeSkills == 0 && !keepExistingProfessionPair)
+    {
+        firstSkill = 0;
+        secondSkill = 0;
 
         sRandomPlayerbotMgr.SetValue(bot, "firstSkill", firstSkill);
         sRandomPlayerbotMgr.SetValue(bot, "secondSkill", secondSkill);
     }
 
+    if (maxPrimaryTradeSkills >= 2 &&
+        (!firstSkill || !secondSkill || firstSkill == secondSkill || !IsPrimaryTradeSkill(firstSkill) ||
+         !IsPrimaryTradeSkill(secondSkill) || !HasProfessionPair(professionPairs, firstSkill, secondSkill)))
+    {
+        auto const& professionPair = ChooseProfessionPair(professionPairs);
+        firstSkill = professionPair.first;
+        secondSkill = professionPair.second;
+
+        sRandomPlayerbotMgr.SetValue(bot, "firstSkill", firstSkill);
+        sRandomPlayerbotMgr.SetValue(bot, "secondSkill", secondSkill);
+    }
+
+    std::vector<uint16> primarySkills;
+    if (keepExistingProfessionPair)
+    {
+        primarySkills.push_back(firstSkill);
+        primarySkills.push_back(secondSkill);
+    }
+    else if (maxPrimaryTradeSkills > 0)
+        primarySkills.push_back(firstSkill);
+    if (!keepExistingProfessionPair && maxPrimaryTradeSkills > 1)
+        primarySkills.push_back(secondSkill);
+
     SetRandomSkill(SKILL_FIRST_AID);
     SetRandomSkill(SKILL_FISHING);
     SetRandomSkill(SKILL_COOKING);
 
-    SetRandomSkill(firstSkill);
-    SetRandomSkill(secondSkill);
+    for (uint16 skillId : primarySkills)
+        SetRandomSkill(skillId);
+
+    std::vector<uint16> skillsToLearn = {SKILL_FIRST_AID, SKILL_FISHING, SKILL_COOKING};
+    skillsToLearn.insert(skillsToLearn.end(), primarySkills.begin(), primarySkills.end());
+
+    for (uint16 skillId : skillsToLearn)
+    {
+        uint32 spellId = GetProfessionStarterSpell(skillId);
+        if (!spellId || bot->HasSpell(spellId))
+            continue;
+
+        if (IsPrimaryTradeSkill(skillId) && !bot->GetFreePrimaryProfessionPoints() &&
+            !(keepExistingProfessionPair && bot->HasSkill(skillId)))
+            continue;
+
+        bot->learnSpell(spellId, false);
+    }
+
+    InitTradeSpecializations();
+}
+
+void PlayerbotFactory::InitTradeSpecializations()
+{
+    InitAlchemySpecialization();
+    InitEngineeringSpecialization();
+    InitLeatherworkingSpecialization();
+    InitTailoringSpecialization();
+    InitBlacksmithingSpecialization();
+}
+
+bool PlayerbotFactory::InitAlchemySpecialization()
+{
+    if (!bot->HasSkill(SKILL_ALCHEMY) ||
+        bot->GetBaseSkillValue(SKILL_ALCHEMY) < 325 ||
+        bot->GetLevel() <= 67)
+        return false;
+
+    if (HasAnySpell(bot, {static_cast<uint32>(ProfessionSpecializationSpell::Transmute),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Elixir),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Potion)}))
+        return false;
+
+    switch (GetStoredOrRandomValue(bot, "alchemySpecialization", 1, 3))
+    {
+        case 1:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Transmute,
+                                                 ProfessionSpecializationSpell::LearnTransmute);
+        case 2:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Elixir,
+                                                 ProfessionSpecializationSpell::LearnElixir);
+        case 3:
+        default:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Potion,
+                                                 ProfessionSpecializationSpell::LearnPotion);
+    }
+}
+
+bool PlayerbotFactory::InitEngineeringSpecialization()
+{
+    if (!bot->HasSkill(SKILL_ENGINEERING) ||
+        bot->GetBaseSkillValue(SKILL_ENGINEERING) < 200 ||
+        bot->GetLevel() < 30)
+        return false;
+
+    if (HasAnySpell(bot, {static_cast<uint32>(ProfessionSpecializationSpell::Goblin),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Gnomish)}))
+        return false;
+
+    switch (GetStoredOrRandomValue(bot, "engineeringSpecialization", 1, 2))
+    {
+        case 1:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Goblin,
+                                                 ProfessionSpecializationSpell::LearnGoblin);
+        case 2:
+        default:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Gnomish,
+                                                 ProfessionSpecializationSpell::LearnGnomish);
+    }
+}
+
+bool PlayerbotFactory::InitLeatherworkingSpecialization()
+{
+    if (!bot->HasSkill(SKILL_LEATHERWORKING) ||
+        bot->GetBaseSkillValue(SKILL_LEATHERWORKING) < 225 ||
+        bot->GetLevel() <= 40)
+        return false;
+
+    if (HasAnySpell(bot, {static_cast<uint32>(ProfessionSpecializationSpell::Dragon),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Elemental),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Tribal)}))
+        return false;
+
+    switch (GetStoredOrRandomValue(bot, "leatherSpecialization", 1, 3))
+    {
+        case 1:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Dragon,
+                                                 ProfessionSpecializationSpell::LearnDragon);
+        case 2:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Elemental,
+                                                 ProfessionSpecializationSpell::LearnElemental);
+        case 3:
+        default:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Tribal,
+                                                 ProfessionSpecializationSpell::LearnTribal);
+    }
+}
+
+bool PlayerbotFactory::InitTailoringSpecialization()
+{
+    if (!bot->HasSkill(SKILL_TAILORING) ||
+        bot->GetBaseSkillValue(SKILL_TAILORING) < 350 ||
+        bot->GetLevel() <= 59)
+        return false;
+
+    if (HasAnySpell(bot, {static_cast<uint32>(ProfessionSpecializationSpell::Spellfire),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Mooncloth),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Shadoweave)}))
+        return false;
+
+    switch (GetStoredOrRandomValue(bot, "tailorSpecialization", 1, 3))
+    {
+        case 1:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Spellfire,
+                                                 ProfessionSpecializationSpell::LearnSpellfire);
+        case 2:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Mooncloth,
+                                                 ProfessionSpecializationSpell::LearnMooncloth);
+        case 3:
+        default:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Shadoweave,
+                                                 ProfessionSpecializationSpell::LearnShadoweave);
+    }
+}
+
+bool PlayerbotFactory::InitBlacksmithingSpecialization()
+{
+    bool learnedSpecialization = false;
+
+    if (!bot->HasSkill(SKILL_BLACKSMITHING) ||
+        bot->GetBaseSkillValue(SKILL_BLACKSMITHING) < 225)
+        return false;
+
+    if (!bot->HasSpell(static_cast<uint32>(ProfessionSpecializationSpell::Armor)) &&
+        !bot->HasSpell(static_cast<uint32>(ProfessionSpecializationSpell::Weapon)))
+    {
+        switch (GetStoredOrRandomValue(bot, "blacksmithSpecialization", 1, 2))
+        {
+            case 1:
+                learnedSpecialization = LearnProfessionSpecialization(bot,
+                                                                      ProfessionSpecializationSpell::Armor,
+                                                                      ProfessionSpecializationSpell::LearnArmor);
+                break;
+            case 2:
+            default:
+                learnedSpecialization = LearnProfessionSpecialization(bot,
+                                                                      ProfessionSpecializationSpell::Weapon,
+                                                                      ProfessionSpecializationSpell::LearnWeapon);
+                break;
+        }
+    }
+
+    if (!bot->HasSpell(static_cast<uint32>(ProfessionSpecializationSpell::Weapon)) ||
+        bot->GetBaseSkillValue(SKILL_BLACKSMITHING) < 250 ||
+        bot->GetLevel() <= 49 ||
+        HasAnySpell(bot, {static_cast<uint32>(ProfessionSpecializationSpell::Hammer),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Axe),
+                          static_cast<uint32>(ProfessionSpecializationSpell::Sword)}))
+        return learnedSpecialization;
+
+    switch (GetStoredOrRandomValue(bot, "blacksmithWeaponSpecialization", 1, 3))
+    {
+        case 1:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Hammer,
+                                                 ProfessionSpecializationSpell::LearnHammer);
+        case 2:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Axe,
+                                                 ProfessionSpecializationSpell::LearnAxe);
+        case 3:
+        default:
+            return LearnProfessionSpecialization(bot,
+                                                 ProfessionSpecializationSpell::Sword,
+                                                 ProfessionSpecializationSpell::LearnSword);
+    }
 }
 
 void PlayerbotFactory::UpdateTradeSkills()
@@ -2456,6 +2925,9 @@ void PlayerbotFactory::InitSkills()
             break;
     }
 
+    InitTradeSkills();
+    InitInventorySkill();
+
     // switch (bot->getClass())
     // {
     //     case CLASS_WARRIOR:
@@ -3804,30 +4276,21 @@ void PlayerbotFactory::InitInventory()
 
 void PlayerbotFactory::InitInventorySkill()
 {
-    if (bot->HasSkill(SKILL_MINING))
-    {
+    if (bot->HasSkill(SKILL_MINING) && !bot->HasItemCount(2901, 1, true))
         StoreItem(2901, 1);  // Mining Pick
-    }
 
-    if (bot->HasSkill(SKILL_BLACKSMITHING) || bot->HasSkill(SKILL_ENGINEERING))
-    {
+    if ((bot->HasSkill(SKILL_BLACKSMITHING) || bot->HasSkill(SKILL_ENGINEERING)) &&
+        !bot->HasItemCount(5956, 1, true))
         StoreItem(5956, 1);  // Blacksmith Hammer
-    }
 
-    if (bot->HasSkill(SKILL_ENGINEERING))
-    {
+    if (bot->HasSkill(SKILL_ENGINEERING) && !bot->HasItemCount(6219, 1, true))
         StoreItem(6219, 1);  // Arclight Spanner
-    }
 
-    if (bot->HasSkill(SKILL_ENCHANTING))
-    {
+    if (bot->HasSkill(SKILL_ENCHANTING) && !bot->HasItemCount(16207, 1, true))
         StoreItem(16207, 1);  // Runed Arcanite Rod
-    }
 
-    if (bot->HasSkill(SKILL_SKINNING))
-    {
+    if (bot->HasSkill(SKILL_SKINNING) && !bot->HasItemCount(7005, 1, true))
         StoreItem(7005, 1);  // Skinning Knife
-    }
 }
 
 Item* PlayerbotFactory::StoreItem(uint32 itemId, uint32 count)
diff --git a/src/Bot/Factory/PlayerbotFactory.h b/src/Bot/Factory/PlayerbotFactory.h
index d943463ea..1962c0428 100644
--- a/src/Bot/Factory/PlayerbotFactory.h
+++ b/src/Bot/Factory/PlayerbotFactory.h
@@ -6,6 +6,9 @@
 #ifndef _PLAYERBOT_PLAYERBOTFACTORY_H
 #define _PLAYERBOT_PLAYERBOTFACTORY_H
 
+#include <string>
+#include <utility>
+
 #include "InventoryAction.h"
 #include "Player.h"
 #include "PlayerbotAI.h"
@@ -87,12 +90,91 @@ public:
     void InitAttunementQuests();
 
 private:
+    enum class ProfessionSpecializationSpell : uint32
+    {
+        Weapon = 9787,
+        Armor = 9788,
+        Hammer = 17040,
+        Axe = 17041,
+        Sword = 17039,
+
+        LearnWeapon = 9789,
+        LearnArmor = 9790,
+        LearnHammer = 39099,
+        LearnAxe = 39098,
+        LearnSword = 39097,
+
+        Dragon = 10656,
+        Elemental = 10658,
+        Tribal = 10660,
+
+        LearnDragon = 10657,
+        LearnElemental = 10659,
+        LearnTribal = 10661,
+
+        Spellfire = 26797,
+        Mooncloth = 26798,
+        Shadoweave = 26801,
+
+        Goblin = 20222,
+        Gnomish = 20219,
+
+        LearnGoblin = 20221,
+        LearnGnomish = 20220,
+
+        LearnSpellfire = 26796,
+        LearnMooncloth = 26799,
+        LearnShadoweave = 26800,
+
+        Transmute = 28672,
+        Elixir = 28677,
+        Potion = 28675,
+
+        LearnTransmute = 28674,
+        LearnElixir = 28678,
+        LearnPotion = 28676
+    };
+
+    enum class ProfessionRollType : uint32
+    {
+        Random = 1,
+        Class = 2
+    };
+
+    struct WeightedProfessionPair
+    {
+        uint16 firstSkill;
+        uint16 secondSkill;
+        uint32 weight;
+    };
+
     void Prepare();
     // void InitSecondEquipmentSet();
     // void InitEquipmentNew(bool incremental);
     bool CanEquipItem(ItemTemplate const* proto);
     bool CanEquipUnseenItem(uint8 slot, uint16& dest, uint32 item);
+    static bool IsPrimaryTradeSkill(uint16 skillId);
+    static bool IsGatheringTradeSkill(uint16 skillId);
+    static bool IsCraftingTradeSkill(uint16 skillId);
+    static uint32 GetProfessionStarterSpell(uint16 skillId);
+    static std::vector<WeightedProfessionPair> GetClassProfessionPairs(Player* bot);
+    static std::vector<WeightedProfessionPair> GetRandomProfessionPairs();
+    static std::pair<uint16, uint16> ChooseProfessionPair(std::vector<WeightedProfessionPair> const& professionPairs);
+    static bool HasProfessionPair(std::vector<WeightedProfessionPair> const& professionPairs,
+                                  uint16 firstSkill, uint16 secondSkill);
+    static uint16 ChooseSingleProfession(std::vector<WeightedProfessionPair> const& professionPairs);
+    static uint32 GetStoredOrRandomValue(Player* bot, std::string const& key, uint32 minValue, uint32 maxValue);
+    static bool HasAnySpell(Player* bot, std::vector<uint32> const& spells);
+    static bool LearnProfessionSpecialization(Player* bot,
+                                             ProfessionSpecializationSpell knownSpell,
+                                             ProfessionSpecializationSpell learnSpell);
     void InitTradeSkills();
+    void InitTradeSpecializations();
+    bool InitAlchemySpecialization();
+    bool InitEngineeringSpecialization();
+    bool InitLeatherworkingSpecialization();
+    bool InitTailoringSpecialization();
+    bool InitBlacksmithingSpecialization();
     void UpdateTradeSkills();
     void SetRandomSkill(uint16 id);
     void ClearSpells();
diff --git a/src/PlayerbotAIConfig.cpp b/src/PlayerbotAIConfig.cpp
index 32443c46d..a8daf972a 100644
--- a/src/PlayerbotAIConfig.cpp
+++ b/src/PlayerbotAIConfig.cpp
@@ -236,6 +236,8 @@ bool PlayerbotAIConfig::Initialize()
     EnableICCBuffs = sConfigMgr->GetOption<bool>("AiPlayerbot.EnableICCBuffs", true);
 
     //////////////////////////// Professions
+    classMatchingProfessionChance =
+        std::min<uint32>(100, sConfigMgr->GetOption<uint32>("AiPlayerbot.ClassMatchingProfessionChance", 30));
     fishingDistanceFromMaster = sConfigMgr->GetOption<float>("AiPlayerbot.FishingDistanceFromMaster", 10.0f);
     endFishingWithMaster = sConfigMgr->GetOption<float>("AiPlayerbot.EndFishingWithMaster", 30.0f);
     fishingDistance = sConfigMgr->GetOption<float>("AiPlayerbot.FishingDistance", 40.0f);
diff --git a/src/PlayerbotAIConfig.h b/src/PlayerbotAIConfig.h
index 4e758e79e..877672678 100644
--- a/src/PlayerbotAIConfig.h
+++ b/src/PlayerbotAIConfig.h
@@ -152,6 +152,7 @@ public:
 
     // Professions
     bool enableFishingWithMaster;
+    uint32 classMatchingProfessionChance;
     float fishingDistanceFromMaster, fishingDistance, endFishingWithMaster;
 
     // chat