#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Network/Connection.h"

#include "storagebackend.h"

#include "transport/filetransfermanager.h"

namespace Transport {

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class RosterResponder;

class BlockResponder;

class DummyReadBytestream;

class NetworkPluginServer {

	public:

		struct Backend {

			int pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

			boost::shared_ptr<Swift::Connection> connection;

			unsigned long res;

			unsigned long init_res;

			unsigned long shared;

			bool acceptUsers;

			bool longRun;

			bool willDie;

			std::string id;

		};

		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager);

		virtual ~NetworkPluginServer();

		int getBackendCount() {

			return m_clients.size();

		}

		const std::list<Backend *> &getBackends() {

			return m_clients;

		}

		void collectBackend();

		bool moveToLongRunBackend(User *user);

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);

		void handleSessionFinished(Backend *c);

		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);

		void handleConnectedPayload(const std::string &payload);

		void handleDisconnectedPayload(const std::string &payload);

		void handleBuddyChangedPayload(const std::string &payload);

		void handleConvMessagePayload(const std::string &payload, bool subject = false);

		void handleParticipantChangedPayload(const std::string &payload);

		void handleRoomChangedPayload(const std::string &payload);

		void handleVCardPayload(const std::string &payload);

		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

		void handleAuthorizationPayload(const std::string &payload);

		void handleAttentionPayload(const std::string &payload);

		void handleStatsPayload(Backend *c, const std::string &payload);

		void handleFTStartPayload(const std::string &payload);

		void handleFTFinishPayload(const std::string &payload);

		void handleFTDataPayload(Backend *b ,const std::string &payload);

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);

		void handleUserDestroyed(User *user);

		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBuddyRemoved(Buddy *buddy);

		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBlockToggled(Buddy *buddy);

		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);

		void handleVCardRequired(User *user, const std::string &name, unsigned int id);

		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);

		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);

		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);

		void handleFTDataNeeded(Backend *b, unsigned long ftid);

		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);

		void pingTimeout();

		void sendPing(Backend *c);

		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false);

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		RosterResponder *m_rosterResponder;

		BlockResponder *m_blockResponder;

		Config *m_config;

		boost::shared_ptr<Swift::ConnectionServer> m_server;

		std::list<Backend *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Swift::Timer::ref m_collectTimer;

		Component *m_component;

		std::list<User *> m_waitingUsers;

		bool m_isNextLongRun;

		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;

		FileTransferManager *m_ftManager;

};

}

			return m_users;

		}

		/// 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 StorageBackend.

		/// \param user User class to remove

		void removeUser(User *user, bool onUserBehalf = true);

		void removeAllUsers(bool onUserBehalf = true);

		Swift::DiscoInfo::ref getCaps(const Swift::JID&) const;

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

		/// Returns true if user is connected.

		/// \return True if user is connected.

		bool isUserConnected(const std::string &barejid) const {

			return m_users.find(barejid) != m_users.end();

		}

		/// Returns pointer to UserRegistry.

		/// \return Pointer to UserRegistry.

		UserRegistry *getUserRegistry() {

			return m_userRegistry;

		}

		Component *getComponent() {

			return m_component;

		}

		/// Connects user manually.

		/// \param user JID of user.

		void connectUser(const Swift::JID &user);

		/// Disconnects user manually.

		/// \param user JID of user.

		void disconnectUser(const Swift::JID &user);

	private:

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

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

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

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

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

		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);

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

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

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

		Component *m_component;

		StorageBackend *m_storageBackend;

		StorageResponder *m_storageResponder;

		UserRegistry *m_userRegistry;

		Swift::Timer::ref m_removeTimer;

		friend class RosterResponder;

};

}

	if (m_clients.size() == 0) {

		// first backend connected, start the server, we're ready.

		m_component->start();

	}

	m_clients.push_front(client);

	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

	sendPing(client);

	// sendPing sets pongReceived to 0, but we want to have it -1 to ignore this backend

	// in first ::pingTimeout call, because it can be called right after this function

	// and backend wouldn't have any time to response to ping.

	client->pongReceived = -1;

	// some users are in queue waiting for this backend

	while(!m_waitingUsers.empty()) {

		// There's no new backend, so stop associating users and wait for new backend,

		// which has been already spawned in getFreeClient() call.

		if (getFreeClient() == NULL)

			break;

		User *u = m_waitingUsers.front();

		m_waitingUsers.pop_front();

		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

		// associate backend with user

		handleUserCreated(u);

		// connect user if it's ready

		if (u->isReadyToConnect()) {

			handleUserReadyToConnect(u);

		}

	}

}

void NetworkPluginServer::handleSessionFinished(Backend *c) {

	LOG4CXX_INFO(logger, "Backend " << c << " disconnected. Current backend count=" << (m_clients.size() - 1));

	// This backend will do, so we can't reconnect users to it in User::handleDisconnected call

	c->willDie = true;

	// If there are users associated with this backend, it must have crashed, so print error output

	// and disconnect users

	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {

		LOG4CXX_ERROR(logger, "Backend " << c << " disconnected (probably crashed) with active user " << (*it)->getJID().toString());

		(*it)->setData(NULL);

		(*it)->handleDisconnected("Internal Server Error, please reconnect.");

	}

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

	wrap.SerializeToString(&message);

	send(c->connection, message);

	c->connection->onDisconnected.disconnect_all_slots();

	c->connection->onDataRead.disconnect_all_slots();

	c->connection->disconnect();

	c->connection.reset();

	m_clients.remove(c);

	delete c;

}

