#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

#include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>

#include <Swift/Controllers/HighlightManager.h>

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

#include <Swift/Controllers/Chat/ChatMessageParser.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, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {

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

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

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

chatWindow_->onLogCleared.connect(boost::bind(&ChatControllerBase::handleLogCleared, this));

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

highlighter_ = highlightManager->createHighlighter();

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

createDayChangeTimer();

}

ChatControllerBase::~ChatControllerBase() {

delete chatWindow_;

}

void ChatControllerBase::handleLogCleared() {

cancelReplaces();

}

ChatWindow* ChatControllerBase::detachChatWindow() {

ChatWindow* chatWindow = chatWindow_;

chatWindow_ = NULL;

return chatWindow;

}

void ChatControllerBase::handleCapsChanged(const JID& jid) {

if (jid.compare(toJID_, JID::WithoutResource) == 0) {

handleBareJIDCapsChanged(jid);

}

}

void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {

if (chatWindow_) {

chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

}

}

void ChatControllerBase::createDayChangeTimer() {

if (timerFactory_) {

boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

boost::posix_time::ptime midnight(now.date() + boost::gregorian::days(1));

int millisecondsUntilMidnight = boost::numeric_cast<int>((midnight - now).total_milliseconds());

dateChangeTimer_ = boost::shared_ptr<Timer>(timerFactory_->createTimer(millisecondsUntilMidnight));

dateChangeTimer_->onTick.connect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));

dateChangeTimer_->start();

}

}

jid_ = JID("testjid@swift.im/swift");

xmppRoster_ = new XMPPRosterImpl();

avatarManager_ = new NullAvatarManager();

mainWindowFactory_ = new MockMainWindowFactory();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, NULL, mucRegistry_);

channel_ = new DummyIQChannel();

router_ = new IQRouter(channel_);

stanzaChannel_ = new DummyStanzaChannel();

presenceOracle_ = new PresenceOracle(stanzaChannel_);

subscriptionManager_ = new SubscriptionManager(stanzaChannel_);

eventController_ = new EventController();

uiEventStream_ = new UIEventStream();

settings_ = new DummySettingsProvider();

nickManager_ = new DummyNickManager();

capsProvider_ = new DummyCapsProvider();

entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

jingleSessionManager_ = new JingleSessionManager(router_);

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

clientBlockListManager_ = new ClientBlockListManager(router_);

crypto_ = PlatformCryptoProvider::create();

vcardStorage_ = new VCardMemoryStorage(crypto_);

vcardManager_ = new VCardManager(jid_, router_, vcardStorage_);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, ftOverview_, clientBlockListManager_, vcardManager_);

mainWindow_ = mainWindowFactory_->last;

}

void tearDown() {

delete rosterController_;

delete vcardManager_;

delete vcardStorage_;

delete crypto_;

delete clientBlockListManager_;

delete ftManager_;

delete jingleSessionManager_;

delete nickManager_;

delete nickResolver_;

delete mucRegistry_;

delete mainWindowFactory_;

delete avatarManager_;

delete router_;

delete channel_;

delete eventController_;

delete subscriptionManager_;

delete presenceOracle_;

delete stanzaChannel_;

delete uiEventStream_;

delete settings_;

delete xmppRoster_;

}

GroupRosterItem* groupChild(size_t i) {

return dynamic_cast<GroupRosterItem*>(CHILDREN[i]);

}

JID withResource(const JID& jid, const std::string& resource) {

return JID(jid.toBare().toString() + "/" + resource);

}

void testPresence() {

std::vector<std::string> groups;

groups.push_back("testGroup1");

groups.push_back("testGroup2");

JID from("test@testdomain.com");

xmppRoster_->addContact(from, "name", groups, RosterItemPayload::Both);

Presence::ref presence(new Presence());

presence->setFrom(withResource(from, "bob"));

presence->setPriority(2);

presence->setStatus("So totally here");

stanzaChannel_->onPresenceReceived(presence);

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swift/Controllers/PreviousStatusStore.h"

using namespace Swift;

class PreviousStatusStoreTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(PreviousStatusStoreTest);

CPPUNIT_TEST(testGetAll);

//CPPUNIT_TEST(testGetAllLimited);

//CPPUNIT_TEST(testGetSuggestionsInexact);

//CPPUNIT_TEST(testGetSuggestionsExact);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

store_ = new PreviousStatusStore();

store_->addStatus(StatusShow::Online, "At home in the study");

store_->addStatus(StatusShow::DND, "In a meeting");

store_->addStatus(StatusShow::DND, "With a client");

store_->addStatus(StatusShow::Away, "Walking the elephant");

store_->addStatus(StatusShow::Online, "In the office, at my desk");

}

void tearDown() {

}

void testGetAll() {

}

private:

PreviousStatusStore* store_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(PreviousStatusStoreTest);