#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>

#include <Swift/Controllers/SettingConstants.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);

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

settings_->onSettingChanged.connect(boost::bind(&RosterController::handleSettingChanged, this, _1));

}

RosterController::~RosterController() {

settings_->onSettingChanged.disconnect(boost::bind(&RosterController::handleSettingChanged, this, _1));

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();

}

mainLayout->addWidget(tabs_);

contactsTabWidget_ = new QWidget(this);

contactsTabWidget_->setContentsMargins(0, 0, 0, 0);

QBoxLayout *contactTabLayout = new QBoxLayout(QBoxLayout::TopToBottom, contactsTabWidget_);

contactsTabWidget_->setLayout(contactTabLayout);

contactTabLayout->setSpacing(0);

contactTabLayout->setContentsMargins(0, 0, 0, 0);

treeWidget_ = new QtRosterWidget(uiEventStream_, settings_, this);

contactTabLayout->addWidget(treeWidget_);

tabs_->addTab(contactsTabWidget_, tr("&Contacts"));

eventWindow_ = new QtEventWindow(uiEventStream_);

connect(eventWindow_, SIGNAL(onNewEventCountUpdated(int)), this, SLOT(handleEventCountUpdated(int)));

chatListWindow_ = new QtChatListWindow(uiEventStream_, settings_);

connect(chatListWindow_, SIGNAL(onCountUpdated(int)), this, SLOT(handleChatCountUpdated(int)));

tabs_->addTab(chatListWindow_, tr("C&hats"));

tabs_->addTab(eventWindow_, tr("&Notices"));

tabs_->setCurrentIndex(settings_->getSetting(QtUISettingConstants::CURRENT_ROSTER_TAB));

connect(tabs_, SIGNAL(currentChanged(int)), this, SLOT(handleTabChanged(int)));

this->setLayout(mainLayout);

QMenu* viewMenu = new QMenu(tr("&View"), this);

menus_.push_back(viewMenu);

showOfflineAction_ = new QAction(tr("&Show offline contacts"), this);

showOfflineAction_->setCheckable(true);

showOfflineAction_->setChecked(false);

connect(showOfflineAction_, SIGNAL(toggled(bool)), SLOT(handleShowOfflineToggled(bool)));

viewMenu->addAction(showOfflineAction_);

//QAction* compactRosterAction_ = new QAction(tr("&Compact Roster"), this);

//compactRosterAction_->setCheckable(true);

//compactRosterAction_->setChecked(false);

//connect(compactRosterAction_, SIGNAL(toggled(bool)), uiPreferences_, SLOT(setCompactRosters(bool)));

//viewMenu->addAction(compactRosterAction_);

QMenu* actionsMenu = new QMenu(tr("&Actions"), this);

menus_.push_back(actionsMenu);

QAction* editProfileAction = new QAction(tr("Edit &Profile"), this);

connect(editProfileAction, SIGNAL(triggered()), SLOT(handleEditProfileAction()));

actionsMenu->addAction(editProfileAction);

QAction* joinMUCAction = new QAction(tr("Enter &Room"), this);

connect(joinMUCAction, SIGNAL(triggered()), SLOT(handleJoinMUCAction()));

actionsMenu->addAction(joinMUCAction);

addUserAction_ = new QAction(tr("&Add Contact"), this);

connect(addUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleAddUserActionTriggered(bool)));

actionsMenu->addAction(addUserAction_);

editUserAction_ = new QAction(tr("&Edit Selected Contact"), this);

connect(editUserAction_, SIGNAL(triggered(bool)), treeWidget_, SLOT(handleEditUserActionTriggered(bool)));

actionsMenu->addAction(editUserAction_);

editUserAction_->setEnabled(false);

chatUserAction_ = new QAction(tr("Start &Chat"), this);

connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));

actionsMenu->addAction(chatUserAction_);

serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);

actionsMenu->addMenu(serverAdHocMenu_);

actionsMenu->addSeparator();

QAction* signOutAction = new QAction(tr("&Sign Out"), this);

connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));

actionsMenu->addAction(signOutAction);

toggleRequestDeliveryReceipts_ = new QAction(tr("&Request Delivery Receipts"), this);

toggleRequestDeliveryReceipts_->setCheckable(true);

toggleRequestDeliveryReceipts_->setChecked(settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS));

connect(toggleRequestDeliveryReceipts_, SIGNAL(toggled(bool)), SLOT(handleToggleRequestDeliveryReceipts(bool)));

loginMenus_.generalMenu->addAction(toggleRequestDeliveryReceipts_);

treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QAction::setEnabled, editUserAction_, _1));

setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

QAction* adHocAction = new QAction(tr("Collecting commands..."), this);

adHocAction->setEnabled(false);

serverAdHocMenu_->addAction(adHocAction);

serverAdHocCommandActions_.append(adHocAction);

