using namespace log4cxx;

static LoggerPtr logger_libpurple = Logger::getLogger("backend.libpurple");

static LoggerPtr logger = Logger::getLogger("backend");

using namespace Transport;

class SpectrumNetworkPlugin;

SpectrumNetworkPlugin *np;

static gboolean nodaemon = FALSE;

static gchar *logfile = NULL;

static gchar *lock_file = NULL;

static gchar *host = NULL;

static int port = 10000;

static gboolean ver = FALSE;

static gboolean list_purple_settings = FALSE;

static GOptionEntry options_entries[] = {

	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },

	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },

	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },

	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },

	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },

	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },

	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },

	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }

};

static GHashTable *ui_info = NULL;

static GHashTable *spectrum_ui_get_info(void)

{

	if(NULL == ui_info) {

		ui_info = g_hash_table_new(g_str_hash, g_str_equal);

		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));

		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));

		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));

		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));

		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));

		/*

		 * This is the client key for "Pidgin."  It is owned by the AIM

		 * account "markdoliner."  Please don't use this key for other

		 * applications.  You can either not specify a client key, in

		 * which case the default "libpurple" key will be used, or you

		 * can register for your own client key at

		 * http://developer.aim.com/manageKeys.jsp

		 */

		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));

		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));

		/*

		 * This is the distid for Pidgin, given to us by AOL.  Please

		 * don't use this for other applications.  You can just not

		 * specify a distid and libpurple will use a default.

		 */

		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));

		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));

	}

	return ui_info;

}

struct authRequest {

	PurpleAccountRequestAuthorizationCb authorize_cb;

	PurpleAccountRequestAuthorizationCb deny_cb;

	void *user_data;

	std::string who;

	PurpleAccount *account;

	std::string mainJID;	// JID of user connected with this request

};

static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {

	if (primary) {

		std::string primaryString(primary);

		if (primaryString == "Authorization Request Message:") {

			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");

			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");

			return NULL;

		}

		else {

			LOG4CXX_WARN(logger, "Unhandled request input. primary=" << primaryString);

		}

	}

	else {

		LOG4CXX_WARN(logger, "Request input without primary string");

	}

	return NULL;

}

static void *requestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data, size_t action_count, va_list actions){

	std::string t(title ? title : "NULL");

	if (t == "SSL Certificate Verification") {

		LOG4CXX_INFO(logger,  "accepting SSL certificate");

		va_arg(actions, char *);

		((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);

	}

	else {

		if (title) {

			std::string headerString(title);

			LOG4CXX_INFO(logger,  "header string: " << headerString);

			if (headerString == "SSL Certificate Verification") {

				va_arg(actions, char *);

				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);

			}

		}

	}

	return NULL;

}

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

	std::string alias;

	PurpleContact *contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(m_buddy)->parent);

	if (contact && contact->alias) {

		alias = contact->alias;

	}

	else if (purple_buddy_get_alias(m_buddy)) {

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

	}

	else {

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

	}

	return alias;

}

class SpectrumNetworkPlugin : public NetworkPlugin {

	public:

		SpectrumEventLoop *m_loop;

		SpectrumNetworkPlugin(Config *config, SpectrumEventLoop *loop, const std::string &host, int port) : NetworkPlugin(loop, host, port) {

			this->config = config;

			m_loop = loop;

		}

		void handleExit() {

			m_loop->stop();

		}

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

			PurpleAccount *account = NULL;

			std::string name = legacyName;

			std::string protocol = CONFIG_STRING(config, "service.protocol");

			if (CONFIG_STRING(config, "service.protocol") == "any") {

				protocol = name.substr(0, name.find("."));

				name = name.substr(name.find(".") + 1);

			}

