/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Swift/Controllers/Roster/RosterController.h"

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include "Swiften/JID/JID.h"

#include "Swiften/Base/foreach.h"

#include "Swift/Controllers/UIInterfaces/MainWindow.h"

#include "Swift/Controllers/UIInterfaces/MainWindowFactory.h"

#include "Swiften/Client/NickResolver.h"

#include "Swiften/Roster/GetRosterRequest.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h"

#include "Swift/Controllers/XMPPEvents/ErrorEvent.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Presence/SubscriptionManager.h"

#include "Swift/Controllers/XMPPEvents/EventController.h"

#include "Swiften/Queries/IQRouter.h"

#include "Swift/Controllers/Roster/Roster.h"

#include "Swift/Controllers/Roster/SetPresence.h"

#include "Swift/Controllers/Roster/AppearOffline.h"

#include "Swift/Controllers/Roster/SetAvatar.h"

#include "Swift/Controllers/Roster/SetName.h"

#include "Swift/Controllers/Roster/OfflineRosterFilter.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include "Swiften/Roster/XMPPRoster.h"

#include "Swiften/Roster/XMPPRosterItem.h"

#include "Swift/Controllers/UIEvents/AddContactUIEvent.h"

#include "Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h"

#include "Swift/Controllers/UIEvents/RenameRosterItemUIEvent.h"

#include "Swift/Controllers/UIEvents/RenameGroupUIEvent.h"

#include "Swift/Controllers/UIEvents/SendFileUIEvent.h"

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/Client/NickManager.h>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Disco/EntityCapsManager.h>

#include <Swiften/Jingle/JingleSessionManager.h>

namespace Swift {

/**

* The controller does not gain ownership of these parameters.

*/

RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview)

: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview) {

assert(fileTransferOverview);

iqRouter_ = iqRouter;

presenceOracle_ = presenceOracle;

subscriptionManager_ = subscriptionManager;

eventController_ = eventController;

settings_ = settings;

expandiness_ = new RosterGroupExpandinessPersister(roster_, settings);

roster_->addFilter(offlineFilter_);

mainWindow_->setRosterModel(roster_);

changeStatusConnection_ = mainWindow_->onChangeStatusRequest.connect(boost::bind(&RosterController::handleChangeStatusRequest, this, _1, _2));

signOutConnection_ = mainWindow_->onSignOutRequest.connect(boost::bind(boost::ref(onSignOutRequest)));

xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));

xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));

xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));

xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));

subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));

presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handleIncomingPresence, this, _1));

uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));

avatarManager_ = avatarManager;

avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));

mainWindow_->setMyAvatarPath(avatarManager_->getAvatarPath(myJID_).string());

nickManager_->onOwnNickChanged.connect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

mainWindow_->setMyJID(jid);

mainWindow_->setMyNick(nickManager_->getOwnNick());

entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

}

RosterController::~RosterController() {

nickManager_->onOwnNickChanged.disconnect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

delete offlineFilter_;

delete expandiness_;

mainWindow_->setRosterModel(NULL);

if (mainWindow_->canDelete()) {

delete mainWindow_;

}

delete roster_;

}

void RosterController::setEnabled(bool enabled) {

if (!enabled) {

roster_->applyOnItems(AppearOffline());

}

}

void RosterController::handleShowOfflineToggled(bool state) {

}

if (state) {

roster_->removeFilter(offlineFilter_);

} else {

roster_->addFilter(offlineFilter_);

}

}

void RosterController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

onChangeStatusRequest(show, statusText);

}

void RosterController::handleOnJIDAdded(const JID& jid) {

std::vector<std::string> groups = xmppRoster_->getGroupsForJID(jid);

std::string name = nickResolver_->jidToNick(jid);

if (!groups.empty()) {

foreach(const std::string& group, groups) {

roster_->addContact(jid, jid, name, group, avatarManager_->getAvatarPath(jid).string());

}

}

else {

roster_->addContact(jid, jid, name, QT_TRANSLATE_NOOP("", "Contacts"), avatarManager_->getAvatarPath(jid).string());

}

applyAllPresenceTo(jid);

}

