#include "Swift/Controllers/MainController.h"

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/shared_ptr.hpp>

#include <stdlib.h>

#include "Swiften/Application/Application.h"

#include "Swiften/Application/ApplicationMessageDisplay.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/ChatWindowFactory.h"

#include "Swift/Controllers/EventController.h"

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

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

#include "Swift/Controllers/MainWindow.h"

#include "Swift/Controllers/MainWindowFactory.h"

#include "Swift/Controllers/MUCController.h"

#include "Swift/Controllers/NickResolver.h"

#include "Swift/Controllers/ProfileSettingsProvider.h"

#include "Swift/Controllers/RosterController.h"

#include "Swift/Controllers/SoundEventController.h"

#include "Swift/Controllers/SoundPlayer.h"

#include "Swift/Controllers/SystemTray.h"

#include "Swift/Controllers/SystemTrayController.h"

#include "Swift/Controllers/XMLConsoleController.h"

#include "Swift/Controllers/XMPPRosterController.h"

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

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

#include "Swiften/Base/foreach.h"

#include "Swiften/Base/String.h"

#include "Swiften/Client/Client.h"

#include "Swiften/Presence/PresenceSender.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/VCardUpdate.h"

#include "Swiften/Queries/Responders/SoftwareVersionResponder.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Queries/Responders/DiscoInfoResponder.h"

#include "Swiften/Disco/CapsInfoGenerator.h"

#include "Swiften/Queries/Requests/GetDiscoInfoRequest.h"

#include "Swiften/Queries/Requests/GetVCardRequest.h"

#include "Swiften/Avatars/AvatarFileStorage.h"

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/StringCodecs/SHA1.h"

namespace {

void printIncomingData(const Swift::String& data) {

std::cout << "<- " << data << std::endl;

}

void printOutgoingData(const Swift::String& data) {

std::cout << "-> " << data << std::endl;

}

}

namespace Swift {

static const String CLIENT_NAME = "Swift";

static const String CLIENT_VERSION = "0.3";

static const String CLIENT_NODE = "http://swift.im";

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory)

: timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), client_(NULL), presenceSender_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings), xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL) {

application_ = application;

presenceOracle_ = NULL;

avatarManager_ = NULL;

uiEventStream_ = new UIEventStream();

avatarStorage_ = new AvatarFileStorage(application_->getAvatarDir());

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings->getBoolSetting("playSounds", true));

loginWindow_ = loginWindowFactory_->createLoginWindow(uiEventStream_);

foreach (String profile, settings->getAvailableProfiles()) {

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(profile, settings);

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

}

loginWindow_->selectUser(settings_->getStringSetting("lastLoginJID"));

loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4));

loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));

idleDetector_.setIdleTimeSeconds(600);

idleDetector_.onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, xmlConsoleWidgetFactory);

}

void MainController::handleJoinMUCRequest(const JID &muc, const String &nick) {

mucControllers_[muc] = new MUCController(jid_, muc, nick, client_, presenceSender_, client_, chatWindowFactory_, treeWidgetFactory_, presenceOracle_, avatarManager_);

mucControllers_[muc]->setAvailableServerFeatures(serverDiscoInfo_);

}

void MainController::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

if (!event->isReadable()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error) {

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

if (i != mucControllers_.end()) {

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

return;

}

}

//if not a mucroom

eventController_->handleIncomingEvent(event);

getChatController(jid)->handleIncomingMessage(event);

}

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, const boost::optional<ErrorPayload>& error) {

if (!error) {

serverDiscoInfo_ = info;

foreach (JIDChatControllerPair pair, chatControllers_) {

pair.second->setAvailableServerFeatures(info);

}

foreach (JIDMUCControllerPair pair, mucControllers_) {

pair.second->setAvailableServerFeatures(info);

}

}

}

bool MainController::isMUC(const JID& jid) const {

return mucControllers_.find(jid.toBare()) != mucControllers_.end();

}

void MainController::handleOwnVCardReceived(boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error) {

if (!error && !vCard->getPhoto().isEmpty()) {

if (lastSentPresence_) {

sendPresence(lastSentPresence_);

}

avatarManager_->setAvatar(jid_, vCard->getPhoto());

}

}

}

Import("env")

env["SWIFT_CONTROLLERS_FLAGS"] = {

"LIBPATH": [Dir(".")],

"LIBS": ["SwiftControllers"]

}

myenv = env.Clone()

myenv.MergeFlags(env["BOOST_FLAGS"])

myenv.StaticLibrary("SwiftControllers", [

"ChatController.cpp",

"ChatControllerBase.cpp",

"MainController.cpp",

"NickResolver.cpp",

"RosterController.cpp",

"XMPPRosterController.cpp",

"MUCController.cpp",

"EventController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"XMLConsoleController.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("UnitTest/NickResolverTest.cpp"),

File("UnitTest/RosterControllerTest.cpp"),

File("UnitTest/XMPPRosterControllerTest.cpp")

])

#pragma once

namespace Swift {

class XMLConsoleWidget {

public:

virtual void show() = 0;

};

}