#include "Swift/Controllers/ChatsManager.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/EventController.h"

#include "Swift/Controllers/MUCController.h"

#include "Swiften/Presence/PresenceSender.h"

namespace Swift {

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

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

ChatsManager::ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, TreeWidgetFactory* treeWidgetFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, boost::shared_ptr<DiscoInfo> serverDiscoInfo, PresenceSender* presenceSender) : jid_(jid) {

eventController_ = eventController;

stanzaChannel_ = stanzaChannel;

iqRouter_ = iqRouter;

chatWindowFactory_ = chatWindowFactory;

treeWidgetFactory_ = treeWidgetFactory;

nickResolver_ = nickResolver;

presenceOracle_ = presenceOracle;

avatarManager_ = NULL;

serverDiscoInfo_ = serverDiscoInfo;

presenceSender_ = presenceSender;

}

ChatsManager::~ChatsManager() {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

delete controllerPair.second;

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

delete controllerPair.second;

}

}

void ChatsManager::setAvatarManager(AvatarManager* avatarManager) {

avatarManager_ = avatarManager;

}

// void ChatsManager::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

// {

// boost::shared_ptr<RequestChatUIEvent> event = boost::dynamic_pointer_cast<RequestChatUIEvent>(rawEvent);

// if (event != NULL) {

// handleChatRequest(event->getContact());

// return;

// }

// }

// {

// boost::shared_ptr<JoinMUCUIEvent> event = boost::dynamic_pointer_cast<JoinMUCUIEvent>(rawEvent);

// if (event != NULL) {

// handleJoinMUCRequest(event->getRoom(), event->getNick());

// }

// }

// }

void ChatsManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {

foreach (JIDChatControllerPair pair, chatControllers_) {

pair.second->setAvailableServerFeatures(info);

}

foreach (JIDMUCControllerPair pair, mucControllers_) {

pair.second->setAvailableServerFeatures(info);

}

}

void ChatsManager::setEnabled(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);

}

}

void ChatsManager::handleChatRequest(const String &contact) {

ChatController* controller = getChatController(JID(contact));

controller->showChatWindow();

controller->activateChatWindow();

}

ChatController* ChatsManager::getChatController(const JID &contact) {

}

}

chatControllers_[to] = chatControllers_[from];

chatControllers_.erase(from);

}

void ChatsManager::handleJoinMUCRequest(const JID &muc, const String &nick) {

mucControllers_[muc] = new MUCController(jid_, muc, nick, stanzaChannel_, presenceSender_, iqRouter_, chatWindowFactory_, treeWidgetFactory_, presenceOracle_, avatarManager_);

mucControllers_[muc]->setAvailableServerFeatures(serverDiscoInfo_);

}

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

JID jid = message->getFrom();

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

if (!event->isReadable()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error) {

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;

}

}

//if not a mucroom

eventController_->handleIncomingEvent(event);

getChatController(jid)->handleIncomingMessage(event);

}

bool ChatsManager::isMUC(const JID& jid) const {

return mucControllers_.find(jid.toBare()) != mucControllers_.end();

}

}

#pragma once

#include <map>

#include <boost/shared_ptr.hpp>

#include "Swiften/Base/String.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/Message.h"

#include "Swiften/JID/JID.h"

#include "Swiften/MUC/MUCRegistry.h"

namespace Swift {

class EventController;

class ChatController;

class MUCController;

class ChatWindowFactory;

class TreeWidgetFactory;

class NickResolver;

class PresenceOracle;

class AvatarManager;

class StanzaChannel;

class IQRouter;

class PresenceSender;

class ChatsManager : public MUCRegistry {

public:

ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, TreeWidgetFactory* treeWidgetFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, boost::shared_ptr<DiscoInfo> serverDiscoInfo, PresenceSender* presenceSender);

~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setEnabled(bool enabled);

void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

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

void handleChatRequest(const String& contact);

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

private:

ChatController* getChatController(const JID &contact);

virtual bool isMUC(const JID& muc) const;

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

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

EventController* eventController_;

JID jid_;

StanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;;

ChatWindowFactory* chatWindowFactory_;

TreeWidgetFactory* treeWidgetFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

PresenceSender* presenceSender_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

};

}

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "3rdParty/hippomocks.h"

#include "Swift/Controllers/ChatsManager.h"

#include "Swift/Controllers/ChatWindow.h"

#include "Swift/Controllers/ChatWindowFactory.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/EventController.h"

