+#include <boost/archive/text_oarchive.hpp>

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/serialization/vector.hpp>

+#include <boost/serialization/map.hpp>

+#include <boost/serialization/string.hpp>

+#include <boost/serialization/split_free.hpp>

+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

+#include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>

+#include <Swift/Controllers/Chat/UserSearchController.h>

+#include <Swiften/Disco/DiscoServiceWalker.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/StringCodecs/Base64.h>

+#include <Swiften/Base/Log.h>

+

+namespace boost {

+namespace serialization {

+ template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {

+ std::string jidStr = jid.toString();

+ ar << jidStr;

+ }

+

+ template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {

+ std::string stringJID;

+ ar >> stringJID;

+ jid = Swift::JID(stringJID);

+ }

+

+ template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version){

+ split_free(ar, t, file_version);

+ }

+

+ template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int /*version*/) {

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ }

+}

+}

+ const std::map<std::string, std::string>& emoticons,

+ UserSearchController* inviteUserSearchController) :

+ clientBlockListManager_(clientBlockListManager),

+ inviteUserSearchController_(inviteUserSearchController) {

+

+ autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(jid.getDomain(), roster_, settings_);

+ delete autoAcceptMUCInviteDecider_;

+ std::stringstream serializeStream;

+ boost::archive::text_oarchive oa(serializeStream);

+ std::vector<ChatListWindow::Chat> recentsLimited = std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

+ if (recentsLimited.size() > 25) {

+ recentsLimited.erase(recentsLimited.begin() + 25, recentsLimited.end());

+ }

+ if (eagleMode_) {

+ foreach(ChatListWindow::Chat& chat, recentsLimited) {

+ chat.activity = "";

+

+ oa << recentsLimited;

+ std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));

+ profileSettings_->storeString(RECENT_CHATS, serializedStr);

+ChatListWindow::Chat ChatsManager::updateChatStatusAndAvatarHelper(const ChatListWindow::Chat& chat) const {

+ ChatListWindow::Chat fixedChat = chat;

+ if (fixedChat.isMUC) {

+ if (mucControllers_.find(fixedChat.jid.toBare()) != mucControllers_.end()) {

+ fixedChat.statusType = StatusShow::Online;

+ } else {

+ if (avatarManager_) {

+ fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);

+ Presence::ref presence = presenceOracle_->getHighestPriorityPresence(fixedChat.jid.toBare());

+ fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

+ }

+ return fixedChat;

+}

+

+void ChatsManager::loadRecents() {

+ std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));

+ if (recentsString.find("\t") != std::string::npos) {

+ // old format

+ std::vector<std::string> recents;

+ boost::split(recents, recentsString, boost::is_any_of("\n"));

+ int i = 0;

+ foreach (std::string recentString, recents) {

+ if (i++ > 30) {

+ break;

+ std::vector<std::string> recent;

+ boost::split(recent, recentString, boost::is_any_of("\t"));

+ if (recent.size() < 4) {

+ continue;

+ }

+ JID jid(recent[0]);

+ if (!jid.isValid()) {

+ continue;

+ std::string activity(recent[1]);

+ bool isMUC = recent[2] == "true";

+ std::string nick(recent[3]);

+ StatusShow::Type type = StatusShow::None;

+ boost::filesystem::path path;

+

+ ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, nick);

+ chat = updateChatStatusAndAvatarHelper(chat);

+ prependRecent(chat);

+ }

+ } else if (!recentsString.empty()){

+ // boost searilaize based format

+ ByteArray debase64 = Base64::decode(recentsString);

+ std::vector<ChatListWindow::Chat> recentChats;

+ std::stringstream deserializeStream(std::string((const char*)debase64.data(), debase64.size()));

+ try {

+ boost::archive::text_iarchive ia(deserializeStream);

+ ia >> recentChats;

+ } catch (const boost::archive::archive_exception& e) {

+ SWIFT_LOG(debug) << "Failed to load recents: " << e.what() << std::endl;

+ return;

+ foreach(ChatListWindow::Chat chat, recentChats) {

+ chat.statusType = StatusShow::None;

+ chat = updateChatStatusAndAvatarHelper(chat);

+ prependRecent(chat);

+ }

+ handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false, false );

+

+ if (controller->isImpromptu()) {

+ ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::map<std::string, JID> participants = controller->getParticipantJIDs();

+ chat.impromptuJIDs = participants;

+ return chat;

+ }

+boost::optional<ChatListWindow::Chat> ChatsManager::removeExistingChat(const ChatListWindow::Chat& chat) {

+ std::list<ChatListWindow::Chat>::iterator result = std::find(recentChats_.begin(), recentChats_.end(), chat);

+ if (result != recentChats_.end()) {

+ ChatListWindow::Chat existingChat = *result;

+ recentChats_.erase(std::remove(recentChats_.begin(), recentChats_.end(), chat), recentChats_.end());

+ return boost::optional<ChatListWindow::Chat>(existingChat);

+ } else {

+ return boost::optional<ChatListWindow::Chat>();

+ }

+}

+

+ boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);

+ ChatListWindow::Chat mergedChat = chat;

+ if (oldChat && !oldChat->impromptuJIDs.empty()) {

+ mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());

+ }

+ recentChats_.push_front(mergedChat);

+ boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);

+ ChatListWindow::Chat mergedChat = chat;

+ if (oldChat && !oldChat->impromptuJIDs.empty()) {

+ mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());

+ }

+ recentChats_.push_back(mergedChat);

