}

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

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

					purple_blist_alias_buddy(buddy, alias.c_str());

					purple_blist_server_alias_buddy(buddy, alias.c_str());

					serv_alias_buddy(buddy);

				}

				else {

					std::cout << "ADDING NEW BUDDY\n";

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

				}

			}

		}

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

			}

		}

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

		}

		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;

	groups.push_back(purple_group_get_name(purple_buddy_get_group(m_buddy)) ? std::string(purple_group_get_name(purple_buddy_get_group(m_buddy))) : std::string("Buddies"));

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

}

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 *message, 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);

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

}

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

				firstName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

				lastName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

				nickname = purple_notify_user_info_entry_get_value(vcardEntry);

			}

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

				fullName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else {

				std::cout << "UNHANDLED VCARD LABEL '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry) << "\n";

			}

		}

		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;

		}

	}

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

		fullName = firstName + " " + lastName;

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

	if (buddy) {

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

}

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

	std::string c("[LIBPURPLE");

	if (category) {

		c.push_back('/');

		c.append(category);

	}

	c.push_back(']');

	std::cout << c << " " << arg_s;

}

/*

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

		/* Good default preferences */

		/* The combination of these two settings mean that libpurple will never

		 * (of its own accord) set all the user accounts idle.

		 */

		purple_prefs_set_bool("/purple/away/away_when_idle", false);

		/*

		 * This must be set to something not "none" for idle reporting to work

		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is

		 * okay for now.

		 */

		purple_prefs_set_string("/purple/away/idle_reporting", "system");

		/* Disable all logging */

		purple_prefs_set_bool("/purple/logging/log_ims", false);

		purple_prefs_set_bool("/purple/logging/log_chats", false);

		purple_prefs_set_bool("/purple/logging/log_system", false);

// 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);

		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);

		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);

		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);

		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);

		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);

// 

// 		purple_commands_init();

	}

	return ret;

}

int main(int argc, char **argv) {

	GError *error = NULL;

	GOptionContext *context;

	context = g_option_context_new("config_file_name or profile name");

	g_option_context_add_main_entries(context, options_entries, "");

	if (!g_option_context_parse (context, &argc, &argv, &error)) {

		std::cout << "option parsing failed: " << error->message << "\n";

		return -1;

	}

	if (ver) {

// 		std::cout << VERSION << "\n";

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

		g_option_context_free(context);

		return 0;

	}

	if (argc != 2) {

#ifdef WIN32

		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";

#else

#if GLIB_CHECK_VERSION(2,14,0)

	std::cout << g_option_context_get_help(context, FALSE, NULL);

#else

	std::cout << "Usage: spectrum <configuration_file.cfg>\n";

	std::cout << "See \"man spectrum\" for more info.\n";

#endif

#endif

	}

	else {

#ifndef WIN32

// 		signal(SIGPIPE, SIG_IGN);

// 

// 		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {

// 			std::cout << "SIGCHLD handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

// 		}

// 

// 		if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {

// 			std::cout << "SIGINT handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

// 		}

// 

// 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

// 			std::cout << "SIGTERM handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

// 		}

// 

// 		struct sigaction sa;

// 		memset(&sa, 0, sizeof(sa)); 

// 		sa.sa_handler = spectrum_sighup_handler;

// 		if (sigaction(SIGHUP, &sa, NULL)) {

// 			std::cout << "SIGHUP handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

//		}

#endif

		Config config;

		if (!config.load(argv[1])) {

			std::cout << "Can't open " << argv[1] << " configuration file.\n";

			return 1;

		}

		initPurple(config);

		SpectrumEventLoop eventLoop;

		np = new SpectrumNetworkPlugin(&config, &eventLoop, host, port);