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