format = *f;

							}

							else if (format.empty()) {

								format = *f;

							}

						}

						g_strfreev(strlist);

						img.magick(format);

						int width, height;

						if (CONFIG().protocol == "icq") {

							width = 48;

							height = 48;

						}

						else {

							purple_buddy_icon_get_scale_size(&prpl_info->icon_spec, &width, &height);

						}

						if (img.size().width() != width || img.size().height() != height) {

							Magick::Geometry g = Magick::Geometry(width,height);

							g.aspect(CONFIG().protocol == "icq");

							img.scale(g);

						}

						Magick::Blob output;

						img.write(&output);

						size = output.length();

						// this will be freed by libpurple

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

						memcpy(photo, output.data(), size);

					}

					catch ( Magick::Exception & error) {

						Log("handleVCard","Caught Magick++ exception: " << error.what());

					} catch(...) {   // catch all other exceptions

					}

				}

#endif /* WITH_IMAGEMAGICK */

				if (!photo)

					return;

				purple_buddy_icons_set_account_icon(account, photo, size);

			}

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {

					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);

					m_authRequests.erase(user + buddyName);

				}

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

				if (buddy) {

					purple_account_remove_buddy(account, buddy, purple_buddy_get_group(buddy));

					purple_blist_remove_buddy(buddy);

				}

			}

		}

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

				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {

					m_authRequests[user + buddyName]->authorize_cb(m_authRequests[user + buddyName]->user_data);

					m_authRequests.erase(user + buddyName);

				}

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

				if (buddy) {

					if (getAlias(buddy) != alias) {

						purple_blist_alias_buddy(buddy, alias.c_str());

						purple_blist_server_alias_buddy(buddy, alias.c_str());

						serv_alias_buddy(buddy);

					}

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

					if (!group) {

						group = purple_group_new(groups.c_str());

					}

					purple_blist_add_contact(purple_buddy_get_contact(buddy), group ,NULL);

				}

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

					if (!group) {

						group = purple_group_new(groups.c_str());

					}

					purple_blist_add_buddy(buddy, NULL, group ,NULL);

					purple_account_add_buddy(account, buddy);

				}

			}

		}

		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				if (blocked)

					purple_privacy_deny(account, buddyName.c_str(), FALSE, FALSE);

				else

					purple_privacy_allow(account, buddyName.c_str(), FALSE, FALSE);

			}

		}

		void handleTypingRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPING);

			}

		}

		void handleTypedRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPED);

			}

		}

		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_NOT_TYPING);

			}

		}

		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				purple_prpl_send_attention(purple_account_get_connection(account), buddyName.c_str(), 0);

			}

		}

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

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

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

		std::map<std::string, authRequest *> m_authRequests;

	private:

		Config *config;

};

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;

		}

		case PURPLE_STATUS_AWAY: {

			status = Swift::StatusShow::Away;

			break;

		}

		case PURPLE_STATUS_UNAVAILABLE: {

			status = Swift::StatusShow::DND;

			break;

		}

		case PURPLE_STATUS_EXTENDED_AWAY: {

			status = Swift::StatusShow::XA;

			break;

		}

		case PURPLE_STATUS_OFFLINE: {

			status = Swift::StatusShow::None;

			break;

		}

		default:

			break;

	}

	const char *message = purple_status_get_attr_string(stat, "message");

	if (message != NULL) {

		char *stripped = purple_markup_strip_html(message);

		statusMessage = std::string(stripped);

		g_free(stripped);

	}

	else

		statusMessage = "";

	return true;

}

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

	char *avatarHash = NULL;

	PurpleBuddyIcon *icon = purple_buddy_icons_find(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));

	if (icon) {

		avatarHash = purple_buddy_icon_get_full_path(icon);

	}

	if (avatarHash) {

		// Check if it's patched libpurple which saves icons to directories

		char *hash = strrchr(avatarHash,'/');

		std::string h;

		if (hash) {

			char *dot;

			hash++;

			dot = strchr(hash, '.');

			if (dot)

				*dot = '\0';

			std::string ret(hash);

			g_free(avatarHash);

			return ret;

		}

		else {

			std::string ret(avatarHash);

			g_free(avatarHash);

			return ret;

		}

	}

	return "";

}

static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {

	std::vector<std::string> groups;

	return groups;

}

static void buddyListNewNode(PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	PurpleBuddy *buddy = (PurpleBuddy *) node;

	PurpleAccount *account = purple_buddy_get_account(buddy);

	Swift::StatusShow status;

	std::string message;

	getStatus(buddy, status, message);

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

}

// static void buddyStatusChanged(PurpleBuddy *buddy, PurpleStatus *status_, PurpleStatus *old_status) {

// 	PurpleAccount *account = purple_buddy_get_account(buddy);

// 

// 	Swift::StatusShow status;

// 	std::string message;

