#include "transport/rostermanager.h"

#include "transport/conversation.h"

#include "transport/networkplugin.h"

#include "spectrumeventloop.h"

#include "geventloop.h"

#include "log4cxx/logger.h"

#include "log4cxx/consoleappender.h"

#include "log4cxx/patternlayout.h"

#include "log4cxx/propertyconfigurator.h"

#include "log4cxx/helpers/properties.h"

#include "log4cxx/helpers/fileinputstream.h"

#include "sys/wait.h"

#include "sys/signal.h"

// #include "valgrind/memcheck.h"

#include "malloc.h"

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

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

				}

				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;

[service]

jid = localhost

password = secret

server = 127.0.0.1

port = 5222

server_mode = 1

backend_host=localhost # < this option doesn't work yet

backend_port=10001

admin_username=admin

admin_password=test

#idle_reconnect_time=10

#cert= #patch to PKCS#12 certificate

#cert_password= #password to that certificate if any

users_per_backend=10

backend=../../backends/libpurple/spectrum_libpurple_backend

#backend=../../backends/libircclient-qt/spectrum_libircclient-qt_backend

#protocol=prpl-msn

protocol=any

#protocol=prpl-icq

[backend]

[logging]

#config=logging.cfg # log4cxx/log4j logging configuration file

#backend_config=backend_logging.cfg # log4cxx/log4j logging configuration file for backends

[database]

#type = mysql # or "none" without database backend

database = test.sql

prefix=icq

namespace Transport {

bool Config::load(const std::string &configfile, boost::program_options::options_description &opts) {

	m_unregistered.clear();

	std::ifstream ifs(configfile.c_str());

	if (!ifs.is_open())

		return false;

	opts.add_options()

		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")

		("service.server", value<std::string>()->default_value(""), "Server to connect to")

		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")

		("service.port", value<int>()->default_value(0), "Port the server is listening on")

		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

		("service.protocol", value<std::string>()->default_value(""), "Protocol")

		("service.allowed_servers", value<std::string>()->default_value(""), "Only users from these servers can connect")

		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")

		("service.users_per_backend", value<int>()->default_value(100), "Number of users per one legacy network backend")

		("service.backend_host", value<std::string>()->default_value("localhost"), "Host to bind backend server to")

		("service.backend_port", value<std::string>()->default_value("10000"), "Port to bind backend server to")

		("service.cert", value<std::string>()->default_value(""), "PKCS#12 Certificate.")

		("service.cert_password", value<std::string>()->default_value(""), "PKCS#12 Certificate password.")

		("service.admin_username", value<std::string>()->default_value(""), "Administrator username.")

		("service.admin_password", value<std::string>()->default_value(""), "Administrator password.")

		("service.reuse_old_backends", value<bool>()->default_value(true), "True if Spectrum should use old backends which were full in the past.")

		("service.idle_reconnect_time", value<int>()->default_value(4*3600), "Time in seconds after which idle users are reconnected to let their backend die.")

		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")

		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")

		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")

		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")

		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")

		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")

		("registration.instructions", value<std::string>()->default_value(""), "Instructions showed to user in registration form")

		("registration.username_field", value<std::string>()->default_value(""), "Label for username field")

		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")

		("registration.encoding", value<std::string>()->default_value("en"), "Default encoding in registration form")

		("database.type", value<std::string>()->default_value("none"), "Database type.")

		("database.database", value<std::string>()->default_value(""), "Database used to store data")

		("database.server", value<std::string>()->default_value("localhost"), "Database server.")

		("database.user", value<std::string>()->default_value(""), "Database user.")

		("database.password", value<std::string>()->default_value(""), "Database Password.")

		("database.port", value<int>()->default_value(0), "Database port.")

		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")

		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")

		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")

		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")

		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")

	;

	parsed_options parsed = parse_config_file(ifs, opts, true);

	BOOST_FOREACH(option opt, parsed.options) {

		if (opt.unregistered) {

			m_unregistered[opt.string_key] = opt.value[0];

		}

	}

	store(parsed, m_variables);

	notify(m_variables);

	m_file = configfile;

	onConfigReloaded();

	return true;

}

bool Config::load(const std::string &configfile) {

	options_description opts("Transport options");

	return load(configfile, opts);

}

bool Config::reload() {

	if (m_file.empty()) {

		return false;

	}

	return load(m_file);

}

}