void NetworkPluginServer::handleConnectedPayload(const std::string &data) {

	pbnetwork::Connected payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.user());

	if (!user) {

		LOG4CXX_ERROR(logger, "Connected payload received for unknown user " << payload.user());

		return;

	}

	user->setConnected(true);

	m_component->m_userRegistry->onPasswordValid(payload.user());

}

void NetworkPluginServer::handleDisconnectedPayload(const std::string &data) {

	pbnetwork::Disconnected payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	m_component->m_userRegistry->onPasswordInvalid(payload.user(), payload.message());

#include "transport/networkpluginserver.h"

#include "log4cxx/logger.h"

using namespace log4cxx;

using namespace Swift;

using namespace boost;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("StatsResponder");

StatsResponder::StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) : Swift::Responder<StatsPayload>(component->getIQRouter()) {

	m_component = component;

	m_userManager = userManager;

	m_server = server;

	m_storageBackend = storageBackend;

	m_start = time(0);

}

StatsResponder::~StatsResponder() {

}

unsigned long StatsResponder::usedMemory() {

	double shared = 0;

	double rss = 0;

#ifndef WIN32

	process_mem_usage(shared, rss);

#endif

	rss -= shared;

	const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

	BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

		rss += backend->res - backend->shared;

	}

	return (unsigned long) rss;

}

bool StatsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {

	boost::shared_ptr<StatsPayload> response(new StatsPayload());

	if (stats->getItems().empty()) {

		response->addItem(StatsPayload::Item("uptime"));

		response->addItem(StatsPayload::Item("users/online"));

		response->addItem(StatsPayload::Item("contacts/online"));

		response->addItem(StatsPayload::Item("contacts/total"));

		response->addItem(StatsPayload::Item("memory-usage"));

	}

	else {

		unsigned long contactsOnline = 0;

		unsigned long contactsTotal = 0;

		Swift::StatusShow s;

		std::string statusMessage;

		for (std::map<std::string, User *>::const_iterator it = m_userManager->getUsers().begin(); it != m_userManager->getUsers().end(); it++) {

			if (!(*it).second) {

				continue;

			}

			const RosterManager::BuddiesMap &buddies = (*it).second->getRosterManager()->getBuddies();

			contactsTotal += buddies.size();

			for(RosterManager::BuddiesMap::const_iterator bt = buddies.begin(); bt != buddies.end(); bt++) {

				if (!(*bt).second) {

					continue;

				}

				if (!(*bt).second->getStatus(s, statusMessage))

					continue;

				if (s.getType() != Swift::StatusShow::None) {

					contactsOnline++;

				}

			}

		}

		BOOST_FOREACH(const StatsPayload::Item &item, stats->getItems()) {

			if (item.getName() == "uptime") {

				response->addItem(StatsPayload::Item("uptime", "seconds", boost::lexical_cast<std::string>(time(0) - m_start)));

			}

			else if (item.getName() == "users/online") {

				response->addItem(StatsPayload::Item("users/online", "users", boost::lexical_cast<std::string>(m_userManager->getUserCount())));

			}

			}

			else if (item.getName() == "memory-usage") {

				response->addItem(StatsPayload::Item("memory-usage", "KB", boost::lexical_cast<std::string>(usedMemory())));

			}

			else if (item.getName() == "contacts/online") {

				response->addItem(StatsPayload::Item("contacts/online", "contacts", boost::lexical_cast<std::string>(contactsOnline)));

			}

			else if (item.getName() == "contacts/total") {

				response->addItem(StatsPayload::Item("contacts/total", "contacts", boost::lexical_cast<std::string>(contactsTotal)));

			}

		}

	}

	sendResponse(from, id, response);

	return true;

}

bool StatsResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {

	return false;

}

}

/**

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

#include "transport/rostermanager.h"

#include "transport/userregistry.h"

#include "storageresponder.h"

#include "log4cxx/logger.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "malloc.h"

// #include "valgrind/memcheck.h"

using namespace log4cxx;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("UserManager");

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

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	m_storageResponder = NULL;

	m_userRegistry = userRegistry;

	if (m_storageBackend) {

		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

		m_storageResponder->start();

	}

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

	component->onUserDiscoInfoReceived.connect(bind(&UserManager::handleDiscoInfo, this, _1, _2));

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

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

	m_userRegistry->onConnectUser.connect(bind(&UserManager::connectUser, this, _1));

	m_userRegistry->onDisconnectUser.connect(bind(&UserManager::disconnectUser, this, _1));

	m_removeTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1);

}

UserManager::~UserManager(){

	if (m_storageResponder) {

		m_storageResponder->stop();

		delete m_storageResponder;

	}

}

void UserManager::addUser(User *user) {

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

	if (m_storageBackend) {

		m_storageBackend->setUserOnline(user->getUserInfo().id, true);

	}

	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;

}