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

}

MainController::~MainController() {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

delete controllerPair.second;

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

delete controllerPair.second;

}

delete systemTrayController_;

delete soundEventController_;

delete avatarStorage_;

delete xmlConsoleController_;

delete uiEventStream_;

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;

}

} else {

sendPresence(presence);

}

}

void MainController::sendPresence(boost::shared_ptr<Presence> presence) {

if (!vCardPhotoHash_.isEmpty()) {

presence->addPayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(vCardPhotoHash_)));

}

presence->addPayload(capsInfo_);

lastSentPresence_ = presence;

presenceSender_->sendPresence(presence);

if (presence->getType() == Presence::Unavailable) {

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!client_ || !client_->isAvailable()) {

return;

}

if (idle) {

preIdlePresence_ = lastSentPresence_;

boost::shared_ptr<Presence> presence(new Presence());

presence->setShow(StatusShow::Away);

presence->setStatus("Auto-away");

sendPresence(presence);

}

else {

if (client_) {

sendPresence(preIdlePresence_);

} else {

queuedPresence_ = preIdlePresence_;

}

}

}

void MainController::handleIncomingPresence(boost::shared_ptr<Presence> presence) {

//FIXME: subscribe, subscribed

rosterController_->handleIncomingPresence(presence);

}

void MainController::handleLoginRequest(const String &username, const String &password, const String& certificateFile, bool remember) {

loginWindow_->setMessage("");

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(username, settings_);

profileSettings->storeString("jid", username);

profileSettings->storeString("certificate", certificateFile);

profileSettings->storeString("pass", remember ? password : "");

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

delete profileSettings;

jid_ = JID(username);

password_ = password;

certificateFile_ = certificateFile;

performLoginFromCachedCredentials();

}

void MainController::performLoginFromCachedCredentials() {

if (!client_) {

client_ = new Swift::Client(jid_, password_);

presenceSender_ = new PresenceSender(client_);

client_->onDataRead.connect(&printIncomingData);

client_->onDataWritten.connect(&printOutgoingData);

if (!certificateFile_.isEmpty()) {

client_->setCertificate(certificateFile_);

}

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

client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));

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

}

client_->connect();

}

void MainController::handleError(const ClientError& error) {

String message;

switch(error.getType()) {

case ClientError::UnknownError: message = "Unknown Error"; break;

case ClientError::DomainNameResolveError: message = "Unable to find server"; break;

case ClientError::ConnectionError: message = "Error connecting to server"; break;

case ClientError::ConnectionReadError: message = "Error while receiving server data"; break;

case ClientError::ConnectionWriteError: message = "Error while sending data to the server"; break;

case ClientError::XMLError: message = "Error parsing server data"; break;

case ClientError::AuthenticationFailedError: message = "Login/password invalid"; break;

case ClientError::CompressionFailedError: message = "Error while compressing stream"; break;

case ClientError::ServerVerificationFailedError: message = "Server verification failed"; break;

case ClientError::NoSupportedAuthMechanismsError: message = "Authentication mechanisms not supported"; break;

case ClientError::UnexpectedElementError: message = "Unexpected response"; break;

case ClientError::ResourceBindError: message = "Error binding resource"; break;

case ClientError::SessionStartError: message = "Error starting session"; break;

case ClientError::TLSError: message = "Encryption error"; break;

case ClientError::ClientCertificateLoadError: message = "Error loading certificate (Invalid password?)"; break;

case ClientError::ClientCertificateError: message = "Certificate not authorized"; break;

}

if (!rosterController_) { //hasn't been logged in yet

signOut();

loginWindow_->setMessage(message);

}

#ifndef SWIFTEN_LoginWindow_H

#define SWIFTEN_LoginWindow_H

#include "Swiften/Base/String.h"

#include <boost/signals.hpp>

#include <boost/shared_ptr.hpp>

namespace Swift {

class MainWindow;

class LoginWindow {

public:

virtual ~LoginWindow() {};

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

virtual void setMessage(const String&) = 0;

virtual void addAvailableAccount(const String& defaultJID, const String& defaultPassword, const String& defaultCertificate) = 0;

boost::signal<void (const String&, const String&, const String& /* certificateFile */, bool)> onLoginRequest;

boost::signal<void ()> onCancelLoginRequest;

};

}

#endif