#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

message_ = new QLabel(this);

message_->setTextFormat(Qt::RichText);

message_->setWordWrap(true);

layout->addWidget(message_);

layout->addStretch();

remember_ = new QCheckBox(tr("Remember Password?"), this);

layout->addWidget(remember_);

connect(loginButton_, SIGNAL(clicked()), SLOT(loginClicked()));

stack_->addWidget(wrapperWidget);

#ifdef SWIFTEN_PLATFORM_MACOSX

menuBar_ = new QMenuBar(NULL);

#else

menuBar_ = menuBar();

#endif

QApplication::setQuitOnLastWindowClosed(false);

swiftMenu_ = new QMenu(tr("Swift"), this);

QAction* aboutAction = new QAction("About Swift", this);

connect(aboutAction, SIGNAL(activated()), SLOT(handleAbout()));

swiftMenu_->addAction(aboutAction);

toolsMenu_ = new QMenu(tr("Tools"), this);

QAction* xmlConsoleAction = new QAction(tr("Show Debug Console"), this);

connect(xmlConsoleAction, SIGNAL(activated()), SLOT(handleShowXMLConsole()));

toolsMenu_->addAction(xmlConsoleAction);

QAction* quitAction = new QAction("Quit", this);

connect(quitAction, SIGNAL(activated()), SLOT(handleQuit()));

swiftMenu_->addAction(quitAction);

setInitialMenus();

this->show();

}

/**

* Move and resize the window, but respect minimum sizes.

* (Like QWidget::setGeometry, only that will truncate the window

* the setGeometry docs say that it shouldn't do this, but I've just seen it

* maybe we can remove this method if that's a Qt bug (or I'm misusing it)).

*/

void QtLoginWindow::setGentleGeometry(const QRect& rect) {

resize(rect.size());

move(rect.topLeft());

}

QRect QtLoginWindow::defaultPosition() {

QDesktopWidget desktop;

int windowWidth = 200;

int windowHeight = 500;

QRect screen = desktop.screenGeometry(-1); //appear on default screen

windowWidth = std::min(windowWidth, screen.width());

windowHeight = std::min(windowHeight, screen.height());

int left = (screen.width() - windowWidth) / 2;

int height = (screen.height() - windowHeight) / 2;

return QRect(left, height, windowWidth, windowHeight);

}

void QtLoginWindow::addAvailableAccount(const String& defaultJID, const String& defaultPassword, const String& defaultCertificate) {

QString username = P2QSTRING(defaultJID);

int index = -1;

for (int i = 0; i < usernames_.count(); i++) {

if (username == usernames_[i]) {

index = i;

}

}

if (index == -1) {

usernames_.append(username);

passwords_.append(P2QSTRING(defaultPassword));

certificateFiles_.append(P2QSTRING(defaultCertificate));

username_->addItem(username);

} else {

usernames_[index] = username;

passwords_[index] = P2QSTRING(defaultPassword);

certificateFiles_[index] = P2QSTRING(defaultCertificate);

}

}

void QtLoginWindow::handleUsernameTextChanged() {

QString username = username_->currentText();

for (int i = 0; i < usernames_.count(); i++) {

if (username_->currentText() == usernames_[i]) {

certificateFile_ == certificateFiles_[i];

password_->setText(passwords_[i]);

}

}

if (!certificateFile_.isEmpty()) {

certificateButton_->setChecked(true);

}

remember_->setChecked(password_->text() != "");

}

void QtLoginWindow::loggedOut() {

if (stack_->count() > 1) {

#ifndef SWIFT_QtLoginWindow_H

#define SWIFT_QtLoginWindow_H

#include <QMainWindow>

#include <QPointer>

#include <QLineEdit>

#include <QPushButton>

#include <QCheckBox>

#include <QStackedWidget>

#include <QMenuBar>

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

#include "Swift/Controllers/MainWindow.h"

#include "QtAboutWidget.h"

class QLabel;

class QToolButton;

class QComboBox;

namespace Swift {

class UIEventStream;

class QtLoginWindow : public QMainWindow, public LoginWindow {

Q_OBJECT

public:

QtLoginWindow(UIEventStream* uiEventStream);

void morphInto(MainWindow *mainWindow);

virtual void loggedOut();

virtual void setMessage(const String& message);

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

static QRect defaultPosition();

void setGentleGeometry(const QRect&);

signals:

void geometryChanged();

private slots:

void loginClicked();

void handleCertficateChecked(bool);

void handleQuit();

void handleShowXMLConsole();

void handleAbout();

void bringToFront();

void handleUsernameTextChanged();

void resizeEvent(QResizeEvent* event);

void moveEvent(QMoveEvent* event);

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

QComboBox* username_;

QLineEdit* password_;

QPushButton* loginButton_;

QCheckBox* remember_;

QStackedWidget* stack_;

QLabel* message_;

QString certificateFile_;

QToolButton* certificateButton_;

QMenuBar* menuBar_;

QMenu* swiftMenu_;

QMenu* toolsMenu_;

UIEventStream* uiEventStream_;

QPointer<QtAboutWidget> aboutDialog_;

};

}

#endif