purple_account_set_password(account, password.c_str());

			purple_account_set_enabled(account, "spectrum", TRUE);

			purple_account_set_bool(account, "custom_smileys", FALSE);

			purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);

			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);

			if (status_type != NULL) {

				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);

			}

			m_accounts[account] = user;

		}

		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

// 				VALGRIND_DO_LEAK_CHECK;

				m_sessions[user] = NULL;

				purple_account_set_enabled(account, "spectrum", FALSE);

				// Remove conversations.

				// This has to be called before m_account->ui_data = NULL;, because it uses

				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.

				GList *iter;

				for (iter = purple_get_conversations(); iter; ) {

					PurpleConversation *conv = (PurpleConversation*) iter->data;

					iter = iter->next;

					if (purple_conversation_get_account(conv) == account)

						purple_conversation_destroy(conv);

				}

				g_free(account->ui_data);

				account->ui_data = NULL;

				m_accounts.erase(account);

				purple_notify_close_with_handle(account);

				purple_request_close_with_handle(account);

				purple_accounts_remove(account);

				GSList *buddies = purple_find_buddies(account, NULL);

				while(buddies) {

					PurpleBuddy *b = (PurpleBuddy *) buddies->data;

					purple_blist_remove_buddy(b);

					buddies = g_slist_delete_link(buddies, buddies);

				}

				/* Remove any open conversation for this account */

				for (GList *it = purple_get_conversations(); it; ) {

					PurpleConversation *conv = (PurpleConversation *) it->data;

					it = it->next;

					if (purple_conversation_get_account(conv) == account)

						purple_conversation_destroy(conv);

				}

				/* Remove this account's pounces */

					// purple_pounce_destroy_all_by_account(account);

				/* This will cause the deletion of an old buddy icon. */

				purple_buddy_icons_set_account_icon(account, NULL, 0);

				purple_account_destroy(account);

				// force returning of memory chunks allocated by libxml2 to kernel

				malloc_trim(0);

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

					case Swift::StatusShow::Away: {

						st = PURPLE_STATUS_AWAY;

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))

							st = PURPLE_STATUS_EXTENDED_AWAY;

						else

							st = PURPLE_STATUS_AWAY;

						break;

					}

					case Swift::StatusShow::DND: {

						st = PURPLE_STATUS_UNAVAILABLE;

						break;

					}

					case Swift::StatusShow::XA: {

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))

							st = PURPLE_STATUS_AWAY;

						else

							st = PURPLE_STATUS_EXTENDED_AWAY;

						break;

					}

					case Swift::StatusShow::None: {

						st = PURPLE_STATUS_OFFLINE;

						break;

					}

					default:

						st = PURPLE_STATUS_AVAILABLE;

						break;

				}

				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);

				std::string markup(_markup);

				g_free(_markup);

				// we are already connected so we have to change status

				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);

				if (status_type != NULL) {

					// send presence to legacy network

					if (!markup.empty()) {

						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);

					}

					else {

						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);

					}

				}

			}

		}

		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);

				if (!conv) {

					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());

				}

				if (xhtml.empty()) {

					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);

					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);

					g_free(_markup);

				}

				else {

					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());

				}

			}

		}

		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				std::string name = legacyName;

				if (CONFIG_STRING(config, "service.protocol") == "any" && legacyName.find("prpl-") == 0) {

					name = name.substr(name.find(".") + 1);

				}

				serv_get_info(purple_account_get_connection(account), name.c_str());

				m_vcards[user + name] = id;

			}

		}

		void handleVCardUpdatedRequest(const std::string &user, const std::string &p) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				gssize size = p.size();

				// this will be freed by libpurple

				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));

				memcpy(photo, p.c_str(), size);