void RosterController::applyAllPresenceTo(const JID& jid) {

foreach (Presence::ref presence, presenceOracle_->getAllPresence(jid)) {

roster_->applyOnItems(SetPresence(presence));

}

}

void RosterController::handleRosterCleared() {

roster_->removeAll();

}

void RosterController::handleOnJIDRemoved(const JID& jid) {

roster_->removeContact(jid);

}

void RosterController::handleOnJIDUpdated(const JID& jid, const std::string& oldName, const std::vector<std::string>& passedOldGroups) {

if (oldName != xmppRoster_->getNameForJID(jid)) {

roster_->applyOnItems(SetName(nickResolver_->jidToNick(jid), jid));

}

std::vector<std::string> groups = xmppRoster_->getGroupsForJID(jid);

std::vector<std::string> oldGroups = passedOldGroups;

std::string name = nickResolver_->jidToNick(jid);

std::string contactsGroup = QT_TRANSLATE_NOOP("", "Contacts");

if (oldGroups.empty()) {

oldGroups.push_back(contactsGroup);

}

if (groups.empty()) {

groups.push_back(contactsGroup);

}

foreach(const std::string& group, groups) {

if (std::find(oldGroups.begin(), oldGroups.end(), group) == oldGroups.end()) {

roster_->addContact(jid, jid, name, group, avatarManager_->getAvatarPath(jid).string());

}

}

foreach(const std::string& group, oldGroups) {

if (std::find(groups.begin(), groups.end(), group) == groups.end()) {

roster_->removeContactFromGroup(jid, group);

if (roster_->getGroup(group)->getChildren().size() == 0) {

roster_->removeGroup(group);

}

}

}

applyAllPresenceTo(jid);

}

}

RosterItemPayload item;

item.setName(addContactEvent->getName());

item.setJID(addContactEvent->getJID());

item.setGroups(std::vector<std::string>(addContactEvent->getGroups().begin(), addContactEvent->getGroups().end()));

boost::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(item);

SetRosterRequest::ref request = SetRosterRequest::create(roster, iqRouter_);

request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

request->send();

subscriptionManager_->requestSubscription(addContactEvent->getJID());

}

else if (boost::shared_ptr<RemoveRosterItemUIEvent> removeEvent = boost::dynamic_pointer_cast<RemoveRosterItemUIEvent>(event)) {

RosterItemPayload item(removeEvent->getJID(), "", RosterItemPayload::Remove);

boost::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(item);

SetRosterRequest::ref request = SetRosterRequest::create(roster, iqRouter_);

request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

request->send();

}

else if (boost::shared_ptr<RenameRosterItemUIEvent> renameEvent = boost::dynamic_pointer_cast<RenameRosterItemUIEvent>(event)) {

JID contact(renameEvent->getJID());

RosterItemPayload item(contact, renameEvent->getNewName(), xmppRoster_->getSubscriptionStateForJID(contact));

item.setGroups(xmppRoster_->getGroupsForJID(contact));

boost::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(item);

SetRosterRequest::ref request = SetRosterRequest::create(roster, iqRouter_);

request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

request->send();

}