			LOG4CXX_INFO(logger,  "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");

			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL){

// 				Log(user, "this account already exists");

				account = purple_accounts_find(name.c_str(), protocol.c_str());

// 				User *u = (User *) account->ui_data;

// 				if (u && u != user) {

// 					Log(userInfo.jid, "This account is already connected by another jid " << user->getJID());

// 					return;

// 				}

			}

			else {

// 				Log(user, "creating new account");

				account = purple_account_new(name.c_str(), protocol.c_str());

				purple_accounts_add(account);

			}

			m_sessions[user] = account;

			// Default avatar

			char* contents;

			gsize length;

			gboolean ret = false;

			if (!CONFIG_STRING(config, "backend.avatars_directory").empty()) {

				std::string f = CONFIG_STRING(config, "backend.avatars_directory") + "/" + legacyName;

				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);

			}

			if (!CONFIG_STRING(config, "backend.default_avatar").empty() && !ret) {

				ret = g_file_get_contents (CONFIG_STRING(config, "backend.default_avatar").c_str(),

											&contents, &length, NULL);

			}

			if (ret) {

				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);

			}

			purple_account_set_password(account, password.c_str());

			purple_account_set_enabled(account, "spectrum", TRUE);

			purple_account_set_bool(account, "custom_smileys", FALSE);

			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);

			if (status_type != NULL) {

				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);

			}

			m_accounts[account] = user;

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

// 				VALGRIND_DO_LEAK_CHECK;

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

				purple_notify_close_with_handle(account);

				purple_request_close_with_handle(account);

				purple_accounts_remove(account);

				GSList *buddies = purple_find_buddies(account, NULL);

				while(buddies) {

					PurpleBuddy *b = (PurpleBuddy *) buddies->data;

					purple_blist_remove_buddy(b);

					buddies = g_slist_delete_link(buddies, buddies);

				}

				/* Remove any open conversation for this account */

				for (GList *it = purple_get_conversations(); it; ) {

					PurpleConversation *conv = (PurpleConversation *) it->data;

					it = it->next;

					if (purple_conversation_get_account(conv) == account)

						purple_conversation_destroy(conv);

				}

				/* Remove this account's pounces */

					// purple_pounce_destroy_all_by_account(account);

				/* This will cause the deletion of an old buddy icon. */

				purple_buddy_icons_set_account_icon(account, NULL, 0);

				purple_account_destroy(account);

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

				malloc_trim(0);

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

					case Swift::StatusShow::Away: {

						st = PURPLE_STATUS_AWAY;

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))

							st = PURPLE_STATUS_EXTENDED_AWAY;

						else

							st = PURPLE_STATUS_AWAY;

						break;

					}

					case Swift::StatusShow::DND: {

						st = PURPLE_STATUS_UNAVAILABLE;

						break;

					}

					case Swift::StatusShow::XA: {

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))

							st = PURPLE_STATUS_AWAY;

						else

							st = PURPLE_STATUS_EXTENDED_AWAY;

						break;

					}

					case Swift::StatusShow::None: {

						st = PURPLE_STATUS_OFFLINE;

						break;

					}

					default:

						st = PURPLE_STATUS_AVAILABLE;

						break;

				}

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

				std::string markup(_markup);

				g_free(_markup);

				// we are already connected so we have to change status

				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);

				if (status_type != NULL) {

					// send presence to legacy network

					if (!markup.empty()) {

						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);

					}

					else {

						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);

					}

				}

			}

		}

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

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

				}

				if (xhtml.empty()) {

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

					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);

					g_free(_markup);

				}

				else {

					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());

				}

			}

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

				std::string name = legacyName;

				if (CONFIG_STRING(config, "service.protocol") == "any" && legacyName.find("prpl-") == 0) {

					name = name.substr(name.find(".") + 1);

				}

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

				m_vcards[user + name] = id;

			}

		}

		void handleVCardUpdatedRequest(const std::string &user, const std::string &p) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				gssize size = p.size();

				// this will be freed by libpurple

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

				memcpy(photo, p.c_str(), size);

#ifdef WITH_IMAGEMAGICK

				if (size != 0) {

					PurplePlugin *plugin = purple_find_prpl(Transport::instance()->protocol()->protocol().c_str());

					PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);

					if (prpl_info->icon_spec.format == NULL) {

						g_free(photo);

						return;

					}

					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 {