1 files changed, 185 insertions, 86 deletions

diff --git a/src/server/game/DungeonFinding/LFGQueue.cpp b/src/server/game/DungeonFinding/LFGQueue.cpp
index 131a3e7a992..8b69b537102 100644
--- a/src/server/game/DungeonFinding/LFGQueue.cpp
+++ b/src/server/game/DungeonFinding/LFGQueue.cpp
@@ -51,7 +51,7 @@ std::string ConcatenateGuids(LfgGuidList const& check)
     return o.str();
 }
 
-char const * GetCompatibleString(LfgCompatibility compatibles)
+char const* GetCompatibleString(LfgCompatibility compatibles)
 {
     switch (compatibles)
     {
@@ -80,83 +80,102 @@ char const * GetCompatibleString(LfgCompatibility compatibles)
     }
 }
 
-void LfgQueue::AddToQueue(uint64 guid)
+void LFGQueue::AddToQueue(uint64 guid)
 {
-    LfgQueueDataMap::iterator itQueue = m_QueueDataMap.find(guid);
-    if (itQueue == m_QueueDataMap.end())
+    LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
+    if (itQueue == QueueDataStore.end())
     {
-        sLog->outError(LOG_FILTER_LFG, "LfgQueue::AddToQueue: Queue data not found for [" UI64FMTD "]", guid);
+        sLog->outError(LOG_FILTER_LFG, "LFGQueue::AddToQueue: Queue data not found for [" UI64FMTD "]", guid);
         return;
     }
 
     AddToNewQueue(guid);
 }
 
-void LfgQueue::RemoveFromQueue(uint64 guid)
+void LFGQueue::RemoveFromQueue(uint64 guid)
 {
     RemoveFromNewQueue(guid);
     RemoveFromCurrentQueue(guid);
     RemoveFromCompatibles(guid);
-    RemoveQueueData(guid);
+
+    std::ostringstream o;
+    o << guid;
+    std::string sguid = o.str();
+
+    LfgQueueDataContainer::iterator itDelete = QueueDataStore.end();
+    for (LfgQueueDataContainer::iterator itr = QueueDataStore.begin(); itr != QueueDataStore.end(); ++itr)
+        if (itr->first != guid)
+        {
+            if (std::string::npos != itr->second.bestCompatible.find(sguid))
+            {
+                itr->second.bestCompatible.clear();
+                FindBestCompatibleInQueue(itr);
+            }
+        }
+        else
+            itDelete = itr;
+
+    if (itDelete != QueueDataStore.end())
+        QueueDataStore.erase(itDelete);
 }
 
-void LfgQueue::AddToNewQueue(uint64 guid)
+void LFGQueue::AddToNewQueue(uint64 guid)
 {
-    m_newToQueue.push_back(guid);
+    newToQueueStore.push_back(guid);
 }
 
-void LfgQueue::RemoveFromNewQueue(uint64 guid)
+void LFGQueue::RemoveFromNewQueue(uint64 guid)
 {
-    m_newToQueue.remove(guid);
+    newToQueueStore.remove(guid);
 }
 
-void LfgQueue::AddToCurrentQueue(uint64 guid)
+void LFGQueue::AddToCurrentQueue(uint64 guid)
 {
-    m_currentQueue.push_back(guid);
+    currentQueueStore.push_back(guid);
 }
 
-void LfgQueue::RemoveFromCurrentQueue(uint64 guid)
+void LFGQueue::RemoveFromCurrentQueue(uint64 guid)
 {
-    m_currentQueue.remove(guid);
+    currentQueueStore.remove(guid);
 }
 
-void LfgQueue::AddQueueData(uint64 guid, time_t joinTime, const LfgDungeonSet &dungeons, const LfgRolesMap &rolesMap)
+void LFGQueue::AddQueueData(uint64 guid, time_t joinTime, const LfgDungeonSet &dungeons, const LfgRolesMap &rolesMap)
 {
-    m_QueueDataMap[guid] = LfgQueueData(joinTime, dungeons, rolesMap);
+    QueueDataStore[guid] = LfgQueueData(joinTime, dungeons, rolesMap);
     AddToQueue(guid);
 }
 