else if (boost::shared_ptr<RenameGroupUIEvent> renameGroupEvent = boost::dynamic_pointer_cast<RenameGroupUIEvent>(event)) {

std::vector<XMPPRosterItem> items = xmppRoster_->getItems();

std::string group = renameGroupEvent->getGroup();

// FIXME: We should handle contacts groups specially to avoid clashes

if (group == QT_TRANSLATE_NOOP("", "Contacts")) {

class RosterController {

public:

RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, FileTransferOverview* fileTransferOverview);

~RosterController();

void showRosterWindow();

MainWindow* getWindow() {return mainWindow_;};

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

void handleAvatarChanged(const JID& jid);

void setEnabled(bool enabled);

boost::optional<XMPPRosterItem> getItem(const JID&) const;

std::set<std::string> getGroups() const;

void setContactGroups(const JID& jid, const std::vector<std::string>& groups);

void updateItem(const XMPPRosterItem&);

private:

void handleOnJIDAdded(const JID &jid);

void handleRosterCleared();

void handleOnJIDRemoved(const JID &jid);

void handleOnJIDUpdated(const JID &jid, const std::string& oldName, const std::vector<std::string>& oldGroups);

void handleStartChatRequest(const JID& contact);

void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

void handleShowOfflineToggled(bool state);

void handleIncomingPresence(boost::shared_ptr<Presence> newPresence);

void handleSubscriptionRequest(const JID& jid, const std::string& message);

void handleSubscriptionRequestAccepted(SubscriptionRequestEvent* event);

void handleSubscriptionRequestDeclined(SubscriptionRequestEvent* event);

void handleUIEvent(boost::shared_ptr<UIEvent> event);

void handleRosterSetError(ErrorPayload::ref error, boost::shared_ptr<RosterPayload> rosterPayload);

void applyAllPresenceTo(const JID& jid);

void handleEditProfileRequest();

void handleOnCapsChanged(const JID& jid);

JID myJID_;

XMPPRoster* xmppRoster_;

MainWindowFactory* mainWindowFactory_;

MainWindow* mainWindow_;

Roster* roster_;

OfflineRosterFilter* offlineFilter_;

AvatarManager* avatarManager_;

NickManager* nickManager_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

SubscriptionManager* subscriptionManager_;

EventController* eventController_;

RosterGroupExpandinessPersister* expandiness_;

IQRouter* iqRouter_;

SettingsProvider* settings_;

UIEventStream* uiEventStream_;

EntityCapsProvider* entityCapsManager_;

FileTransferOverview* ftOverview_;

boost::bsignals::scoped_connection changeStatusConnection_;

boost::bsignals::scoped_connection signOutConnection_;

boost::bsignals::scoped_connection uiEventConnection_;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

#include <vector>

#include <Swiften/Base/foreach.h>

namespace Swift {

RosterGroupExpandinessPersister::RosterGroupExpandinessPersister(Roster* roster, SettingsProvider* settings) : roster_(roster), settings_(settings) {

load();

roster_->onGroupAdded.connect(boost::bind(&RosterGroupExpandinessPersister::handleGroupAdded, this, _1));

}

void RosterGroupExpandinessPersister::handleGroupAdded(GroupRosterItem* group) {

if (collapsed_.find(group->getDisplayName()) != collapsed_.end()) {

group->setExpanded(false);

} else {

group->setExpanded(true);

}

group->onExpandedChanged.connect(boost::bind(&RosterGroupExpandinessPersister::handleExpandedChanged, this, group, _1));

}

void RosterGroupExpandinessPersister::handleExpandedChanged(GroupRosterItem* group, bool expanded) {

if (expanded) {

std::string displayName = group->getDisplayName();

//collapsed_.erase(std::remove(collapsed_.begin(), collapsed_.end(), displayName), collapsed_.end());

collapsed_.erase(displayName);

} else {

collapsed_.insert(group->getDisplayName());

}

save();

}

void RosterGroupExpandinessPersister::save() {

std::string setting;

foreach (const std::string& group, collapsed_) {

if (!setting.empty()) {

setting += "\n";

}

setting += group;

}

}

void RosterGroupExpandinessPersister::load() {

std::vector<std::string> collapsed = String::split(saved, '\n');

collapsed_.insert(collapsed.begin(), collapsed.end());

}

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <set>

#include "Swift/Controllers/Roster/Roster.h"

#include "Swift/Controllers/Settings/SettingsProvider.h"

namespace Swift {

class RosterGroupExpandinessPersister {

public:

RosterGroupExpandinessPersister(Roster* roster, SettingsProvider* settings);

private:

void handleExpandedChanged(GroupRosterItem* group, bool expanded);

void handleGroupAdded(GroupRosterItem* group);

void load();

void save();

std::set<std::string> collapsed_;

Roster* roster_;

SettingsProvider* settings_;

};

}