/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		Buddy *getBuddy(const std::string &name);

		/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		boost::signal<void (Buddy *buddy)> onBuddySet;

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendBuddyRosterPush(Buddy *buddy);

		void sendRIE();

		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key);

		std::map<std::string, Buddy *> m_buddies;

		Component *m_component;

		User *m_user;

		Swift::Timer::ref m_setBuddyTimer;

		Swift::Timer::ref m_RIETimer;

};

}

			boost::signal<void (const Swift::ComponentError &error)> onConnectionError;

			/// This signal is emitted when transport successfully connects the server.

			boost::signal<void ()> onConnected;

			/// This signal is emitted when XML stanza is sent to server.

			/// \param xml xml stanza

			boost::signal<void (const std::string &xml)> onXMLOut;

			/// This signal is emitted when XML stanza is received from server.

			/// \param xml xml stanza

			boost::signal<void (const std::string &xml)> onXMLIn;

			/// This signal is emitted when presence from XMPP user (for example "user@domain.tld")

			/// is received. It's emitted only for presences addressed to transport itself

			/// (for example to="j2j.domain.tld").

			/// \param presence presence data

			boost::signal<void (Swift::Presence::ref presence)> onUserPresenceReceived;

// 			boost::signal<void (boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid)> onDiscoInfoResponse;

		private:

			void handleConnected();

			void handleConnectionError(const Swift::ComponentError &error);

			void handlePresence(Swift::Presence::ref presence);

			void handleDataRead(const std::string &data);

			void handleDataWritten(const std::string &data);

// 			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			void handleCapsChanged(const Swift::JID& jid);

			Swift::BoostNetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::BoostIOServiceThread m_boostIOServiceThread;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			Swift::PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Swift::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			DiscoItemsResponder *m_discoItemsResponder;

			RosterResponder *m_rosterResponder;

			int m_reconnectCount;

			Config* m_config;

		virtual ~User();

		/// Returns JID of XMPP user who is currently connected using this User class.

		/// \return full JID

		const Swift::JID &getJID();

		/// Returns UserInfo struct with informations needed to connect the legacy network.

		/// \return UserInfo struct

		UserInfo &getUserInfo() { return m_userInfo; }

		RosterManager *getRosterManager() { return m_rosterManager; }

		ConversationManager *getConversationManager() { return m_conversationManager; }

		Component *getComponent() { return m_component; }

		void setData(void *data) { m_data = data; }

		void *getData() { return m_data; }

		/// Handles presence from XMPP JID associated with this user.

		/// \param presence Swift::Presence.

		void handlePresence(Swift::Presence::ref presence);

		/// Returns language.

		/// \return language

		const char *getLang() { return "en"; }

		void handleDisconnected(const std::string &error);

		boost::signal<void ()> onReadyToConnect;

		boost::signal<void ()> onDisconnected;

	private:

		void onConnectingTimeout();

		Swift::JID m_jid;

		Component *m_component;

		RosterManager *m_rosterManager;

		UserManager *m_userManager;

		ConversationManager *m_conversationManager;

		Swift::EntityCapsManager *m_entityCapsManager;

		Swift::PresenceOracle *m_presenceOracle;

		UserInfo m_userInfo;

		void *m_data;

		bool m_connected;

		bool m_readyForConnect;

		Swift::Timer::ref m_reconnectTimer;

		/// \param barejid bare JID of user

		/// \return User class associated with this user

		User *getUser(const std::string &barejid);

		/// Returns number of online users.

		/// \return number of online users

		int getUserCount();

		/// Removes user. This function disconnects user and safely removes

		/// User class. This does *not* remove user from database.

		/// \param user User class to remove

		void removeUser(User *user);

		/// Called when new User class is created.

		/// \param user newly created User class

		boost::signal<void (User *user)> onUserCreated;

		/// Called when User class is going to be removed

		/// \param user removed User class

		boost::signal<void (User *user)> onUserDestroyed;

	private:

		void handlePresence(Swift::Presence::ref presence);

		void handleMessageReceived(Swift::Message::ref message);

// 		void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

		std::map<std::string, User *> m_users;

		Component *m_component;

		StorageBackend *m_storageBackend;

};

}

Buddy *RosterManager::getBuddy(const std::string &name) {

	return m_buddies[name];

}