#include "Swift/Controllers/MUCController.h"

#include "Swiften/Presence/PresenceSender.h"

#include "Swiften/Avatars/UnitTest/MockAvatarManager.h"

#include "Swift/Controllers/NickResolver.h"

#include "Swiften/Roster/XMPPRoster.h"

#include "Swift/Controllers/UnitTest/MockChatWindow.h"

#include "Swiften/Client/DummyStanzaChannel.h"

#include "Swiften/Queries/DummyIQChannel.h"

#include "Swiften/Presence/PresenceOracle.h"

using namespace Swift;

class ChatsManagerTest : public CppUnit::TestFixture

{

CPPUNIT_TEST_SUITE(ChatsManagerTest);

CPPUNIT_TEST(testFirstOpenWindowIncoming);

CPPUNIT_TEST(testFirstOpenWindowOutgoing);

CPPUNIT_TEST(testFirstOpenWindowBareToFull);

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST_SUITE_END();

public:

ChatsManagerTest() {};

void setUp() {

mocks_ = new MockRepository();

jid_ = JID("test@test.com/resource");

stanzaChannel_ = new DummyStanzaChannel();

iqChannel_ = new DummyIQChannel();

iqRouter_ = new IQRouter(iqChannel_);

eventController_ = new EventController();

chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

treeWidgetFactory_ = NULL;

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

nickResolver_ = new NickResolver(xmppRoster_);

presenceOracle_ = new PresenceOracle(stanzaChannel_);

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

presenceSender_ = NULL;

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, treeWidgetFactory_, nickResolver_, presenceOracle_, serverDiscoInfo_, presenceSender_);

avatarManager_ = new MockAvatarManager();

manager_->setAvatarManager(avatarManager_);

};

void tearDown() {

delete manager_;

delete presenceSender_;

delete avatarManager_;

delete presenceOracle_;

delete nickResolver_;

delete treeWidgetFactory_;

delete stanzaChannel_;

delete iqChannel_;

delete iqRouter_;

delete mocks_;

}

void testFirstOpenWindowIncoming() {

JID messageJID("testling@test.com/resource1");

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID).Return(window);

boost::shared_ptr<Message> message(new Message());

message->setFrom(messageJID);

manager_->handleIncomingMessage(message);

}

void testFirstOpenWindowOutgoing() {

String messageJIDString("testling@test.com");

ChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString)).Return(window);

manager_->handleChatRequest(messageJIDString);

}

void testFirstOpenWindowBareToFull() {

String bareJIDString("testling@test.com");

String fullJIDString("testling@test.com/resource1");

MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(bareJIDString)).Return(window);

manager_->handleChatRequest(bareJIDString);

boost::shared_ptr<Message> message(new Message());

message->setFrom(JID(fullJIDString));

manager_->handleIncomingMessage(message);

}

void testSecondWindow() {

String messageJIDString1("testling1@test.com");

ChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString1)).Return(window1);

manager_->handleChatRequest(messageJIDString1);

String messageJIDString2("testling2@test.com");

ChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString2)).Return(window2);

manager_->handleChatRequest(messageJIDString2);

}

private:

JID jid_;

ChatsManager* manager_;

StanzaChannel* stanzaChannel_;

IQChannel* iqChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

TreeWidgetFactory* treeWidgetFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

boost::shared_ptr<XMPPRoster> xmppRoster_;

PresenceSender* presenceSender_;

MockRepository* mocks_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ChatsManagerTest);

#pragma once

#include "Swift/Controllers/ChatWindow.h"

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

MockChatWindow() {};

virtual ~MockChatWindow();

virtual void addSystemMessage(const String& /*message*/) {};

virtual void addErrorMessage(const String& /*message*/) {};

virtual void setName(const String& name) {name_ = name;};

virtual void show() {};

virtual void activate() {};

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabel>& labels) {labels_ = labels;};

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;};

virtual void setUnreadMessageCount(int /*count*/) {};

virtual void convertToMUC() {};

virtual TreeWidget *getTreeWidget() {return NULL;};

virtual void setSecurityLabelsError() {};

virtual SecurityLabel getSelectedSecurityLabel() {return SecurityLabel();};

virtual void setInputEnabled(bool /*enabled*/) {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const String&)> onSendMessageRequest;

String name_;

std::vector<SecurityLabel> labels_;

bool labelsEnabled_;

};

}