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

xmppRosterController_ = new XMPPRosterController(client_, xmppRoster_);

xmppRosterController_->requestRoster();

clientVersionResponder_ = new SoftwareVersionResponder(CLIENT_NAME, CLIENT_VERSION, client_);

loginWindow_->morphInto(rosterController_->getWindow());

DiscoInfo discoInfo;

discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

discoInfo.addFeature("urn:xmpp:sec-label:0");

capsInfo_ = boost::shared_ptr<CapsInfo>(new CapsInfo(CapsInfoGenerator(CLIENT_NODE).generateCapsInfo(discoInfo)));

discoResponder_ = new DiscoInfoResponder(client_);

discoResponder_->setDiscoInfo(discoInfo);

discoResponder_->setDiscoInfo(capsInfo_->getNode() + "#" + capsInfo_->getVersion(), discoInfo);

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

}

boost::shared_ptr<GetDiscoInfoRequest> discoInfoRequest(new GetDiscoInfoRequest(JID(), client_));

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

boost::shared_ptr<GetVCardRequest> vCardRequest(new GetVCardRequest(JID(), client_));

vCardRequest->onResponse.connect(boost::bind(&MainController::handleOwnVCardReceived, this, _1, _2));

vCardRequest->send();

idleDetector_->onInputIdle.connect(boost::bind(&MainController::handleInputIdle, this));

idleDetector_->onInputNotIdle.connect(boost::bind(&MainController::handleInputNotIdle, this));

//Send presence last to catch all the incoming presences.

boost::shared_ptr<Presence> initialPresence;

if (queuedPresence_.get() != NULL) {

initialPresence = queuedPresence_;

} else {

initialPresence = boost::shared_ptr<Presence>(new Presence());

}

initialPresence->addPayload(capsInfo_);

setManagersEnabled(true);

sendPresence(initialPresence);

}

void MainController::handleEventQueueLengthChange(int count) {

application_->getApplicationMessageDisplay()->setMessage(count == 0 ? "" : boost::lexical_cast<std::string>(count).c_str());

}

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

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

if (show == StatusShow::None) {

// FIXME: This is wrong. None doesn't mean unavailable

presence->setType(Presence::Unavailable);

}

else {

presence->setShow(show);

}

presence->setStatus(statusText);

if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

performLoginFromCachedCredentials();

queuedPresence_ = presence;

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

client_->sendPresence(presence);

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

logout();

}

}

void MainController::handleInputIdle() {

preIdlePresence_ = lastSentPresence_;

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

presence->setShow(StatusShow::Away);

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

sendPresence(presence);

}

void MainController::handleInputNotIdle() {

if (client_) {

sendPresence(preIdlePresence_);

} else {

queuedPresence_ = preIdlePresence_;

}

}

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

//FIXME: subscribe, subscribed

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

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

}

logout();

}

void MainController::handleCancelLoginRequest() {

signOut();

}

void MainController::signOut() {

logout();

idleDetector_->onInputIdle.connect(boost::bind(&MainController::handleInputIdle, this));

idleDetector_->onInputNotIdle.connect(boost::bind(&MainController::handleInputNotIdle, this));

loginWindow_->loggedOut();

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

delete controllerPair.second;

}

chatControllers_.clear();

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

delete controllerPair.second;

}

mucControllers_.clear();

delete rosterController_;

rosterController_ = NULL;

resetClient();

}

void MainController::logout() {

if (client_ && client_->isAvailable()) {

client_->disconnect();

}

if (rosterController_) {

rosterController_->getWindow()->setMyStatusType(StatusShow::None);

rosterController_->getWindow()->setMyStatusText("");

}

setManagersEnabled(false);

}

void MainController::setManagersEnabled(bool enabled) {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

//printf("Setting enabled on %d to %d\n", controllerPair.second, enabled);

controllerPair.second->setEnabled(enabled);

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

controllerPair.second->setEnabled(enabled);

}

if (rosterController_) {

rosterController_->setEnabled(enabled);

}

}

class RosterController;

class XMPPRosterController;

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(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory* treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, IdleDetector* idleDetector);

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

void handleInputNotIdle();

void logout();

void signOut();

virtual bool isMUC(const JID& muc) const;

void performLoginFromCachedCredentials();

void setManagersEnabled(bool enabled);

Client* client_;

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

IdleDetector* idleDetector_;

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

};

}

#endif