void RosterManager::sendRIE() {

	m_RIETimer->stop();

	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		Swift::RosterItemExchangePayload::Item item;

		item.jid = buddy->getJID().toBare();

		item.name = buddy->getAlias();

		item.action = Swift::RosterItemExchangePayload::Add;

		item.groups = buddy->getGroups();

		payload->addItem(item);

	}

	boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, m_user->getJID(), payload, m_component->getIQRouter()));

	request->send();

}

}

	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));

	m_factories = new BoostNetworkFactories(loop);

	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(1000);

	m_reconnectTimer->onTick.connect(bind(&Component::connect, this)); 

	if (CONFIG_BOOL(m_config, "service.server_mode")) {

		m_userRegistry = new MyUserRegistry();

		m_server = new Swift::Server(loop, m_factories, m_userRegistry, m_jid, CONFIG_INT(m_config, "service.port"));

		m_server->start();

		m_stanzaChannel = m_server->getStanzaChannel();

		m_iqRouter = m_server->getIQRouter();

		m_server->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_server->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

	}

	else {

		m_component = new Swift::Component(loop, m_factories, m_jid, CONFIG_STRING(m_config, "service.password"));

		m_component->setSoftwareVersion("", "");

		m_component->onConnected.connect(bind(&Component::handleConnected, this));

		m_component->onError.connect(bind(&Component::handleConnectionError, this, _1));

		m_component->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_component->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

		m_stanzaChannel = m_component->getStanzaChannel();

		m_iqRouter = m_component->getIQRouter();

	}

	m_capsMemoryStorage = new CapsMemoryStorage();

	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

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

	m_presenceOracle = new PresenceOracle(m_stanzaChannel);

	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));

	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter);

	m_discoInfoResponder->start();

	m_discoItemsResponder = new DiscoItemsResponder(m_iqRouter);

	m_discoItemsResponder->start();

	m_rosterResponder = new RosterResponder(m_iqRouter);

	m_rosterResponder->start();

// 

// 	m_registerHandler = new SpectrumRegisterHandler(m_component);

// 	m_registerHandler->start();

	m_reconnectTimer->stop();

}

void Component::handleConnected() {

	onConnected();

	m_reconnectCount = 0;

}

void Component::handleConnectionError(const ComponentError &error) {

	onConnectionError(error);

// 	if (m_reconnectCount == 2)

// 		Component::instance()->userManager()->removeAllUsers();

	m_reconnectTimer->start();

}

void Component::handleDataRead(const std::string &data) {

	onXMLIn(data);

}

void Component::handleDataWritten(const std::string &data) {

	onXMLOut(data);

}

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

	bool isMUC = presence->getPayload<MUCPayload>() != NULL;

	// filter out login/logout presence spam

	if (!presence->getTo().getNode().empty() && isMUC == false)

		return;

	// filter out bad presences

	if (!presence->getFrom().isValid()) {

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

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

		response->setFrom(presence->getTo());

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

		response->addPayload(boost::shared_ptr<Payload>(new ErrorPayload(ErrorPayload::JIDMalformed, ErrorPayload::Modify)));

		m_component->sendPresence(response);

		return;

	}

	// check if we have this client's capabilities and ask for them

	bool haveFeatures = false;

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

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

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

			haveFeatures = m_entityCapsManager->getCaps(presence->getFrom()) != DiscoInfo::ref();

			std::cout << "has capsInfo " << haveFeatures << "\n";

		}

// 		else {

// 			GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(presence->getFrom(), m_iqRouter);

// 			discoInfoRequest->onResponse.connect(boost::bind(&Component::handleDiscoInfoResponse, this, _1, _2, presence->getFrom()));

// 			discoInfoRequest->send();

// 		}

	}

	onUserPresenceReceived(presence);

}

void Component::handleCapsChanged(const Swift::JID& jid) {

	bool haveFeatures = m_entityCapsManager->getCaps(jid) != DiscoInfo::ref();

	std::cout << "has capsInfo " << haveFeatures << "\n";

}

}

					onReadyToConnect();

				}

			}

			else {

				m_reconnectTimer->start();

			}

		}

	}

	if (highest) {

		highest->setTo(presence->getFrom().toBare());

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

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

	}

	else {

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

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

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

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

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

	}

}

void User::onConnectingTimeout() {

	if (m_connected || m_readyForConnect)

		return;

	m_reconnectTimer->stop();

	m_readyForConnect = true;

	onReadyToConnect();

}

void User::handleDisconnected(const std::string &error) {

	onDisconnected();

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

	msg->setBody(error);

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

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

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

	if (m_component->inServerMode()) {

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

	}

	m_userManager->removeUser(this);

}

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "transport/usermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

namespace Transport {

UserManager::UserManager(Component *component, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

// 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));

}

UserManager::~UserManager(){

}

void UserManager::addUser(User *user) {

	m_users[user->getJID().toBare().toString()] = user;

	onUserCreated(user);

}

User *UserManager::getUser(const std::string &barejid){

	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

		return m_cachedUser;

	}

	if (m_users.find(barejid) != m_users.end()) {

		User *user = m_users[barejid];

		m_cachedUser = user;

		return user;

	}

	return NULL;

}

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

		if (user) {

			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(presence->getFrom().toBare());

			// There's no presence for this user, so disconnect

			if (!highest || (highest && highest->getType() == Swift::Presence::Unavailable)) {

				removeUser(user);

			}

		}

		// TODO: HANDLE MUC SOMEHOW

// 		else if (user && Transport::instance()->protocol()->tempAccountsAllowed() && !((User *) user)->hasOpenedMUC()) {

// 			Transport::instance()->userManager()->removeUser(user);

// 		}

	}

}

void UserManager::handleMessageReceived(Swift::Message::ref message) {

	User *user = getUser(message->getFrom().toBare().toString());

	if (!user ){

		return;

	}

	user->getConversationManager()->handleMessageReceived(message);

}

}