#include <string>

#include <algorithm>

#include <map>

#include "Swiften/Swiften.h"

// #include "rosterstorage.h"

namespace Transport {

class Buddy;

class User;

class Component;

/// Manages roster of one XMPP user.

class RosterManager {

	public:

		/// Creates new RosterManager.

		/// \param user User associated with this RosterManager.

		/// \param component Transport instance associated with this roster.

		RosterManager(User *user, Component *component);

		/// Destructor.

		virtual ~RosterManager();

		/// Associates the buddy with this roster,

		/// 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;

};

}

			/// Connects the Jabber server.

			/// \see Component()

			void connect();

			/// Sets disco#info features which are sent as answer to

			/// disco#info IQ-get. This sets features of transport contact (For example "j2j.domain.tld").

			/// \param features list of features as sent in disco#info response

			void setTransportFeatures(std::list<std::string> &features);

			/// Sets disco#info features which are sent as answer to

			/// disco#info IQ-get. This sets features of legacy network buddies (For example "me\40gmail.com@j2j.domain.tld").

			/// \param features list of features as sent in disco#info response

			void setBuddyFeatures(std::list<std::string> &features);

			/// Returns Jabber ID of this transport.

			/// \return Jabber ID of this transport

			Swift::JID &getJID() { return m_jid; }

			Swift::BoostNetworkFactories *getFactories() { return m_factories; }

			Factory *getFactory() { return m_factory; }

			/// This signal is emitted when server disconnects the transport because of some error.

			/// \param error disconnection error

			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;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

		friend class User;

		friend class UserRegistration;

	};

}

#include "Swiften/Swiften.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "storagebackend.h"

namespace Transport {

class Component;

class RosterManager;

class ConversationManager;

class UserManager;

struct UserInfo;

/// Represents online XMPP user.

class User {

	public:

		/// Creates new User class.

		/// \param jid XMPP JID associated with this user

		/// \param userInfo UserInfo struct with informations needed to connect

		/// this user to legacy network

		/// \param component Component associated with this user

		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);

		/// Destroyes User.

		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;

};

}

#include <map>

#include "Swiften/Swiften.h"

namespace Transport {

class User;

class Component;

class StorageBackend;

/// Manages online XMPP Users.

/// This class handles presences and creates User classes when new user connects.

/// It also removes the User class once the last user's resource disconnected.

class UserManager {

	public:

		/// Creates new UserManager.

		/// \param component Component which's presence will be handled

		/// \param storageBackend Storage backend used to fetch UserInfos

		UserManager(Component *component, StorageBackend *storageBackend);

		/// Destroys UserManager.

		~UserManager();

		/// Returns user according to his bare JID.

		/// \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;

};

}

		sendBuddyRosterPush(buddy);

	}

	else {

	}

	if (m_setBuddyTimer->onTick.empty()) {

		m_setBuddyTimer->stop();

		if (true /*&& rie_is_supported*/) {

			m_RIETimer->start();

		}

	}

}

void RosterManager::unsetBuddy(Buddy *buddy) {

	m_buddies.erase(buddy->getName());

	onBuddyUnset(buddy);

}

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

	if (m_buddies[key] != NULL) {

		m_buddies[key]->buddyChanged();

	}

}

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();

}

}

using namespace boost;

namespace Transport {

class MyUserRegistry : public Swift::UserRegistry {

	public:

		MyUserRegistry() {}

		~MyUserRegistry() {}

		bool isValidUserPassword(const JID& user, const std::string& password) const {

			users[user.toBare().toString()] = password;

			return true;

		}

		mutable std::map<std::string, std::string> users;

};

Component::Component(Swift::EventLoop *loop, Config *config, Factory *factory) {

	m_component = NULL;

	m_userRegistry = NULL;

	m_server = NULL;

	m_reconnectCount = 0;

	m_config = config;

	m_factory = factory;

	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();

}

Component::~Component() {

	delete m_presenceOracle;

	delete m_entityCapsManager;

	delete m_capsManager;

	delete m_capsMemoryStorage;

	delete m_rosterResponder;

	delete m_discoInfoResponder;

	if (m_component)

		delete m_component;

	if (m_server)

		delete m_server;

	if (m_userRegistry)

		delete m_userRegistry;

	delete m_factories;

}

const std::string &Component::getUserRegistryPassword(const std::string &barejid) {

	MyUserRegistry *registry = dynamic_cast<MyUserRegistry *>(m_userRegistry);

	return registry->users[barejid];

}

Swift::StanzaChannel *Component::getStanzaChannel() {

	return m_stanzaChannel;

}

Swift::PresenceOracle *Component::getPresenceOracle() {

	return m_presenceOracle;

}

void Component::setTransportFeatures(std::list<std::string> &features) {

	m_discoInfoResponder->setTransportFeatures(features);

}

void Component::setBuddyFeatures(std::list<std::string> &features) {

	// TODO: handle caps change

	m_discoInfoResponder->setBuddyFeatures(features);

}

void Component::connect() {

	if (!m_component)

		return;

	m_reconnectCount++;

	m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));

	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";

}

}

	m_reconnectTimer->stop();

	delete m_rosterManager;

	delete m_conversationManager;

}

const Swift::JID &User::getJID() {

	return m_jid;

}

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

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

	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()) {

					m_readyForConnect = true;

					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);

}

}

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * 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;

}

void UserManager::removeUser(User *user) {

	m_users.erase(user->getJID().toBare().toString());

	if (m_cachedUser == user)

		m_cachedUser = NULL;

	onUserDestroyed(user);

	delete user;

}

int UserManager::getUserCount() {

	return m_users.size();

}

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

	std::string barejid = presence->getTo().toBare().toString();

	std::string userkey = presence->getFrom().toBare().toString();