#ifdef WITH_IMAGEMAGICK

				if (size != 0) {

					PurplePlugin *plugin = purple_find_prpl(Transport::instance()->protocol()->protocol().c_str());

					PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);

					if (prpl_info->icon_spec.format == NULL) {

						g_free(photo);

						return;

					}

					try {

						Magick::Blob blob(photo, size);

						g_free(photo);

						photo = NULL;

						Magick::Image img(blob);

						std::string format;

						gchar **strlist = g_strsplit(prpl_info->icon_spec.format, ",", 10);

						for (gchar **f = strlist; *f != NULL; f++) {

							// jpeg is the best

							if (strcmp(*f, "jpeg") == 0 || strcmp(*f, "jpg") == 0) {

								format = "jpg";

							}

							// png is number two

							else if (strcmp(*f, "png") == 0 && format != "jpg") {

								format = *f;

							}

							// gif is alright if there's not jpeg or png

							else if (strcmp(*f, "gif") == 0 && format != "jpg" && format != "png") {

								format = *f;

							}

							else if (format.empty()) {

								format = *f;

							}

						}

						g_strfreev(strlist);

						img.magick(format);

/**

 * 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/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 "transport/rosterresponder.h"

#include "blockresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Elements/AttentionPayload.h"

#include "Swiften/Elements/XHTMLIMPayload.h"

#include "pbnetwork.pb.h"

#include "sys/wait.h"

#include "sys/signal.h"

#include "log4cxx/logger.h"

#include "popt.h"

using namespace log4cxx;

namespace Transport {

static unsigned long backend_id;

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

class NetworkConversation : public Conversation {

	public:

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

		}

		// Called when there's new message to legacy network from XMPP network

		void sendMessage(boost::shared_ptr<Swift::Message> &message) {

			onMessageToSend(this, message);

		}

		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		// Creates new conversation (NetworkConversation in this case)

		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);

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

			return nc;

		}

		// Creates new LocalBuddy

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setSubscription(buddyInfo.subscription);

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) buddyInfo.flags);

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

// Wraps google protobuf payload into WrapperMessage and serialize it to string

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

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

static pid_t exec_(std::string path, const char *host, const char *port, const char *config) {

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));

	// Add host and port.

	path += std::string(" --host ") + host + " --port " + port + " " + config;

	LOG4CXX_INFO(logger, "Starting new backend " << path);

	// Create array of char * from string using -lpopt library

	char *p = (char *) malloc(path.size() + 1);

	strcpy(p, path.c_str());

	int argc;

	char **argv;

	poptParseArgvString(p, &argc, (const char ***) &argv);

	// fork and exec

	pid_t pid = fork();

	if ( pid == 0 ) {

		// child process

		exit(execv(argv[0], argv));

	} else if ( pid < 0 ) {

		// fork failed

	}

	free(p);

	return pid;

}

static void SigCatcher(int n) {

	pid_t result;

	int status;

	// Read exit code from all children to not have zombies arround

	if (backend) {

		m_collectTimer->start();

		LOG4CXX_INFO(logger, "Backend " << backend << "is set to die");

		backend->acceptUsers = false;

	}

}

bool NetworkPluginServer::moveToLongRunBackend(User *user) {

	// Check if user has already some backend

	Backend *old = (Backend *) user->getData();

	if (!old) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");

		return true;

	}

	// if he's already on long run, do nothing

	if (old->longRun) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");

		return true;

	}

	// Get free longrun backend, if there's no longrun backend, create one and wait

	// for its connection

	Backend *backend = getFreeClient(false, true);

	if (!backend) {

		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");

		return false;

	}

	// old backend will trigger disconnection which has to be ignored to keep user online

	user->setIgnoreDisconnect(true);

	// remove user from the old backend

	// If backend is empty, it will be collected by pingTimeout

	old->users.remove(user);

	// switch to new backend and connect

	user->setData(backend);

	backend->users.push_back(user);

	// connect him

	handleUserReadyToConnect(user);

	return true;

}

void NetworkPluginServer::handleUserCreated(User *user) {

	// Get free backend to handle this user or spawn new one if there's no free one.

	Backend *c = getFreeClient();

	// Add user to queue if there's no free backend to handle him so far.

	if (!c) {

		LOG4CXX_INFO(logger, "There is no backend to handle user " << user->getJID().toString() << ". Adding him to queue.");

		m_waitingUsers.push_back(user);

		return;

	}

	// Associate users with backend

	user->setData(c);

	c->users.push_back(user);

// 	UserInfo userInfo = user->getUserInfo();

	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));

	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));

	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3));

	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));

}

void NetworkPluginServer::handleUserReadyToConnect(User *user) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Login login;

	login.set_user(user->getJID().toBare());

	login.set_legacyname(userInfo.uin);

	login.set_password(userInfo.password);

	std::string message;

	login.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

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

	if (presence->getShow() == Swift::StatusShow::None)

		return;

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Status status;

	status.set_username(user->getJID().toBare());

	status.set_statusmessage(presence->getStatus());

	std::string message;

	status.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleRoomJoined(User *user, const std::string &r, const std::string &nickname, const std::string &password) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Room room;

	room.set_username(user->getJID().toBare());

	room.set_nickname(nickname);

	room.set_room(r);

	room.set_password(password);

	std::string message;

	room.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	NetworkConversation *conv = new NetworkConversation(user->getConversationManager(), r, true);

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

	conv->setNickname(nickname);

}

void NetworkPluginServer::handleRoomLeft(User *user, const std::string &r) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Room room;

	room.set_username(user->getJID().toBare());

	room.set_nickname("");

	room.set_room(r);

	room.set_password("");

	std::string message;

	room.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(r);

	if (!conv) {

		return;

	}

	user->getConversationManager()->removeConversation(conv);

	delete conv;

}

void NetworkPluginServer::handleUserDestroyed(User *user) {

	std::cout << "HANDLE_DESTROYED\n";

	m_waitingUsers.remove(user);

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Logout logout;

	logout.set_user(user->getJID().toBare());

	logout.set_legacyname(userInfo.uin);

	std::string message;

	logout.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	c->users.remove(user);

	if (c->users.size() == 0) {

		LOG4CXX_INFO(logger, "Disconnecting backend " << c << ". There are no users.");

		c->connection->disconnect();

		c->connection.reset();

// 		handleSessionFinished(c);

// 		m_clients.erase(user->connection);