std::vector<Swift::Presence::ref> presences = m_presenceOracle->getAllPresence(m_jid);

	foreach(Swift::Presence::ref presence, presences) {

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

			continue;

		}

		if (m_connected) {

			Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());

			if (highest) {

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

				response->setTo(presence->getFrom());

				response->setFrom(m_component->getJID());

				m_component->getStanzaChannel()->sendPresence(response);

			}

			else {

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

				response->setTo(presence->getFrom());

				response->setFrom(m_component->getJID());

				response->setType(Swift::Presence::Unavailable);

				m_component->getStanzaChannel()->sendPresence(response);

			}

		}

		else {

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

			response->setTo(presence->getFrom());

			response->setFrom(m_component->getJID());

			response->setType(Swift::Presence::Unavailable);

			response->setStatus("Connecting");

			m_component->getStanzaChannel()->sendPresence(response);

		}

	}

}

void User::setConnected(bool connected) {

	m_connected = connected;

	m_reconnectCounter = 0;

	setIgnoreDisconnect(false);

	updateLastActivity();

	sendCurrentPresence();

}

void User::handlePresence(Swift::Presence::ref presence) {

	int currentResourcesCount = m_presenceOracle->getAllPresence(m_jid).size();

	m_conversationManager->resetResources();

	if (!m_connected) {

		// we are not connected to legacy network, so we should do it when disco#info arrive :)

		if (m_readyForConnect == false) {

			// Forward status message to legacy network, but only if it's sent from active resource

// 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {

// 						forwardStatus(presenceShow, stanzaStatus);

// 					}

			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();

			if (capsInfo && capsInfo->getHash() == "sha-1") {

				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {

					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

					m_readyForConnect = true;

					onReadyToConnect();

				}

			}

			else if (m_component->inServerMode()) {

				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

				m_readyForConnect = true;

				onReadyToConnect();

			}

			else {

				m_reconnectTimer->start();

			}

		}

	}

	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';

	if (isMUC) {

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

			std::string room = Buddy::JIDToLegacyName(presence->getTo());

			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << room);

			onRoomLeft(room);

		}

		else {

			// force connection to legacy network to let backend to handle auto-join on connect.

			if (!m_readyForConnect) {

				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

				m_readyForConnect = true;

				onReadyToConnect();

			}

			std::string room = Buddy::JIDToLegacyName(presence->getTo());

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

			std::string password = "";

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

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

			}

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

		}

		return;

	}

	// User wants to disconnect this resource

	if (!m_component->inServerMode()) {

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

				// Send unavailable presences for online contacts

				m_rosterManager->sendUnavailablePresences(presence->getFrom());

				// Send unavailable presence for transport contact itself

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

				response->setTo(presence->getFrom());

				response->setFrom(m_component->getJID());

				response->setType(Swift::Presence::Unavailable);

				m_component->getStanzaChannel()->sendPresence(response);

		}

		else {

			sendCurrentPresence();

			// This resource is new, so we have to send buddies presences

			if (currentResourcesCount != m_resources) {

				m_rosterManager->sendCurrentPresences(presence->getFrom());

			}

		}

	}

	m_resources = currentResourcesCount;

	// Change legacy network presence

	if (m_readyForConnect) {

		Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());

		if (highest) {

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

			response->setTo(m_jid);

			response->setFrom(m_component->getJID());

			LOG4CXX_INFO(logger, m_jid.toString() << ": Changing legacy network presence to " << response->getType());

			onPresenceChanged(highest);

		}

		else {

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

			response->setTo(m_jid.toBare());

			response->setFrom(m_component->getJID());

			response->setType(Swift::Presence::Unavailable);

			onPresenceChanged(response);

		}

	}

}

void User::handleSubscription(Swift::Presence::ref presence) {

	m_rosterManager->handleSubscription(presence);

}

void User::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {

	LOG4CXX_INFO(logger, jid.toString() << ": got disco#info");

#ifdef SUPPORT_LEGACY_CAPS

	Swift::DiscoInfo::ref discoInfo = m_entityCapsManager->getCaps(jid);

	// This is old legacy cap which is not stored in entityCapsManager,

	// we have to store it in our user class.

	if (!discoInfo) {

		LOG4CXX_INFO(logger, jid.toString() << ": LEGACY");

		m_legacyCaps[jid] = info;

	}

#endif

	onConnectingTimeout();

}

void User::onConnectingTimeout() {

	if (m_connected || m_readyForConnect)

		return;

	m_reconnectTimer->stop();

	m_readyForConnect = true;

	onReadyToConnect();

	Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());

	if (highest) {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Changing legacy network presence to " << highest->getType());

		onPresenceChanged(highest);

	}

}

void User::setIgnoreDisconnect(bool ignoreDisconnect) {

	m_ignoreDisconnect = ignoreDisconnect;

	LOG4CXX_INFO(logger, m_jid.toString() << ": Setting ignoreDisconnect=" << m_ignoreDisconnect);

}

void User::handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e) {

	if (m_ignoreDisconnect) {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnecting from legacy network ignored (probably moving between backends)");

		return;

	}

	if (e == Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR || e == Swift::SpectrumErrorPayload::CONNECTION_ERROR_NETWORK_ERROR) {

		if (m_reconnectCounter < 3) {

			m_reconnectCounter++;

			// Simulate destruction/resurrection :)

			// TODO: If this stops working, create onReconnect signal

			m_userManager->onUserDestroyed(this);

			m_userManager->onUserCreated(this);

			return;

		}

	}

	if (error.empty()) {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network");

	}

	else {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network with error " << error);

	}

	onDisconnected();

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

	msg->setBody(error);

	msg->setTo(m_jid.toBare());

	msg->setFrom(m_component->getJID());

	msg->addPayload(boost::make_shared<Swift::SpectrumErrorPayload>(e));

	m_component->getStanzaChannel()->sendMessage(msg);

	// In server mode, server finishes the session and pass unavailable session to userManager if we're connected to legacy network,

	// so we can't removeUser() in server mode, because it would be removed twice.

	// Once in finishSession and once in m_userManager->removeUser.

	if (m_component->inServerMode()) {

		// Remove user later just to be sure there won't be double-free.

		// We can't be sure finishSession sends unavailable presence everytime, so check if user gets removed

		// in finishSession(...) call and if not, remove it here.

		std::string jid = m_jid.toBare().toString();		

		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::Element>(new Swift::StreamError(Swift::StreamError::UndefinedCondition, error)));

		if (m_userManager->getUser(jid) != NULL) {

			m_userManager->removeUser(this);

		}

	}

	else {

		m_userManager->removeUser(this);

	}

}

}