#include <map>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/algorithm/string.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

namespace Swift {

ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider) {

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

if (messageEvent->isReadable() && !messageEvent->getConcluded()) {

unreadMessages_.push_back(messageEvent);

}

boost::shared_ptr<Message> message = messageEvent->getStanza();

std::string body = message->getBody();

if (message->isError()) {

std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

chatWindow_->addErrorMessage(errorMessage);

}

else {

if (!messageEvent->isReadable()) {

return;

}

showChatWindow();

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

if (!delayPayloads[i]->getFrom()) {

case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable"); break;

case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required"); break;

case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition"); break;

case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request"); break;

}

}

return defaultMessage;

}

}

private:

IDGenerator idGenerator_;

std::string lastSentMessageStanzaID_;

void createDayChangeTimer();

void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

void handleDayChangeTick();

protected:

JID selfJID_;

std::vector<boost::shared_ptr<MessageEvent> > unreadMessages_;

StanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

ChatWindowFactory* chatWindowFactory_;

ChatWindow* chatWindow_;

JID toJID_;

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swift/Controllers/FileTransfer/FileTransferController.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

#include <Swiften/Avatars/AvatarManager.h>

namespace Swift {

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

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

#define RECENT_CHATS "recent_chats"

ChatsManager::ChatsManager(

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

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

JID jid = message->getFrom();

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

return;

}

// Try to deliver it to a MUC

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;

}

void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {

if (chat.isMUC) {

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, chat.nick));

}

else {

uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));

}

}

}

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

chatWindow_->setName(muc->getJID().getNode());

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

if (timerFactory) {

void MUCController::handleConfigurationFormReceived(Form::ref form) {

chatWindow_->showRoomConfigurationForm(form);

}

void MUCController::handleDestroyRoomRequest() {

muc_->destroyRoom();

}

}

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {lastWasPresence_ = false;}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;