}

void NetworkPluginServer::collectBackend() {

	// Stop accepting new users to backend with the biggest memory usage. This prevents backends

	// which are leaking to eat whole memory by connectin new users to legacy network.

	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");

	unsigned long max = 0;

	Backend *backend = NULL;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->res > max) {

			max = (*it)->res;

			backend = (*it);

		}

	}

	if (backend) {

		if (m_collectTimer) {

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

	bool isInvisible = presence->getPayload<Swift::InvisiblePayload>() != NULL;

	if (isInvisible) {

		LOG4CXX_INFO(logger, "This presence is invisible");

		status.set_status((pbnetwork::STATUS_INVISIBLE));

	}

	else {

		status.set_status((pbnetwork::StatusType) presence->getShow());

	}

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

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

// 		handleSessionFinished(c);

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

// 	}

}

void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {

	conv->getConversationManager()->getUser()->updateLastActivity();

	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();

	if (statePayload) {

		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;

		switch (statePayload->getChatState()) {

			case Swift::ChatState::Active:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;

				break;

			case Swift::ChatState::Composing:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;

				break;

			case Swift::ChatState::Paused:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;

				break;

			default:

				break;

		}

		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {

			pbnetwork::Buddy buddy;

			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

			buddy.set_buddyname(conv->getLegacyName());

			std::string message;

			buddy.SerializeToString(&message);

			WRAP(message, type);

			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

			if (!c) {

				return;

			}

			send(c->connection, message);

		}

	}

	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();

	if (attentionPayload) {

		pbnetwork::ConversationMessage m;

		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

		m.set_buddyname(conv->getLegacyName());

		m.set_message(msg->getBody());

		std::string message;

		m.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);

		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

		send(c->connection, message);

		return;

	}

	std::string xhtml;

	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();

	if (xhtmlPayload) {

		xhtml = xhtmlPayload->getBody();

	}

	// Send normal message

	if (!msg->getBody().empty() || !xhtml.empty()) {

		pbnetwork::ConversationMessage m;

		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

		m.set_buddyname(conv->getLegacyName());

		m.set_message(msg->getBody());

		m.set_xhtml(xhtml);

		std::string message;

		m.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

		if (!c) {

			return;

		}

		send(c->connection, message);

	}

}

void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

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

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_groups(b->getGroups().size() == 0 ? "" : b->getGroups()[0]);

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);

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

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {

	User *user = b->getRosterManager()->getUser();

	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());

	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());

	user->getRosterManager()->storeBuddy(b);

	pbnetwork::Buddy buddy;

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

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_groups(b->getGroups().size() == 0 ? "" : b->getGroups()[0]);

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

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

	if (!c) {

		return;

	}

	send(c->connection, message);

}

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

	handleBuddyUpdated(buddy, item);

}

void NetworkPluginServer::handleBlockToggled(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

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

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_groups(b->getGroups().size() == 0 ? "" : b->getGroups()[0]);

	buddy.set_status(pbnetwork::STATUS_NONE);

	buddy.set_blocked(!b->isBlocked());

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

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

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {

	pbnetwork::VCard vcard;

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

	vcard.set_buddyname("");

	vcard.set_id(0);

	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());

	vcard.set_nickname(v->getNickname());

	std::string message;