settings_->onSettingChanged.connect(boost::bind(&QtMainWindow::handleSettingChanged, this, _1));

}

QtMainWindow::~QtMainWindow() {

settings_->onSettingChanged.disconnect(boost::bind(&QtMainWindow::handleSettingChanged, this, _1));

}

void QtMainWindow::handleTabChanged(int index) {

settings_->storeSetting(QtUISettingConstants::CURRENT_ROSTER_TAB, index);

}

void QtMainWindow::handleToggleRequestDeliveryReceipts(bool enabled) {

settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, enabled);

}

QtEventWindow* QtMainWindow::getEventWindow() {

return eventWindow_;

}

QtChatListWindow* QtMainWindow::getChatListWindow() {

return chatListWindow_;

}

void QtMainWindow::setRosterModel(Roster* roster) {

treeWidget_->setRosterModel(roster);

}

void QtMainWindow::handleEditProfileRequest() {

uiEventStream_->send(boost::make_shared<RequestProfileEditorUIEvent>());

}

void QtMainWindow::handleEventCountUpdated(int count) {

QColor eventTabColor = (count == 0) ? QColor() : QColor(255, 0, 0); // invalid resets to default

int eventIndex = 2;

tabs_->tabBar()->setTabTextColor(eventIndex, eventTabColor);

uiEventStream_->send(event);

}

void QtMainWindow::handleChatUserActionTriggered(bool /*checked*/) {

boost::shared_ptr<UIEvent> event(new RequestChatWithUserDialogUIEvent());

uiEventStream_->send(event);

}

void QtMainWindow::handleSignOutAction() {

loginMenus_.generalMenu->removeAction(toggleRequestDeliveryReceipts_);

onSignOutRequest();

}

void QtMainWindow::handleEditProfileAction() {

uiEventStream_->send(boost::make_shared<RequestProfileEditorUIEvent>());

}

void QtMainWindow::handleJoinMUCAction() {

uiEventStream_->send(boost::make_shared<RequestJoinMUCUIEvent>());

}

void QtMainWindow::handleStatusChanged(StatusShow::Type showType, const QString &statusMessage) {

onChangeStatusRequest(showType, Q2PSTRING(statusMessage));

}

void QtMainWindow::handleSettingChanged(const std::string& settingPath) {

if (settingPath == SettingConstants::SHOW_OFFLINE.getKey()) {

handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));

}

if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

toggleRequestDeliveryReceipts_->setChecked(settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS));

}

}

void QtMainWindow::handleShowOfflineToggled(bool state) {

}

void QtMainWindow::setMyNick(const std::string& nick) {

meView_->setNick(P2QSTRING(nick));

}

void QtMainWindow::setMyJID(const JID& jid) {

meView_->setJID(P2QSTRING(jid.toBare().toString()));

}

void QtMainWindow::setMyAvatarPath(const std::string& path) {

meView_->setAvatar(P2QSTRING(path));

}

void QtMainWindow::setMyStatusText(const std::string& status) {

meView_->setStatusText(P2QSTRING(status));

}

void QtMainWindow::setMyStatusType(StatusShow::Type type) {

meView_->setStatusType(type);

}

void QtMainWindow::setConnecting() {

meView_->setConnecting();

}

void QtMainWindow::handleAdHocActionTriggered(bool /*checked*/) {

QAction* action = qobject_cast<QAction*>(sender());

assert(action);

DiscoItems::Item command = serverAdHocCommands_[serverAdHocCommandActions_.indexOf(action)];

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestAdHocUIEvent(command)));

}

void QtMainWindow::setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) {

serverAdHocCommands_ = commands;

void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands);

private slots:

void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);

void handleSettingChanged(const std::string& settingPath);

void handleShowOfflineToggled(bool);

void handleJoinMUCAction();

void handleSignOutAction();

void handleEditProfileAction();

void handleAddUserActionTriggered(bool checked);

void handleChatUserActionTriggered(bool checked);

void handleAdHocActionTriggered(bool checked);

void handleEventCountUpdated(int count);

void handleChatCountUpdated(int count);

void handleEditProfileRequest();

void handleTabChanged(int index);

void handleToggleRequestDeliveryReceipts(bool enabled);

private:

SettingsProvider* settings_;

QtLoginWindow::QtMenus loginMenus_;

std::vector<QMenu*> menus_;

QtRosterWidget* treeWidget_;

QtRosterHeader* meView_;

QAction* addUserAction_;

QAction* editUserAction_;

QAction* chatUserAction_;

QAction* showOfflineAction_;

QAction* toggleRequestDeliveryReceipts_;

QMenu* serverAdHocMenu_;

QtTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

QtEventWindow* eventWindow_;

QtChatListWindow* chatListWindow_;

UIEventStream* uiEventStream_;

std::vector<DiscoItems::Item> serverAdHocCommands_;

QList<QAction*> serverAdHocCommandActions_;

};

}