#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/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/XMPPRosterController.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;

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

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

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

}

MainController::~MainController() {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

delete controllerPair.second;

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

delete controllerPair.second;

}

delete systemTrayController_;

delete soundEventController_;

delete avatarStorage_;

resetClient();

}

void MainController::resetClient() {

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>();

xmppRoster_ = boost::shared_ptr<XMPPRoster>();

delete presenceOracle_;

presenceOracle_ = NULL;

delete nickResolver_;

nickResolver_ = NULL;

delete avatarManager_;

avatarManager_ = NULL;

delete rosterController_;

rosterController_ = NULL;

delete xmppRosterController_;

xmppRosterController_ = NULL;

delete clientVersionResponder_;

clientVersionResponder_ = NULL;

delete discoResponder_;

discoResponder_ = NULL;

delete presenceSender_;

presenceSender_ = NULL;

delete client_;

client_ = NULL;

}

void MainController::handleConnected() {

//FIXME: this freshLogin thing is temporary so I can see what's what before I split into a seperate method.

bool freshLogin = rosterController_ == NULL;

if (freshLogin) {

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

xmppRoster_ = boost::shared_ptr<XMPPRoster>(new XMPPRoster());

presenceOracle_ = new PresenceOracle(client_);

lastSentPresence_ = boost::shared_ptr<Presence>();

client_->onPresenceReceived.connect(boost::bind(&MainController::handleIncomingPresence, this, _1));

nickResolver_ = new NickResolver(xmppRoster_);

avatarManager_ = new AvatarManager(client_, client_, avatarStorage_, this);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, treeWidgetFactory_, nickResolver_);

rosterController_->onStartChatRequest.connect(boost::bind(&MainController::handleChatRequest, this, _1));

rosterController_->onJoinMUCRequest.connect(boost::bind(&MainController::handleJoinMUCRequest, this, _1, _2));

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

#include <boost/signals.hpp>

#include <boost/shared_ptr.hpp>

#include <vector>

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "SwifTools/Idle/PlatformIdleQuerier.h"

#include "SwifTools/Idle/ActualIdleDetector.h"

#include "Swiften/Base/String.h"

#include "Swiften/Client/ClientError.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/VCard.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/Message.h"

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/CapsInfo.h"

#include "Swiften/MUC/MUCRegistry.h"

#include "Swiften/Roster/XMPPRoster.h"

namespace Swift {

class AvatarStorage;

class Application;

class Client;

class ChatWindowFactory;

class ChatController;

class EventController;

class MainWindowFactory;

class MainWindow;

class NickResolver;

class RosterController;

class XMPPRosterController;

class PresenceSender;

class DiscoInfoResponder;

class AvatarManager;

class LoginWindow;

class EventLoop;

class SoftwareVersionResponder;

class LoginWindowFactory;

class TreeWidgetFactory;

class MUCController;

class PresenceOracle;

class SystemTray;

class SystemTrayController;

class SoundEventController;

class SoundPlayer;

class MainController : public MUCRegistry {

public:

~MainController();

private:

void resetClient();

void handleConnected();

void handleLoginRequest(const String& username, const String& password, const String& certificateFile, bool remember);

void handleCancelLoginRequest();

void handleChatRequest(const String& contact);

void handleJoinMUCRequest(const JID& muc, const String& nick);

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

void handleChatControllerJIDChanged(const JID& from, const JID& to);

void handleIncomingMessage(boost::shared_ptr<Message> message);

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

void handleError(const ClientError& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, const boost::optional<ErrorPayload>&);

void handleEventQueueLengthChange(int count);

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

ChatController* getChatController(const JID &contact);

void sendPresence(boost::shared_ptr<Presence> presence);

void handleInputIdleChanged(bool);

void logout();

void signOut();

virtual bool isMUC(const JID& muc) const;

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersEnabled(bool enabled);

BoostIOServiceThread boostIOServiceThread_;

BoostTimerFactory timerFactory_;

PlatformIdleQuerier idleQuerier_;

ActualIdleDetector idleDetector_;

Client* client_;

PresenceSender* presenceSender_;

ChatWindowFactory* chatWindowFactory_;

MainWindowFactory* mainWindowFactory_;

LoginWindowFactory* loginWindowFactory_;

TreeWidgetFactory* treeWidgetFactory_;

SettingsProvider *settings_;

Application* application_;

AvatarStorage* avatarStorage_;

ChatController* chatController_;

XMPPRosterController* xmppRosterController_;

RosterController* rosterController_;

EventController* eventController_;

LoginWindow* loginWindow_;

SoftwareVersionResponder* clientVersionResponder_;

NickResolver* nickResolver_;

DiscoInfoResponder* discoResponder_;

boost::shared_ptr<CapsInfo> capsInfo_;

std::map<JID, MUCController*> mucControllers_;

std::map<JID, ChatController*> chatControllers_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

boost::shared_ptr<XMPPRoster> xmppRoster_;;

JID jid_;

PresenceOracle* presenceOracle_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

AvatarManager* avatarManager_;

boost::shared_ptr<Presence> lastSentPresence_;

boost::shared_ptr<Presence> preIdlePresence_;

String vCardPhotoHash_;

boost::shared_ptr<Presence> queuedPresence_;

String password_;

String certificateFile_;

};

}

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",

])

env.Append(UNITTEST_SOURCES = [

File("UnitTest/NickResolverTest.cpp"),

File("UnitTest/RosterControllerTest.cpp"),

File("UnitTest/XMPPRosterControllerTest.cpp")

])

#ifndef SWIFTEN_LoginWindowFactory_H

#define SWIFTEN_LoginWindowFactory_H

namespace Swift {

class LoginWindow;

class LoginWindowFactory {

public:

virtual ~LoginWindowFactory() {};

/**

* Transfers ownership of result.

*/

};

}

#endif