void setRoom(const std::string &room);

		/// Returns room name associated with this Conversation.

		/// \return room name associated with this Conversation.

		const std::string &getRoom() {

			return m_room;

		}

		void destroyRoom();

		std::string getParticipants();

		void sendCachedMessages(const Swift::JID &to = Swift::JID());

		void setMUCEscaping(bool mucEscaping);

	private:

		Swift::Presence::ref generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname = "", const std::string &iconhash = "");

		void cacheMessage(boost::shared_ptr<Swift::Message> &message);

	private:

		ConversationManager *m_conversationManager;

		std::string m_legacyName;

		std::string m_nickname;

		std::string m_room;

		bool m_muc;

		Swift::JID m_jid;

		std::list<Swift::JID> m_jids;

		bool m_sentInitialPresence;

		bool m_nicknameChanged;

		bool m_mucEscaping;

		// TODO: Move this to some extra class to cache the most used

		// rooms across different accounts. Just now if we have 10 users

		// connected to single room, we store all those things 10 times.

		// It would be also great to store last 100 messages per room

		// every time, so we can get history messages for IRC for example.

		boost::shared_ptr<Swift::Message> m_subject;

		std::list<boost::shared_ptr<Swift::Message> > m_cachedMessages;

		typedef struct {

			Swift::Presence::ref presence;

			std::string alias;

namespace Transport {

DEFINE_LOGGER(logger, "Conversation");

Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {

	m_legacyName = legacyName;

	m_muc = isMUC;

	m_jid = m_conversationManager->getUser()->getJID().toBare();

	m_sentInitialPresence = false;

	m_nicknameChanged = false;

	m_mucEscaping = false;

	if (CONFIG_BOOL_DEFAULTED(conversationManager->getComponent()->getConfig(), "features.rawxml", false)) {

		m_sentInitialPresence = true;

	}

}

Conversation::~Conversation() {

}

void Conversation::setMUCEscaping(bool mucEscaping) {

	LOG4CXX_INFO(logger, m_jid.toString() << ": Setting MUC escaping to " << mucEscaping);

	m_mucEscaping = mucEscaping;

		else {

			m_conversationManager->getComponent()->getFrontend()->sendMessage(message);

		}

	}

	else {

		if (m_jids.empty()) {

			cacheMessage(message);

		}

		else {

			BOOST_FOREACH(const Swift::JID &jid, m_jids) {

				message->setTo(jid);

				// Subject has to be sent after our own presence (the one with code 110)

					m_subject = message;

				}

				m_conversationManager->getComponent()->getFrontend()->sendMessage(message);

			}

		}

	}

}

void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {

	if (m_muc) {

		message->setType(Swift::Message::Groupchat);

	}

	else {

	handleRawMessage(message);

}

std::string Conversation::getParticipants() {

	std::string ret;

	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {

		ret += (*it).second.presence->getFrom().getResource() + ", ";

	}

	return ret;

}

	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {

		(*it).second.presence->setTo(to);

		m_conversationManager->getComponent()->getFrontend()->sendPresence((*it).second.presence);

	}

}

void Conversation::sendCachedMessages(const Swift::JID &to) {

	for (std::list<boost::shared_ptr<Swift::Message> >::const_iterator it = m_cachedMessages.begin(); it != m_cachedMessages.end(); it++) {

		if (to.isValid()) {

			(*it)->setTo(to);

		}

		else {

		m_participants[nick].alias = alias;

	}

	BOOST_FOREACH(const Swift::JID &jid, m_jids) {

		presence->setTo(jid);

		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);

	}

	if (!newname.empty()) {

		handleParticipantChanged(newname, flag, status, statusMessage, "", iconhash);

	}

		m_conversationManager->getComponent()->getFrontend()->sendMessage(m_subject);

	}

	// We send error presences only to inform user that he is disconnected

	// from the room. This code must be extended in case we start sending error

	// presences in other situations.

	if (presence->getType() == Swift::Presence::Error) {

		m_conversationManager->getUser()->leaveRoom(m_legacyName);

	}

}

}

			std::string password = "";

			if (presence->getPayload<Swift::MUCPayload>() != NULL) {

				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";

			}

			Conversation *conv = m_conversationManager->getConversation(room);

			if (conv != NULL) {

				if (std::find(conv->getJIDs().begin(), conv->getJIDs().end(), presence->getFrom()) != conv->getJIDs().end()) {

					LOG4CXX_INFO(logger, m_jid.toString() << ": User has already tried to join room " << room << " as " << presence->getTo().getResource());

				}

				else {

					conv->addJID(presence->getFrom());

					conv->sendCachedMessages(presence->getFrom());

				}

				if (forceJoin) {

					onRawPresenceReceived(presence);

					onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);

				}

				return;

			}

			bool isInJoined = false;

			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {

		msg->setType(Swift::Message::Groupchat);

		conv->handleMessage(msg);

		loop->processEvents();

		// No response, because presence with code 110 has not been sent yet and we must not send

		// subject before this one.

		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());

		// this user presence - status code 110

		conv->handleParticipantChanged("nickname", Conversation::PARTICIPANT_FLAG_MODERATOR, Swift::StatusShow::Away, "my status message");

		loop->processEvents();

		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());

		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));

		CPPUNIT_ASSERT_EQUAL(std::string("subject"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getSubject());

		received.clear();

		// send response

		msg->setFrom("user@localhost/resource");

		msg->setTo("#room@localhost");

		injectMessage(msg);

		loop->processEvents();

		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());

		loop->processEvents();

		Swift::Presence::ref response = Swift::Presence::create();

		response->setTo("#room@localhost/hanzz");

		response->setFrom("user@localhost/resource");

		Swift::MUCPayload *payload = new Swift::MUCPayload();

		payload->setPassword("password");

		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));

		injectPresence(response);

		loop->processEvents();

	}

	void handleGroupchatMessagesBouncerLeave() {

		User *user = userManager->getUser("user@localhost");

		user->addUserSetting("stay_connected", "1");

		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);

		user->getConversationManager()->addConversation(conv);

		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));

		conv->setNickname("nickname");

		conv->addJID("user@localhost/resource");

		CPPUNIT_ASSERT(!user->shouldCacheMessages());

		loop->processEvents();

		Swift::Presence::ref response = Swift::Presence::create();

		response->setTo("#room@localhost/hanzz");

		response->setFrom("user@localhost/resource");

		Swift::MUCPayload *payload = new Swift::MUCPayload();

		payload->setPassword("password");

		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));

		injectPresence(response);

		loop->processEvents();

	}

	void handleGroupchatMessagesTwoResources() {

		connectSecondResource();

		received2.clear();

		User *user = userManager->getUser("user@localhost");

		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);

		user->getConversationManager()->addConversation(conv);

		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));

		conv->setNickname("nickname");

		conv->addJID("user@localhost/resource");