m_accounts[account] = user;

		}

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

			const char *protocol = CONFIG_STRING(config, "service.protocol").c_str();

			PurpleAccount *account = purple_accounts_find(legacyName.c_str(), protocol);

			if (account) {

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

			}

		}

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

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

				}

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

				purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);

				g_free(_markup);

			}

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

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

				m_vcards[user + legacyName] = id;

			}

		}

		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::string &groups) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());

				if (buddy) {

					purple_blist_alias_buddy(buddy, alias.c_str());

					purple_blist_server_alias_buddy(buddy, alias.c_str());

					serv_alias_buddy(buddy);

				}

				else {

					PurpleBuddy *buddy = purple_buddy_new(account, buddyName.c_str(), alias.c_str());

					// Add newly created buddy to legacy network roster.

					PurpleGroup *group = purple_find_group(groups.c_str());

					purple_blist_add_buddy(buddy, NULL, group ,NULL);

					purple_account_add_buddy(account, buddy);

				}

			}

		}

		std::map<std::string, PurpleAccount *> m_sessions;

		std::map<PurpleAccount *, std::string> m_accounts;

		std::map<std::string, unsigned int> m_vcards;

	private:

		Config *config;

};

static std::string getAlias(PurpleBuddy *m_buddy) {

	std::string alias;

	if (purple_buddy_get_server_alias(m_buddy))

		alias = (std::string) purple_buddy_get_server_alias(m_buddy);

	else

		alias = (std::string) purple_buddy_get_alias(m_buddy);

	return alias;

}

static bool getStatus(PurpleBuddy *m_buddy, Swift::StatusShow &status, std::string &statusMessage) {

	PurplePresence *pres = purple_buddy_get_presence(m_buddy);

	if (pres == NULL)

		return false;

	PurpleStatus *stat = purple_presence_get_active_status(pres);

	if (stat == NULL)

		return false;

	int st = purple_status_type_get_primitive(purple_status_get_type(stat));

	switch(st) {

		case PURPLE_STATUS_AVAILABLE: {

			break;

void NetworkPlugin::handleDataRead(const Swift::SafeByteArray &data) {

	m_data.insert(m_data.end(), data.begin(), data.end());

	while (m_data.size() != 0) {

		unsigned int expected_size;

		if (m_data.size() >= 4) {

			expected_size = *((unsigned int*) &m_data[0]);

			expected_size = ntohl(expected_size);

			if (m_data.size() - 4 < expected_size)

				return;

		}

		else {

			return;

		}

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&m_data[4], expected_size) == false) {

			m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

			return;

		}

		m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_LOGIN:

				handleLoginPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LOGOUT:

				handleLogoutPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PING:

				sendPong();

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:

				handleJoinRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:

				handleLeaveRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

				handleBuddyChangedPayload(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

void NetworkPlugin::send(const std::string &data) {

	char header[4];

	*((int*)(header)) = htonl(data.size());

	m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPlugin::sendPong() {

	m_pingReceived = true;

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);

	wrap.SerializeToString(&message);

	send(message);

	std::cout << "SENDING PONG\n";

}

void NetworkPlugin::pingTimeout() {

	std::cout << "PINGTIMEOUT " << m_pingReceived << " " << this << "\n";

	if (m_pingReceived == false) {

		exit(1);

	}

	m_pingReceived = false;

	m_pingTimer->start();

}

}