std::map<JID, std::string> participantsNames;

for (auto& i : invitees_[jid]) {

participantsNames.emplace(i, roster_->getNameForJID(i));

}

chat.inviteesNames = participantsNames;

return chat;

}

}

return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

Presence::ref presence = presenceOracle_->getAccountPresence(bareishJID);

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

}

}

void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {

const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;

ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

/* FIXME: handle nick changes */

appendRecent(chat);

handleUnreadCountChanged(nullptr);

saveRecents();

}

void ChatsManager::handleChatClosed(const JID& /*jid*/) {

cleanupPrivateMessageRecents();

chatListWindow_->setRecents(recentChats_);

}

void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {

int unreadTotal = 0;

bool controllerIsMUC = dynamic_cast<MUCController*>(controller);

bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());

for (ChatListWindow::Chat& chatItem : recentChats_) {

bool match = false;

if (controller) {

/* Matching MUC item */

match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

/* Matching PM */

match |= isPM && chatItem.jid == controller->getToJID();

/* Matching non-PM */

match |= !isPM && !controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

}

if (match) {

chatItem.setUnreadCount(controller->getUnreadCount());

}

unreadTotal += chatItem.unreadCount;

}

chatListWindow_->setRecents(recentChats_);

chatListWindow_->setUnreadCount(unreadTotal);

}

MUCController* controller = nullptr;

SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = nullptr;

if (reuseChatwindow) {

chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

}

std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat); /* a message parser that knows this is a room/MUC (not a chat) */

controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_);

if (chatWindowFactoryAdapter) {

/* The adapters are only passed to chat windows, which are deleted in their

* controllers' dtor, which are deleted in ChatManager's dtor. The adapters

* are also deleted there.*/

chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

}

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

controller->onUserNicknameChanged.connect(boost::bind(&ChatsManager::handleUserNicknameChanged, this, controller, _1, _2));

controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));

controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

if (!stanzaChannel_->isAvailable()) {

/* When online, the MUC is added to the registry in MUCImpl::internalJoin. This method is not

* called when Swift is offline, so we add it here as only MUCs in the registry are rejoined

* when going back online.

*/

mucRegistry_->addMUC(mucJID.toBare());

}

handleChatActivity(mucJID.toBare(), "", true);

}

auto chatListWindowIter = std::find_if(recentChats_.begin(), recentChats_.end(), [&](const ChatListWindow::Chat& chatListWindow) { return mucJID == (chatListWindow.jid); });

mucControllers_[mucJID]->setChatWindowTitle(chatListWindowIter->getTitle());

}

mucControllers_[mucJID]->showChatWindow();

return muc;

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

void ChatsManager::handleUserNicknameChanged(MUCController* mucController, const std::string& oldNickname, const std::string& newNickname) {

JID oldMUCChatJID = mucController->getToJID().withResource(oldNickname);

JID newMUCChatJID = mucController->getToJID().withResource(newNickname);

SWIFT_LOG(debug) << "nickname change in " << mucController->getToJID().toString() << " from " << oldNickname << " to " << newNickname << std::endl;

// get current chat controller

ChatController *chatController = getChatControllerIfExists(oldMUCChatJID);

if (chatController) {

// adjust chat controller

chatController->setToJID(newMUCChatJID);

nickResolver_->onNickChanged(newMUCChatJID, oldNickname);

chatControllers_.erase(oldMUCChatJID);

chatControllers_[newMUCChatJID] = chatController;

chatController->onActivity.disconnect(boost::bind(&ChatsManager::handleChatActivity, this, oldMUCChatJID, _1, false));

chatController->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, newMUCChatJID, _1, false));

}

}