#include "storagebackend.h"

namespace Transport {

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class NetworkPluginServer {

	public:

		struct Client {

			bool pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

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

		};

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

		void handleUserDestroyed(User *user);

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

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

		void pingTimeout();

		void sendPing(Client *c);

		Client *getFreeClient();

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		Config *m_config;

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

		std::list<Client *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Component *m_component;

};

}

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

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/RosterPayload.h"

namespace Transport {

class UserManager;

class RosterResponder : public Swift::Responder<Swift::RosterPayload> {

	public:

		~RosterResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		UserManager *m_userManager;

};

}

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

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

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

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

		StorageResponder *m_storageResponder;

		friend class RosterResponder;

};

}

#include "transport/networkpluginserver.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "transport/usermanager.h"

#include "transport/conversationmanager.h"

#include "transport/localbuddy.h"

#include "transport/config.h"

#include "transport/conversation.h"

#include "transport/vcardresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "pbnetwork.pb.h"

#include "sys/wait.h"

#include "sys/signal.h"

namespace Transport {

class NetworkConversation : public Conversation {

	public:

		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {

	m_component = component;

	m_component->m_factory = new NetworkFactory(this);

	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));

	m_pingTimer = component->getFactories()->getTimerFactory()->createTimer(10000);

	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this)); 

	m_vcardResponder = new VCardResponder(component->getIQRouter(), userManager);

	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

	m_vcardResponder->start();

	m_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

	signal(SIGCHLD, SigCatcher);

	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());

}

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	delete m_vcardResponder;

}

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

	Client *client = new Client;

	client->pongReceived = true;

	client->connection = c;

	m_clients.push_back(client);

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

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

	sendPing(client);

 * (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 <iostream>

#include <boost/bind.hpp>

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Swiften.h"

#include "transport/user.h"

#include "transport/usermanager.h"

#include "transport/rostermanager.h"

using namespace Swift;

using namespace boost;

namespace Transport {

	m_userManager = userManager;

}

RosterResponder::~RosterResponder() {

}

bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {

	// Get means we're in server mode and user wants to fetch his roster.

	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.

	User *user = m_userManager->getUser(from.toBare().toString());

	if (!user) {

		// Client can send jabber:iq:roster IQ before presence, so we do little hack here to

 * 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 "storageresponder.h"

namespace Transport {

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

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

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

	m_storageResponder->start();

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

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

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

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

}

UserManager::~UserManager(){

	m_storageResponder->stop();

	delete m_storageResponder;

}

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;

	}