// 	getStatus(buddy, status, message);

// 

// 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

// }

// 

// static void buddySignedOn(PurpleBuddy *buddy) {

// 	PurpleAccount *account = purple_buddy_get_account(buddy);

// 

// 	Swift::StatusShow status;

// 	std::string message;

// 	getStatus(buddy, status, message);

// 

// 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

// }

// 

// static void buddySignedOff(PurpleBuddy *buddy) {

// 	PurpleAccount *account = purple_buddy_get_account(buddy);

// 

// 	Swift::StatusShow status;

// 	std::string message;

// 	getStatus(buddy, status, message);

// 

// 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

// }

static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	PurpleBuddy *buddy = (PurpleBuddy *) node;

	PurpleAccount *account = purple_buddy_get_account(buddy);

	Swift::StatusShow status;

	std::string message;

	getStatus(buddy, status, message);

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy),

		purple_privacy_check(account, purple_buddy_get_name(buddy)) == false);

}

static void NodeRemoved(PurpleBlistNode *node, void *data) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

// 	PurpleBuddy *buddy = (PurpleBuddy *) node;

}

static PurpleBlistUiOps blistUiOps =

{

	NULL,

	buddyListNewNode,

	NULL,

	buddyListUpdate,

	NULL, //NodeRemoved,

	NULL,

	NULL,

	NULL, // buddyListAddBuddy,

	NULL,

	NULL,

	NULL, //buddyListSaveNode,

	NULL, //buddyListRemoveNode,

	NULL, //buddyListSaveAccount,

	NULL

};

static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {

	// Don't forwards our own messages.

	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)

		return;

	PurpleAccount *account = purple_conversation_get_account(conv);

// 	char *striped = purple_markup_strip_html(message);

// 	std::string msg = striped;

// 	g_free(striped);

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	// Escape HTML characters.

	char *newline = purple_strdup_withhtml(msg);

	char *strip, *xhtml, *xhtml_linkified;

	purple_markup_html_to_xhtml(newline, &xhtml, &strip);

	xhtml_linkified = purple_markup_linkify(xhtml);

	std::string message_(strip);

	std::string xhtml_(xhtml_linkified);

	g_free(newline);

	g_free(xhtml);

	g_free(xhtml_linkified);

	g_free(strip);

	if (xhtml_ == message_) {

		xhtml_ = "";

	}

// 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");

	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);

}

static PurpleConversationUiOps conversation_ui_ops =

{

	NULL,

	NULL,

	NULL,//conv_write_chat,                              /* write_chat           */

	conv_write_im,             /* write_im             */

	NULL,//conv_write_conv,           /* write_conv           */

	NULL,//conv_chat_add_users,       /* chat_add_users       */

	NULL,//conv_chat_rename_user,     /* chat_rename_user     */

	NULL,//conv_chat_remove_users,    /* chat_remove_users    */

	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */

	NULL,//pidgin_conv_present_conversation, /* present              */

	NULL,//pidgin_conv_has_focus,            /* has_focus            */

	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */

	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */

	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */

	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */

	NULL,

	NULL,

	NULL,

	NULL

};

static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){

	PurpleAccount *account = purple_connection_get_account(gc);

	np->handleDisconnected(np->m_accounts[account], purple_account_get_username(account), (int) reason, text ? text : "");

}

static PurpleConnectionUiOps conn_ui_ops =

{

	NULL,

	NULL,

	NULL,//connection_disconnected,

	NULL,

	NULL,

	NULL,

	NULL,

	connection_report_disconnect,

	NULL,

	NULL,

	NULL

};

static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {

	std::string name(who);

	PurpleAccount *account = purple_connection_get_account(gc);

	GList *vcardEntries = purple_notify_user_info_get_entries(user_info);

	PurpleNotifyUserInfoEntry *vcardEntry;

	std::string firstName;

	std::string lastName;

	std::string fullName;

	std::string nickname;

	std::string header;

	std::string label;

	Swift::ByteArray photo;

	while (vcardEntries) {

		vcardEntry = (PurpleNotifyUserInfoEntry *)(vcardEntries->data);

		if (purple_notify_user_info_entry_get_label(vcardEntry) && purple_notify_user_info_entry_get_value(vcardEntry)){

			label = purple_notify_user_info_entry_get_label(vcardEntry);

			if (label == "Given Name" || label == "First Name") {

				firstName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label == "Family Name" || label == "Last Name") {

				lastName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label=="Nickname" || label == "Nick") {

				nickname = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label=="Full Name") {

				fullName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else {

				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry));

			}

		}

		vcardEntries = vcardEntries->next;

	}

	if (name == purple_account_get_username(account)) {

		const gchar *displayname = purple_connection_get_display_name(gc);

		if (!displayname) {

			displayname = purple_account_get_name_for_display(account);

		}

		if (displayname) {

			nickname = displayname;

		}

		// avatar

		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);

		if (avatar) {

			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);

			size_t len = purple_imgstore_get_size(avatar);

			if (len < 300000 && data) {

				photo = Swift::createByteArray(data, len);

			}

		}

	}

	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())

		fullName = firstName + " " + lastName;

	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);

	if (buddy && photo.size() == 0) {

		gsize len;

		PurpleBuddyIcon *icon = NULL;

		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());

		if (icon) {

			const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);

			// Sometimes libpurple returns really broken pointers here

			// They weren't able to do anything with that and I don't know what to do too,

			// so it's better to hack through it by not trying to forward really broken things...

			if (len < 300000 && data) {

				photo = Swift::createByteArray(data, len);

// 				const gchar *ext = (gchar*)purple_buddy_icon_get_extension(icon);

// 				if (ext) {

// 					std::string extension(ext);

// 					if (extension != "icon") {

// 						if (extension == "jpg") {

// 							extension = "jpeg";

// 						}

// 						photo->addChild( new Tag("TYPE", "image/" + extension) );

// 					}

// 				}

			}

		}

	}

	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, Swift::byteArrayToString(photo));

	np->m_vcards.erase(np->m_accounts[account] + name);

	return NULL;

}

