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;

		};

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

	required StatusType status = 5;

	optional string statusMessage = 6;

	optional string newname = 7;

}

message VCard {

	required string userName = 1;

	required string buddyName = 2;

	required int32 id = 3;

	optional string fullname = 4;

	optional string nickname = 5;

	optional bytes photo = 6;

}

message Status {

	required string userName = 1;

	required StatusType status = 3;

	optional string statusMessage = 4;

}

message Stats {

	required int32 res = 1;

	required int32 init_res = 2;

	required int32 shared = 3;

}

message File {

	required string userName = 1;

	required string buddyName = 2;

	required string fileName = 3;

	required int32 size = 4;

	optional int32 ftID = 5;

}

message FileTransferData {

	required int32 ftID = 1;

	required bytes data = 2;

}

message WrapperMessage {

	enum Type { 

		TYPE_CONNECTED 				= 1;

		TYPE_DISCONNECTED 			= 2;

		TYPE_LOGIN 					= 3;

		TYPE_LOGOUT 				= 4;

		TYPE_BUDDY_CHANGED			= 6;

		TYPE_BUDDY_REMOVED			= 7;

		TYPE_CONV_MESSAGE			= 8;

#include "transport/networkplugin.h"

#include "log4cxx/logger.h"

#include "log4cxx/basicconfigurator.h"

#include "transport/memoryusage.h"

#ifndef WIN32

#include <arpa/inet.h>

#else 

#include <winsock2.h>

#include <stdint.h>

#endif

using namespace log4cxx;

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

namespace Transport {

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

NetworkPlugin::NetworkPlugin() {

	m_pingReceived = false;

	double shared;

#ifndef WIN32

	process_mem_usage(shared, m_init_res);

#endif

}

NetworkPlugin::~NetworkPlugin() {

}

void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

	m.set_message(msg);

	m.set_nickname(nickname);

	m.set_xhtml(xhtml);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

	send(message);

	sendMemoryUsage();

}

void NetworkPlugin::sendMemoryUsage() {

	pbnetwork::Stats stats;

	stats.set_init_res(m_init_res);

	double res = 0;

	double shared = 0;

#ifndef WIN32

	process_mem_usage(shared, res);

#endif

	double e_res;

	double e_shared;

	handleMemoryUsage(e_res, e_shared);

	stats.set_res(res + e_res);

	stats.set_shared(shared + e_shared);

	std::string message;

	stats.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATS);

	send(message);

}

}

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

	msg->setBody(payload.message());

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

	// Attentions trigger new Conversation creation

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());

	if (!conv) {

		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());

		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));

	}

	conv->handleMessage(msg);

}

void NetworkPluginServer::handleStatsPayload(Backend *c, const std::string &data) {

	pbnetwork::Stats payload;

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

		// TODO: ERROR

		return;

	}

	c->res = payload.res();

	c->init_res = payload.init_res();

	c->shared = payload.shared();

}

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

	pbnetwork::File payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	LOG4CXX_INFO(logger, "handleFTStartPayload " << payload.filename() << " " << payload.buddyname());

	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());

	if (!buddy) {

		// TODO: escape? reject?

		return;

	}

	Swift::StreamInitiationFileInfo fileInfo;

	fileInfo.setSize(payload.size());

	fileInfo.setName(payload.filename());