/*

* Copyright (c) 2010-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Chat/MUCController.h>

#include <algorithm>

#include <memory>

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/range/adaptor/reversed.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/Thread.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <SwifTools/TabComplete.h>

#include <Swift/Controllers/Chat/ChatMessageParser.h>

#include <Swift/Controllers/Highlighting/Highlighter.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/Roster/ContactRosterItem.h>

/**

* The controller does not gain ownership of the stanzaChannel, nor the factory.

*/

MUCController::MUCController (

const JID& self,

MUC::ref muc,

const boost::optional<std::string>& password,

const std::string &nick,

StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

ChatWindowFactory* chatWindowFactory,

NickResolver* nickResolver,

PresenceOracle* presenceOracle,

AvatarManager* avatarManager,

UIEventStream* uiEventStream,

bool useDelayForLatency,

TimerFactory* timerFactory,

EventController* eventController,

EntityCapsProvider* entityCapsProvider,

XMPPRoster* xmppRoster,

HistoryController* historyController,

MUCRegistry* mucRegistry,

HighlightManager* highlightManager,

ClientBlockListManager* clientBlockListManager,

std::shared_ptr<ChatMessageParser> chatMessageParser,

bool isImpromptu,

AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

VCardManager* vcardManager,

MUCBookmarkManager* mucBookmarkManager) :

ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

xmppRoster_ = xmppRoster;

subject_ = "";

isInitialJoin_ = true;

roster_ = std::unique_ptr<Roster>(new Roster(false, true));

rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_.get());

chatWindow_->setTabComplete(completer_);

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

chatMessageParser_->setNick(nick_);

if (timerFactory && stanzaChannel_->isAvailable()) {

loginCheckTimer_ = std::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You are currently offline. You will enter this room when you are connected.")), ChatWindow::DefaultDirection);

}

if (isImpromptu) {

muc_->onUnlocked.connect(boost::bind(&MUCController::handleRoomUnlocked, this));

chatWindow_->convertToMUC(ChatWindow::ImpromptuMUC);

} else {

muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

muc_->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));

chatWindow_->convertToMUC(ChatWindow::StandardMUC);

chatWindow_->setName(muc->getJID().getNode());

}

if (stanzaChannel->isAvailable()) {

MUCController::setOnline(true);

}

MUCController::handleBareJIDCapsChanged(muc->getJID());

eventStream_->onUIEvent.connect(boost::bind(&MUCController::handleUIEvent, this, _1));

// setup handling of MUC bookmark changes

mucBookmarkManagerBookmarkAddedConnection_ = (mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&MUCController::handleMUCBookmarkAdded, this, _1)));

mucBookmarkManagerBookmarkRemovedConnection_ = (mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&MUCController::handleMUCBookmarkRemoved, this, _1)));

std::vector<MUCBookmark> mucBookmarks = mucBookmarkManager_->getBookmarks();

std::vector<MUCBookmark>::iterator bookmarkIterator = std::find_if(mucBookmarks.begin(), mucBookmarks.end(), MUCBookmarkPredicate(muc->getJID()));

if (bookmarkIterator != mucBookmarks.end()) {

updateChatWindowBookmarkStatus(*bookmarkIterator);

}

else {

updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());

}

}

MUCController::~MUCController() {

eventStream_->onUIEvent.disconnect(boost::bind(&MUCController::handleUIEvent, this, _1));

chatWindow_->setRosterModel(nullptr);

delete rosterVCardProvider_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(nullptr);

delete completer_;

}

void MUCController::cancelReplaces() {

appendToJoinParts(joinParts_, event);

MUCOccupant::Role role = MUCOccupant::Participant;

MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

if (!isImpromptu_) {

role = occupant.getRole();

affiliation = occupant.getAffiliation();

}

std::string groupName(roleToGroupName(role));

roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid));

roster_->applyOnItems(SetMUC(jid, role, affiliation));

roster_->getGroup(groupName)->setManualSort(roleToSortName(role));

if (joined_) {

std::string joinString;

if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %3% as a %2%.")) % occupant.getNick() % roleToFriendlyName(role) % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

else {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %2%.")) % occupant.getNick() % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

addPresenceMessage(joinString);

}

if (isImpromptu_) {

setImpromptuWindowTitle();

onActivity("");

}

}

}

void MUCController::addPresenceMessage(const std::string& message) {

lastWasPresence_ = true;

chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(message), ChatWindow::DefaultDirection);

}

void MUCController::setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role)

{

std::vector<ChatWindow::RoomAction> actions;

if (role <= MUCOccupant::Participant) {

actions.push_back(ChatWindow::ChangeSubject);

}

if (affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Configure);

}

if (affiliation <= MUCOccupant::Admin) {

actions.push_back(ChatWindow::Affiliations);

}

if (affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Destroy);

}

if (role <= MUCOccupant::Visitor) {

actions.push_back(ChatWindow::Invite);

}

chatWindow_->setAvailableRoomActions(actions);

}

// adjust occupants

currentOccupants_.erase(oldNickname);

currentOccupants_.insert(newNickname);

// adjust completer

completer_->removeWord(oldNickname);

completer_->addWord(newNickname);

// update contact

roster_->removeContact(oldJID);

auto it = currentOccupants_.find(newNickname);

if (it != currentOccupants_.end()) {

roster_->removeContact(newJID);

}

MUCOccupant occupant = muc_->getOccupant(newNickname);

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

MUCOccupant::Role role = MUCOccupant::Participant;

MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

if (!isImpromptu_) {

role = occupant.getRole();

affiliation = occupant.getAffiliation();

}

std::string groupName(roleToGroupName(role));

roster_->addContact(newJID, realJID, newNickname, groupName, avatarManager_->getAvatarPath(newJID));

roster_->applyOnItems(SetMUC(newJID, role, affiliation));

clearPresenceQueue();

onUserNicknameChanged(oldNickname, newNickname);

}

void MUCController::handleOccupantPresenceChange(std::shared_ptr<Presence> presence) {

receivedActivity();

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

bool MUCController::isIncomingMessageFromMe(std::shared_ptr<Message> message) {

JID from = message->getFrom();

return nick_ == from.getResource();

}

std::string MUCController::senderHighlightNameFromMessage(const JID& from) {

return from.getResource();

}

std::string MUCController::senderDisplayNameFromMessage(const JID& from) {

return from.getResource();

}

void MUCController::preSendMessageRequest(std::shared_ptr<Message> message) {

message->setType(Swift::Message::Groupchat);

}

boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(std::shared_ptr<Message> message) const {

return message->getTimestampFrom(toJID_);

}