-void LfgQueue::RemoveQueueData(uint64 guid)
+void LFGQueue::RemoveQueueData(uint64 guid)
 {
-    LfgQueueDataMap::iterator it = m_QueueDataMap.find(guid);
-    if (it != m_QueueDataMap.end())
-        m_QueueDataMap.erase(it);
+    LfgQueueDataContainer::iterator it = QueueDataStore.find(guid);
+    if (it != QueueDataStore.end())
+        QueueDataStore.erase(it);
 }
 
-void LfgQueue::UpdateWaitTimeAvg(int32 waitTime, uint32 dungeonId)
+void LFGQueue::UpdateWaitTimeAvg(int32 waitTime, uint32 dungeonId)
 {
-    LfgWaitTime &wt = m_waitTimesAvg[dungeonId];
+    LfgWaitTime &wt = waitTimesAvgStore[dungeonId];
     uint32 old_number = wt.number++;
     wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }
 
-void LfgQueue::UpdateWaitTimeTank(int32 waitTime, uint32 dungeonId)
+void LFGQueue::UpdateWaitTimeTank(int32 waitTime, uint32 dungeonId)
 {
-    LfgWaitTime &wt = m_waitTimesTank[dungeonId];
+    LfgWaitTime &wt = waitTimesTankStore[dungeonId];
     uint32 old_number = wt.number++;
     wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }
 
-void LfgQueue::UpdateWaitTimeHealer(int32 waitTime, uint32 dungeonId)
+void LFGQueue::UpdateWaitTimeHealer(int32 waitTime, uint32 dungeonId)
 {
-    LfgWaitTime &wt = m_waitTimesHealer[dungeonId];
+    LfgWaitTime &wt = waitTimesHealerStore[dungeonId];
     uint32 old_number = wt.number++;
     wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }
 
-void LfgQueue::UpdateWaitTimeDps(int32 waitTime, uint32 dungeonId)
+void LFGQueue::UpdateWaitTimeDps(int32 waitTime, uint32 dungeonId)
 {
-    LfgWaitTime &wt = m_waitTimesDps[dungeonId];
+    LfgWaitTime &wt = waitTimesDpsStore[dungeonId];
     uint32 old_number = wt.number++;
     wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }
@@ -166,61 +185,76 @@ void LfgQueue::UpdateWaitTimeDps(int32 waitTime, uint32 dungeonId)
 
    @param[in]     guid Guid to remove from compatible cache
 */
-void LfgQueue::RemoveFromCompatibles(uint64 guid)
+void LFGQueue::RemoveFromCompatibles(uint64 guid)
 {
     std::stringstream out;
     out << guid;
     std::string strGuid = out.str();
 
-    sLog->outDebug(LOG_FILTER_LFG, "LfgQueue::RemoveFromCompatibles: Removing [" UI64FMTD "]", guid);
-    for (LfgCompatibleMap::iterator itNext = m_CompatibleMap.begin(); itNext != m_CompatibleMap.end();)
+    sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::RemoveFromCompatibles: Removing [" UI64FMTD "]", guid);
+    for (LfgCompatibleContainer::iterator itNext = CompatibleMapStore.begin(); itNext != CompatibleMapStore.end();)
     {
-        LfgCompatibleMap::iterator it = itNext++;
-        if (it->first.find(strGuid) != std::string::npos)  // Found, remove it
-            m_CompatibleMap.erase(it);
+        LfgCompatibleContainer::iterator it = itNext++;
+        if (std::string::npos != it->first.find(strGuid))
+            CompatibleMapStore.erase(it);
     }
 }
 
-
 /**
    Stores the compatibility of a list of guids
 
    @param[in]     key String concatenation of guids (| used as separator)
    @param[in]     compatibles type of compatibility
 */
-void LfgQueue::SetCompatibles(const std::string &key, LfgCompatibility compatibles)
+void LFGQueue::SetCompatibles(std::string const& key, LfgCompatibility compatibles)
+{
+    LfgCompatibilityData& data = CompatibleMapStore[key];
+    data.compatibility = compatibles;
+}
+
+void LFGQueue::SetCompatibilityData(std::string const& key, LfgCompatibilityData const& data)
 {
-    m_CompatibleMap[key] = compatibles;
+    CompatibleMapStore[key] = data;
 }
 
