/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <map>

#include <set>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <hippomocks.h>

#include <Swiften/Avatars/AvatarMemoryStorage.h>

#include <Swiften/Avatars/NullAvatarManager.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/DummyEntityCapsProvider.h>

#include <Swiften/Elements/CarbonsReceived.h>

#include <Swiften/Elements/CarbonsSent.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/Elements/Forwarded.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

public:

void setUp() {

mocks_ = new MockRepository();

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

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

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

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

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

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

serverDiscoInfo_ = std::make_shared<DiscoInfo>();

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

entityCapsProvider_ = new DummyEntityCapsProvider();

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

chatListWindow_ = new MockChatListWindow();

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

avatarManager_ = new NullAvatarManager();

wbSessionManager_ = new WhiteboardSessionManager(iqRouter_, stanzaChannel_, presenceOracle_, entityCapsProvider_);

wbManager_ = new WhiteboardManager(whiteboardWindowFactory_, uiEventStream_, nickResolver_, wbSessionManager_);

highlightManager_ = new HighlightManager(settings_);

handledHighlightActions_ = 0;

soundsPlayed_.clear();

highlightManager_->onHighlight.connect(boost::bind(&ChatsManagerTest::handleHighlightAction, this, _1));

crypto_ = PlatformCryptoProvider::create();

vcardStorage_ = new VCardMemoryStorage(crypto_);

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

mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);

clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, nullptr, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_);

manager_->setAvatarManager(avatarManager_);

}

void tearDown() {

delete highlightManager_;

delete profileSettings_;

delete avatarManager_;

delete manager_;

delete clientBlockListManager_;

delete vcardManager_;

delete vcardStorage_;

delete crypto_;

delete ftOverview_;

delete ftManager_;

delete wbSessionManager_;

delete wbManager_;

delete directedPresenceSender_;

delete presenceSender_;

delete presenceOracle_;

stanzaChannel_->onIQReceived(infoResponse);

CPPUNIT_ASSERT_EQUAL(true, window->impromptuMUCSupported_);

manager_->setOnline(false);

CPPUNIT_ASSERT_EQUAL(false, window->impromptuMUCSupported_);

}

void testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::Subscription from, RosterItemPayload::Subscription to) {

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

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), from);

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

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

settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

std::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(st(0), stanzaChannel_->countSentStanzaOfType<Message>());

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);

message->setID("2");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->countSentStanzaOfType<Message>());

Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(1);

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);

}

void testChatControllerHighlightingNotificationTesting() {

JID messageJID = JID("testling@test.com");

MockChatWindow* window = new MockChatWindow();

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

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

message->setFrom(messageJID);

std::string body("This message should cause two sounds: Juliet and Romeo.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(2, handledHighlightActions_);

}

void testChatControllerHighlightingNotificationDeduplicateSounds() {

JID messageJID = JID("testling@test.com");

MockChatWindow* window = new MockChatWindow();

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

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

message->setFrom(messageJID);

std::string body("This message should cause one sound, because both actions have the same sound: Juliet and Romeo.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(1, handledHighlightActions_);

}

void testChatControllerMeMessageHandling() {

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

MockChatWindow* window = new MockChatWindow();

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

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

message->setFrom(messageJID);

std::string body("/me is feeling delighted.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(std::string("is feeling delighted."), window->bodyFromMessage(window->lastAddedAction_));

}

void testRestartingMUCComponentCrash() {

JID mucJID = JID("teaparty@rooms.wonderland.lit");

JID self = JID("girl@wonderland.lit/rabbithole");

std::string nick = "aLiCe";

MockChatWindow* window;

auto genRemoteMUCPresence = [=]() {

auto presence = Presence::create();

presence->setFrom(mucJID.withResource(nick));

presence->setTo(self);

return presence;

};

}

{

auto firstPresence = genRemoteMUCPresence();

firstPresence->setType(Presence::Unavailable);

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addItem(MUCItem(MUCOccupant::Owner, MUCOccupant::NoRole));

firstPresence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(firstPresence);

}

CPPUNIT_ASSERT_EQUAL(std::string("Couldn't enter room: Unable to enter this room."), MockChatWindow::bodyFromMessage(window->lastAddedErrorMessage_));

{

auto presence = genRemoteMUCPresence();

presence->setType(Presence::Unavailable);

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addStatusCode(303);

auto item = MUCItem(MUCOccupant::Owner, self, MUCOccupant::Moderator);

item.nick = nick;

userPayload->addItem(item);

userPayload->addStatusCode(110);

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

}

void testChatControllerMeMessageHandlingInMUC() {

JID mucJID("mucroom@rooms.test.com");

std::string nickname = "toodles";

// add highlight rule for 'foo'

MockChatWindow* window = new MockChatWindow();

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

uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucJID, boost::optional<std::string>(), nickname));

auto genRemoteMUCPresence = [=]() {

auto presence = Presence::create();

presence->setFrom(mucJID.withResource(nickname));

presence->setTo(jid_);

return presence;

};

{

auto presence = genRemoteMUCPresence();

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addStatusCode(110);

userPayload->addItem(MUCItem(MUCOccupant::Owner, jid_, MUCOccupant::Moderator));

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

{

auto presence = genRemoteMUCPresence();

presence->setFrom(mucJID.withResource("someDifferentNickname"));

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addItem(MUCItem(MUCOccupant::Member, JID("foo@bar.com"), MUCOccupant::Moderator));

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

originalMessage->setFrom(messageJID);

originalMessage->setTo(jid2);

originalMessage->setType(Message::Chat);

originalMessage->addPayload(std::make_shared<DeliveryReceipt>("abcdefg123456"));

auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsReceived>(), originalMessage);

manager_->handleIncomingMessage(messageWrapper);

CPPUNIT_ASSERT_EQUAL(size_t(2), window->receiptChanges_.size());

CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptReceived, window->receiptChanges_[1].second);

}

}

private:

std::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

std::shared_ptr<Message> message = std::make_shared<Message>();

message->setFrom(from);

message->setID(id);

message->setBody("This will cause the window to open");

message->addPayload(std::make_shared<DeliveryReceiptRequest>());

return message;

}

size_t st(int i) {

return static_cast<size_t>(i);

}

void handleHighlightAction(const HighlightAction& action) {

handledHighlightActions_++;

}

}

private:

JID jid_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

JoinMUCWindowFactory* joinMUCWindowFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

std::shared_ptr<DiscoInfo> serverDiscoInfo_;

XMPPRosterImpl* xmppRoster_;

PresenceSender* presenceSender_;

MockRepository* mocks_;

UIEventStream* uiEventStream_;

ChatListWindowFactory* chatListWindowFactory_;

WhiteboardWindowFactory* whiteboardWindowFactory_;

MUCSearchWindowFactory* mucSearchWindowFactory_;

MUCRegistry* mucRegistry_;

DirectedPresenceSender* directedPresenceSender_;

DummyEntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

ProfileSettingsProvider* profileSettings_;

ChatListWindow* chatListWindow_;

FileTransferOverview* ftOverview_;