+void ChatsManager::finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID) {

+ // send impromptu invites for the new MUC

+ std::vector<JID> missingJIDsToInvite = jidsToInvite;

+

+ typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;

+ std::map<std::string, MUCOccupant> occupants = muc->getOccupants();

+ foreach(StringMUCOccupantPair occupant, occupants) {

+ boost::optional<JID> realJID = occupant.second.getRealJID();

+ if (realJID) {

+ missingJIDsToInvite.erase(std::remove(missingJIDsToInvite.begin(), missingJIDsToInvite.end(), realJID->toBare()), missingJIDsToInvite.end());

+ }

+ }

+

+ if (reuseChatJID) {

+ muc->invitePerson(reuseChatJID.get(), reason, true, true);

+ }

+ foreach(const JID& jid, missingJIDsToInvite) {

+ muc->invitePerson(jid, reason, true);

+ }

+}

+

+ boost::shared_ptr<CreateImpromptuMUCUIEvent> createImpromptuMUCEvent = boost::dynamic_pointer_cast<CreateImpromptuMUCUIEvent>(event);

+ if (createImpromptuMUCEvent) {

+ assert(!localMUCServiceJID_.toString().empty());

+ // create new muc

+ JID roomJID = createImpromptuMUCEvent->getRoomJID().toString().empty() ? JID(idGenerator_.generateID(), localMUCServiceJID_) : createImpromptuMUCEvent->getRoomJID();

+

+ // join muc

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), false, true, true);

+ mucControllers_[roomJID]->onImpromptuConfigCompleted.connect(boost::bind(&ChatsManager::finalizeImpromptuJoin, this, muc, createImpromptuMUCEvent->getJIDs(), createImpromptuMUCEvent->getReason(), boost::optional<JID>()));

+ mucControllers_[roomJID]->activateChatWindow();

+ }

+ handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically(), joinEvent->getCreateAsReservedRoomIfNew(), joinEvent->isImpromptu());

+void ChatsManager::handleTransformChatToMUC(ChatController* chatController, ChatWindow* chatWindow, const std::vector<JID>& jidsToInvite, const std::string& reason) {

+ JID reuseChatInvite = chatController->getToJID();

+ chatControllers_.erase(chatController->getToJID());

+ delete chatController;

+

+ // join new impromptu muc

+ assert(!localMUCServiceJID_.toString().empty());

+

+ // create new muc

+ JID roomJID = JID(idGenerator_.generateID(), localMUCServiceJID_);

+

+ // join muc

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), false, true, true, chatWindow);

+ mucControllers_[roomJID]->onImpromptuConfigCompleted.connect(boost::bind(&ChatsManager::finalizeImpromptuJoin, this, muc, jidsToInvite, reason, boost::optional<JID>(reuseChatInvite)));

+}

+

+ localMUCServiceFinderWalker_ = boost::make_shared<DiscoServiceWalker>(jid_.getDomain(), iqRouter_);

+ localMUCServiceFinderWalker_->onServiceFound.connect(boost::bind(&ChatsManager::handleLocalServiceFound, this, _1, _2));

+ localMUCServiceFinderWalker_->onWalkAborted.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

+ localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

+ localMUCServiceFinderWalker_->beginWalk();

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, autoAcceptMUCInviteDecider_);

+ controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));

+ controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());

+MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow) {

+ MUC::ref muc;

+ return muc;

+ muc = mucManager->createMUC(mucJID);

+ if (isImpromptu) {

+ muc->setCreateAsReservedIfNew();

+ }

+

+ MUCController* controller = NULL;

+ SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

+ if (reuseChatwindow) {

+ chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

+ }

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

+ 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;

+ }

+

+ return muc;

+

+ // check for impromptu invite to potentially auto-accept

+ MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

+ if (invite && autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

+ if (invite->getIsContinuation()) {

+ // check for existing chat controller for the from JID

+ ChatController* controller = getChatControllerIfExists(jid);

+ if (controller) {

+ ChatWindow* window = controller->detachChatWindow();

+ chatControllers_.erase(jid);

+ delete controller;

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true, window);

+ }

+ } else {

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true);

+ return;

+ }

+ }

+

+ if (chat.isMUC && !chat.impromptuJIDs.empty()) {

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::vector<JID> inviteJIDs;

+ foreach(StringJIDPair pair, chat.impromptuJIDs) {

+ inviteJIDs.push_back(pair.second);

+ }

+ uiEventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(inviteJIDs, chat.jid, ""));

+ }

+ else if (chat.isMUC) {

+void ChatsManager::handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info) {

+ foreach (DiscoInfo::Identity identity, info->getIdentities()) {

+ if ((identity.getCategory() == "directory"

+ && identity.getType() == "chatroom")

+ || (identity.getCategory() == "conference"

+ && identity.getType() == "text")) {

+ localMUCServiceJID_ = service;

+ localMUCServiceFinderWalker_->endWalk();

+ SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_ << std::endl;

+ break;

+ }

+ }

+}

+

+void ChatsManager::handleLocalServiceWalkFinished() {

+ onImpromptuMUCServiceDiscovered(!localMUCServiceJID_.toString().empty());

+}

+

+std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

+ return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

+}

+

+std::vector<Contact> Swift::ChatsManager::getContacts() {

+ std::vector<Contact> result;

+ foreach (ChatListWindow::Chat chat, recentChats_) {

+ if (!chat.isMUC) {

+ result.push_back(Contact(chat.chatName.empty() ? chat.jid.toString() : chat.chatName, chat.jid, chat.statusType, chat.avatarPath));

+ }

+ }

+ return result;

+}

+

+ChatsManager::SingleChatWindowFactoryAdapter::SingleChatWindowFactoryAdapter(ChatWindow* chatWindow) : chatWindow_(chatWindow) {}

+ChatsManager::SingleChatWindowFactoryAdapter::~SingleChatWindowFactoryAdapter() {}

+ChatWindow* ChatsManager::SingleChatWindowFactoryAdapter::createChatWindow(const JID &, UIEventStream*) {

+ return chatWindow_;

+}

+