+
 /**
    Get the compatibility of a group of guids
 
    @param[in]     key String concatenation of guids (| used as separator)
    @return LfgCompatibility type of compatibility
 */
-LfgCompatibility LfgQueue::GetCompatibles(std::string const& key)
+LfgCompatibility LFGQueue::GetCompatibles(std::string const& key)
 {
-    LfgCompatibleMap::iterator it = m_CompatibleMap.find(key);
-    if (it != m_CompatibleMap.end())
-        return it->second;
+    LfgCompatibleContainer::iterator itr = CompatibleMapStore.find(key);
+    if (itr != CompatibleMapStore.end())
+        return itr->second.compatibility;
 
     return LFG_COMPATIBILITY_PENDING;
 }
 
-uint8 LfgQueue::FindGroups()
+LfgCompatibilityData* LFGQueue::GetCompatibilityData(std::string const& key)
+{
+    LfgCompatibleContainer::iterator itr = CompatibleMapStore.find(key);
+    if (itr != CompatibleMapStore.end())
+        return &(itr->second);
+
+    return NULL;
+}
+
+uint8 LFGQueue::FindGroups()
 {
     uint8 proposals = 0;
     LfgGuidList firstNew;
-    while (!m_newToQueue.empty())
+    while (!newToQueueStore.empty())
     {
-        uint64 frontguid = m_newToQueue.front();
-        sLog->outDebug(LOG_FILTER_LFG, "LfgQueue::FindGroups: checking [" UI64FMTD "] newToQueue(%u), currentQueue(%u)", frontguid, uint32(m_newToQueue.size()), uint32(m_currentQueue.size()));
+        uint64 frontguid = newToQueueStore.front();
+        sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::FindGroups: checking [" UI64FMTD "] newToQueue(%u), currentQueue(%u)", frontguid, uint32(newToQueueStore.size()), uint32(currentQueueStore.size()));
         firstNew.clear();
         firstNew.push_back(frontguid);
         RemoveFromNewQueue(frontguid);
 
-        LfgGuidList temporalList = m_currentQueue;
+        LfgGuidList temporalList = currentQueueStore;
         LfgCompatibility compatibles = FindNewGroups(firstNew, temporalList);
 
         if (compatibles == LFG_COMPATIBLES_MATCH)
@@ -238,15 +272,22 @@ uint8 LfgQueue::FindGroups()
    @param[in]     all List of all other guids in main queue to match against
    @return LfgCompatibility type of compatibility between groups
 */
-LfgCompatibility LfgQueue::FindNewGroups(LfgGuidList& check, LfgGuidList& all)
+LfgCompatibility LFGQueue::FindNewGroups(LfgGuidList& check, LfgGuidList& all)
 {
     std::string strGuids = ConcatenateGuids(check);
     LfgCompatibility compatibles = GetCompatibles(strGuids);
 
     sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::FindNewGroup: (%s): %s - all(%s)", strGuids.c_str(), GetCompatibleString(compatibles), ConcatenateGuids(all).c_str());
-    if (compatibles == LFG_COMPATIBILITY_PENDING || compatibles == LFG_COMPATIBLES_BAD_STATES) // Not previously cached, calculate
+    if (compatibles == LFG_COMPATIBILITY_PENDING) // Not previously cached, calculate
         compatibles = CheckCompatibility(check);
 
+    if (compatibles == LFG_COMPATIBLES_BAD_STATES && sLFGMgr->AllQueued(check))
+    {
+        sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::FindNewGroup: (%s) compatibles (cached) changed from bad states to match", strGuids.c_str());
+        SetCompatibles(strGuids, LFG_COMPATIBLES_MATCH);
+        return LFG_COMPATIBLES_MATCH;
+    }
+
     if (compatibles != LFG_COMPATIBLES_WITH_LESS_PLAYERS)
         return compatibles;
 
@@ -269,7 +310,7 @@ LfgCompatibility LfgQueue::FindNewGroups(LfgGuidList& check, LfgGuidList& all)
    @param[in]     check List of guids to check compatibilities
    @return LfgCompatibility type of compatibility
 */
-LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
+LfgCompatibility LFGQueue::CheckCompatibility(LfgGuidList check)
 {
     std::string strGuids = ConcatenateGuids(check);
     LfgProposal proposal;
@@ -284,10 +325,6 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
         return LFG_INCOMPATIBLES_WRONG_GROUP_SIZE;
     }
 
-    // Player joining alone always compatible
-    if (check.size() == 1 && IS_PLAYER_GUID(check.front()))
-        return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
-
     // Check all-but-new compatiblitity
     if (check.size() > 2)
     {
@@ -311,8 +348,8 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     for (LfgGuidList::const_iterator it = check.begin(); it != check.end() && numLfgGroups < 2 && numPlayers <= MAXGROUPSIZE; ++it)
     {
         uint64 guid = (*it);
-        LfgQueueDataMap::iterator itQueue = m_QueueDataMap.find(guid);
-        if (itQueue == m_QueueDataMap.end())
+        LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
+        if (itQueue == QueueDataStore.end())
         {
             sLog->outError(LOG_FILTER_LFG, "LFGQueue::CheckCompatibility: [" UI64FMTD "] is not queued but listed as queued!", guid);
             RemoveFromQueue(guid);
@@ -337,6 +374,14 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     if (check.size() == 1 && numPlayers != MAXGROUPSIZE)
     {
         sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::CheckCompatibility: (%s) sigle group. Compatibles", strGuids.c_str());
+        LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(check.front());
+
+        LfgCompatibilityData data(LFG_COMPATIBLES_WITH_LESS_PLAYERS);
+        data.roles = itQueue->second.roles;
+        LFGMgr::CheckGroupRoles(data.roles);
+
+        UpdateBestCompatibleInQueue(itQueue, strGuids, data.roles);
+        SetCompatibilityData(strGuids, data);
         return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
     }
 
@@ -359,14 +404,14 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     {
         for (LfgGuidList::const_iterator it = check.begin(); it != check.end(); ++it)
         {
-            const LfgRolesMap &roles = m_QueueDataMap[(*it)].roles;
+            const LfgRolesMap &roles = QueueDataStore[(*it)].roles;
             for (LfgRolesMap::const_iterator itRoles = roles.begin(); itRoles != roles.end(); ++itRoles)
             {
                 LfgRolesMap::const_iterator itPlayer;
                 for (itPlayer = proposalRoles.begin(); itPlayer != proposalRoles.end(); ++itPlayer)
                 {
                     if (itRoles->first == itPlayer->first)
-                        sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::CheckCompatibility: ERROR! Player multiple times in queue! [" UI64FMTD "]", itRoles->first);
+                        sLog->outError(LOG_FILTER_LFG, "LFGQueue::CheckCompatibility: ERROR! Player multiple times in queue! [" UI64FMTD "]", itRoles->first);
                     else if (sLFGMgr->HasIgnore(itRoles->first, itPlayer->first))
                         break;
                 }
@@ -382,7 +427,7 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
             return LFG_INCOMPATIBLES_HAS_IGNORES;
         }
 
-        LfgRolesMap debugRoles = proposalRoles; // DEBUG
+        LfgRolesMap debugRoles = proposalRoles;
         if (!LFGMgr::CheckGroupRoles(proposalRoles))
         {
             std::ostringstream o;
@@ -395,13 +440,13 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
         }
 
         LfgGuidList::iterator itguid = check.begin();
-        proposalDungeons = m_QueueDataMap[*itguid].dungeons;
+        proposalDungeons = QueueDataStore[*itguid].dungeons;
         std::ostringstream o;
         o << ", " << *itguid << ": (" << sLFGMgr->ConcatenateDungeons(proposalDungeons) << ")";
         for (++itguid; itguid != check.end(); ++itguid)
         {
             LfgDungeonSet temporal;
-            LfgDungeonSet &dungeons = m_QueueDataMap[*itguid].dungeons;
+            LfgDungeonSet &dungeons = QueueDataStore[*itguid].dungeons;
             o << ", " << *itguid << ": (" << sLFGMgr->ConcatenateDungeons(dungeons) << ")";
             std::set_intersection(proposalDungeons.begin(), proposalDungeons.end(), dungeons.begin(), dungeons.end(), std::inserter(temporal, temporal.begin()));
             proposalDungeons = temporal;
@@ -417,7 +462,7 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     else
     {
         uint64 gguid = *check.begin();
-        const LfgQueueData &queue = m_QueueDataMap[gguid];
+        const LfgQueueData &queue = QueueDataStore[gguid];
         proposalDungeons = queue.dungeons;
         proposalRoles = queue.roles;
         LFGMgr::CheckGroupRoles(proposalRoles);          // assing new roles
@@ -427,7 +472,15 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     if (numPlayers != MAXGROUPSIZE)
     {
         sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::CheckCompatibility: (%s) Compatibles but not enough players(%u)", strGuids.c_str(), numPlayers);
-        SetCompatibles(strGuids, LFG_COMPATIBLES_WITH_LESS_PLAYERS);
+        LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(check.front());
+
+        LfgCompatibilityData data(LFG_COMPATIBLES_WITH_LESS_PLAYERS);
+        data.roles = proposalRoles;
+
+        for (LfgGuidList::const_iterator itr = check.begin(); itr != check.end(); ++itr)
+            UpdateBestCompatibleInQueue(QueueDataStore.find(*itr), strGuids, data.roles);
+
+        SetCompatibilityData(strGuids, data);
         return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
     }
 
@@ -488,19 +541,20 @@ LfgCompatibility LfgQueue::CheckCompatibility(LfgGuidList check)
     return LFG_COMPATIBLES_MATCH;
 }
 
-void LfgQueue::UpdateQueueTimers(time_t currTime)
+void LFGQueue::UpdateQueueTimers(time_t currTime)
 {
-    for (LfgQueueDataMap::const_iterator itQueue = m_QueueDataMap.begin(); itQueue != m_QueueDataMap.end(); ++itQueue)
+    sLog->outTrace(LOG_FILTER_LFG, "Updating queue timers...");
+    for (LfgQueueDataContainer::iterator itQueue = QueueDataStore.begin(); itQueue != QueueDataStore.end(); ++itQueue)
     {
-        const LfgQueueData &queueinfo = itQueue->second;
+        LfgQueueData& queueinfo = itQueue->second;
         uint32 dungeonId = (*queueinfo.dungeons.begin());
         uint32 queuedTime = uint32(currTime - queueinfo.joinTime);
         uint8 role = PLAYER_ROLE_NONE;
         int32 waitTime = -1;
-        int32 wtTank = m_waitTimesTank[dungeonId].time;
-        int32 wtHealer = m_waitTimesHealer[dungeonId].time;
-        int32 wtDps = m_waitTimesDps[dungeonId].time;
-        int32 wtAvg = m_waitTimesAvg[dungeonId].time;
+        int32 wtTank = waitTimesTankStore[dungeonId].time;
+        int32 wtHealer = waitTimesHealerStore[dungeonId].time;
+        int32 wtDps = waitTimesDpsStore[dungeonId].time;
+        int32 wtAvg = waitTimesAvgStore[dungeonId].time;
 
         for (LfgRolesMap::const_iterator itPlayer = queueinfo.roles.begin(); itPlayer != queueinfo.roles.end(); ++itPlayer)
             role |= itPlayer->second;
@@ -525,6 +579,9 @@ void LfgQueue::UpdateQueueTimers(time_t currTime)
                 break;
         }
 
+        if (queueinfo.bestCompatible.empty())
+            FindBestCompatibleInQueue(itQueue);
+
         LfgQueueStatusData queueData(dungeonId, waitTime, wtAvg, wtTank, wtHealer, wtDps, queuedTime, queueinfo.tanks, queueinfo.healers, queueinfo.dps);
         for (LfgRolesMap::const_iterator itPlayer = queueinfo.roles.begin(); itPlayer != queueinfo.roles.end(); ++itPlayer)
         {
@@ -534,17 +591,12 @@ void LfgQueue::UpdateQueueTimers(time_t currTime)
     }
 }
 
-time_t LfgQueue::GetJoinTime(uint64 guid)
+time_t LFGQueue::GetJoinTime(uint64 guid)
 {
-    return m_QueueDataMap[guid].joinTime;
+    return QueueDataStore[guid].joinTime;
 }
 
-LfgCompatibleMap const& LfgQueue::GetCompatibleMap()
-{
-    return m_CompatibleMap;
-}
-
-std::string LfgQueue::DumpQueueInfo() const
+std::string LFGQueue::DumpQueueInfo() const
 {
     uint32 players = 0;
     uint32 groups = 0;
@@ -552,30 +604,77 @@ std::string LfgQueue::DumpQueueInfo() const
 
     for (uint8 i = 0; i < 2; ++i)
     {
-        LfgGuidList const& queue = i ? m_newToQueue : m_currentQueue;
+        LfgGuidList const& queue = i ? newToQueueStore : currentQueueStore;
         for (LfgGuidList::const_iterator it = queue.begin(); it != queue.end(); ++it)
         {
             uint64 guid = *it;
             if (IS_GROUP(guid))
             {
                 groups++;
-                if (Group const* group = sGroupMgr->GetGroupByGUID(GUID_LOPART(guid)))
-                    playersInGroup += group->GetMembersCount();
-                else
-                    playersInGroup += 2; // Shouldn't happen but just in case
+                playersInGroup += sLFGMgr->GetPlayerCount(guid);
             }
             else
                 players++;
         }
     }
     std::ostringstream o;
-    o << "Queued Players: " << players << "(in group: " << playersInGroup << ") Groups: " << groups << "\n";
+    o << "Queued Players: " << players << " (in group: " << playersInGroup << ") Groups: " << groups << "\n";
     return o.str();
 }
 
-std::string LfgQueue::DumpCompatibleInfo() const
+std::string LFGQueue::DumpCompatibleInfo(bool full /* = false */) const
 {
     std::ostringstream o;
-    o << "Compatible Map size: " << m_CompatibleMap.size() << "\n";
+    o << "Compatible Map size: " << CompatibleMapStore.size() << "\n";
+    if (full)
+        for (LfgCompatibleContainer::const_iterator itr = CompatibleMapStore.begin(); itr != CompatibleMapStore.end(); ++itr)
+            o << "(" << itr->first << "): " << GetCompatibleString(itr->second.compatibility) << "\n";
+
     return o.str();
 }
+
+void LFGQueue::FindBestCompatibleInQueue(LfgQueueDataContainer::iterator itrQueue)
+{
+    sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::FindBestCompatibleInQueue: " UI64FMTD, itrQueue->first);
+    std::ostringstream o;
+    o << itrQueue->first;
+    std::string sguid = o.str();
+
+    for (LfgCompatibleContainer::const_iterator itr = CompatibleMapStore.begin(); itr != CompatibleMapStore.end(); ++itr)
+        if (itr->second.compatibility == LFG_COMPATIBLES_WITH_LESS_PLAYERS && 
+            std::string::npos != itr->first.find(sguid))
+        {
+            UpdateBestCompatibleInQueue(itrQueue, itr->first, itr->second.roles);
+        }
+}
+
+void LFGQueue::UpdateBestCompatibleInQueue(LfgQueueDataContainer::iterator itrQueue, std::string const& key, LfgRolesMap const& roles)
+{
+    LfgQueueData& queueData = itrQueue->second;
+
+    uint8 storedSize = queueData.bestCompatible.empty() ? 0 : 
+        std::count(queueData.bestCompatible.begin(), queueData.bestCompatible.end(), '|') + 1;
+
+    uint8 size = std::count(key.begin(), key.end(), '|') + 1;
+
+    if (size <= storedSize)
+        return;
+
+    sLog->outDebug(LOG_FILTER_LFG, "LFGQueue::UpdateBestCompatibleInQueue: Changed (%s) to (%s) as best compatible group for " UI64FMTD,
+        queueData.bestCompatible.c_str(), key.c_str(), itrQueue->first);
+
+    queueData.bestCompatible = key;
+    queueData.tanks = LFG_TANKS_NEEDED;
+    queueData.healers = LFG_HEALERS_NEEDED;
+    queueData.dps = LFG_DPS_NEEDED;
+    for (LfgRolesMap::const_iterator it = roles.begin(); it != roles.end(); ++it)
+    {
+        uint8 role = it->second;
+        if (role & PLAYER_ROLE_TANK)
+            --queueData.tanks;
+        else if (role & PLAYER_ROLE_HEALER)
+            --queueData.healers;
+        else
+            --queueData.dps;
+    }
+}
\ No newline at end of file