static PurpleNotifyUiOps notifyUiOps =

{

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		notify_user_info,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL

};

static PurpleRequestUiOps requestUiOps =

{

	requestInput,

	NULL,

	requestAction,

	NULL,

	NULL,

	NULL, //requestClose,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void * accountRequestAuth(PurpleAccount *account, const char *remote_user, const char *id, const char *alias, const char *message, gboolean on_list, PurpleAccountRequestAuthorizationCb authorize_cb, PurpleAccountRequestAuthorizationCb deny_cb, void *user_data) {

	authRequest *req = new authRequest;

	req->authorize_cb = authorize_cb;

	req->deny_cb = deny_cb;

	req->user_data = user_data;

	req->account = account;

	req->who = remote_user;

	req->mainJID = np->m_accounts[account];

	np->m_authRequests[req->mainJID + req->who] = req;

	np->handleAuthorization(req->mainJID, req->who);

	return req;

}

static void accountRequestClose(void *data){

	authRequest *req = (authRequest *) data;

	np->m_authRequests.erase(req->mainJID + req->who);

}

static PurpleAccountUiOps accountUiOps =

{

	NULL,

	NULL,

	NULL,

	accountRequestAuth,

	accountRequestClose,

	NULL,

	NULL,

	NULL,

	NULL

};

static void transport_core_ui_init(void)

{

	purple_blist_set_ui_ops(&blistUiOps);

	purple_accounts_set_ui_ops(&accountUiOps);

	purple_notify_set_ui_ops(&notifyUiOps);

	purple_request_set_ui_ops(&requestUiOps);

// 	purple_xfers_set_ui_ops(getXferUiOps());

	purple_connections_set_ui_ops(&conn_ui_ops);

	purple_conversations_set_ui_ops(&conversation_ui_ops);

// #ifndef WIN32

// 	purple_dnsquery_set_ui_ops(getDNSUiOps());

// #endif

}

static PurpleCoreUiOps coreUiOps =

{

	NULL,

// 	debug_init,

	NULL,

	transport_core_ui_init,

	NULL,

	spectrum_ui_get_info,

	NULL,

	NULL,

	NULL

};

static void signed_on(PurpleConnection *gc, gpointer unused) {

	PurpleAccount *account = purple_connection_get_account(gc);

	np->handleConnected(np->m_accounts[account]);

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

	malloc_trim(0);

}

static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {

	std::string c("");

	std::string args(arg_s);

	args.erase(args.size() - 1);

	if (category) {

		c.append(category);

	}

	c.push_back(':');

	LOG4CXX_INFO(logger_libpurple, c << args);

}

/*

 * Ops....

 */

static PurpleDebugUiOps debugUiOps =

{

	printDebug,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyTyping(np->m_accounts[account], w);

}

static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyTyped(np->m_accounts[account], w);

}

static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyStoppedTyping(np->m_accounts[account], w);

}

static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleAttention(np->m_accounts[account], w, "");

}

static bool initPurple(Config &cfg) {

	bool ret;

	purple_util_set_user_dir("./");

	remove("./accounts.xml");

	remove("./blist.xml");

// 	if (m_configuration.logAreas & LOG_AREA_PURPLE)

		purple_debug_set_ui_ops(&debugUiOps);

	purple_core_set_ui_ops(&coreUiOps);

	purple_eventloop_set_ui_ops(getEventLoopUiOps());

	ret = purple_core_init("spectrum");

	if (ret) {

		static int blist_handle;

		static int conversation_handle;

		purple_set_blist(purple_blist_new());

		purple_blist_load();

		purple_prefs_load();