#include "utils.h"

#include "glib.h"

// win32/libc_interface.h defines its own socket(), read() and so on.

// We don't want to use it here.

#define _LIBC_INTERFACE_H_ 1

#include "purple.h"

#include <algorithm>

#include <iostream>

#include <fstream> 

#include "transport/NetworkPlugin.h"

#include "transport/Logging.h"

#include "transport/Config.h"

#include "geventloop.h"

// #include "valgrind/memcheck.h"

#if !defined(__FreeBSD__) && !defined(__APPLE__)

#include "malloc.h"

#endif

#include <algorithm>

#include "errno.h"

#include <boost/make_shared.hpp>

#ifdef WITH_LIBEVENT

#include <event.h>

#endif

#ifdef WIN32

#include "win32/win32dep.h"

#define close closesocket

#define ssize_t SSIZE_T

#include <process.h>

#define getpid _getpid

#endif

#include "purple_defs.h"

DEFINE_LOGGER(logger_libpurple, "libpurple");

DEFINE_LOGGER(logger, "backend");

int main_socket;

static int writeInput;

bool firstPing = true;

using namespace Transport;

template <class T> T fromString(const std::string &str) {

	T i;

	std::istringstream os(str);

	os >> i;

	return i;

}

template <class T> std::string stringOf(T object) {

	std::ostringstream os;

	os << object;

	return (os.str());

}

static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {

    std::stringstream ss(s);

    std::string item;

    while(std::getline(ss, item, delim)) {

        elems.push_back(item);

    }

    return elems;

}

static std::vector<std::string> split(const std::string &s, char delim) {

    std::vector<std::string> elems;

    return split(s, delim, elems);

}

static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);

class SpectrumNetworkPlugin;

boost::shared_ptr<Config> config;

SpectrumNetworkPlugin *np;

static std::string host;

static int port = 10000;

struct FTData {

	unsigned long id;

	unsigned long timer;

	bool paused;

};

struct NodeCache {

	PurpleAccount *account;

	std::map<PurpleBlistNode *, int> nodes;

	int timer;

};

bool caching = true;

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

static gboolean ft_ui_ready(void *data) {

	PurpleXfer *xfer = (PurpleXfer *) data;

	FTData *ftdata = (FTData *) xfer->ui_data;

	ftdata->timer = 0;

	purple_xfer_ui_ready_wrapped((PurpleXfer *) data);

	return FALSE;

}

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 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 if (primaryString == "Authorization Denied Message:") {

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

			((PurpleRequestInputCb) ok_cb)(user_data, "Authorization denied.");

			return NULL;

		}

		else {

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

		}

	}

	else if (title) {

		std::string titleString(title);

		if (titleString == "Xfire Invitation 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. title=" << titleString);

		}

	}

	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 (t == "Plaintext Authentication") {

		LOG4CXX_INFO(logger,  "Rejecting plaintext authentification");

		va_arg(actions, char *);

		va_arg(actions, GCallback);

		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_wrapped(m_buddy)) {

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

	}

	else {

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

	}

	return alias;

}

class SpectrumNetworkPlugin : public NetworkPlugin {

	public:

		SpectrumNetworkPlugin() : NetworkPlugin() {

		}

		void handleExitRequest() {

			LOG4CXX_INFO(logger, "Exiting...");

			exit(0);

		}

		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {

			name = legacyName;

			protocol = CONFIG_STRING(config, "service.protocol");

			if (protocol == "any") {

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

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

			}

		}

		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {

			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_wrapped(account, (guchar *) contents, length);

			}

		}

		void setDefaultAccountOptions(PurpleAccount *account) {

			int i = 0;

			Config::SectionValuesCont purpleConfigValues = config->getSectionValues("purple");

			BOOST_FOREACH ( const Config::SectionValuesCont::value_type & keyItem, purpleConfigValues )

			{

				std::string key = keyItem.first;

				std::string strippedKey = boost::erase_first_copy(key, "purple.");

				if (strippedKey == "fb_api_key" || strippedKey == "fb_api_secret") {

					purple_account_set_bool_wrapped(account, "auth_fb", TRUE);

 				}

				PurplePlugin *plugin = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));

				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);

				bool found = false;

				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {

					PurpleAccountOption *option = (PurpleAccountOption *) l->data;

					PurplePrefType type = purple_account_option_get_type_wrapped(option);

					std::string key2(purple_account_option_get_setting_wrapped(option));

					if (strippedKey != key2) {

						continue;

					}

					found = true;

					switch (type) {

						case PURPLE_PREF_BOOLEAN:

							purple_account_set_bool_wrapped(account, strippedKey.c_str(), fromString<bool>(keyItem.second.as<std::string>()));

							break;

						case PURPLE_PREF_INT:

							purple_account_set_int_wrapped(account, strippedKey.c_str(), fromString<int>(keyItem.second.as<std::string>()));

							break;

						case PURPLE_PREF_STRING:

						case PURPLE_PREF_STRING_LIST:

							purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());

							break;

						default:

							continue;

					}

					break;

				}

				if (!found) {

					purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());

				}

				i++;

			}

			char* contents;

			gsize length;

			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);

			if (ret) {

				purple_account_set_int_wrapped(account, "version", fromString<int>(std::string(contents, length)));

			}

			if (CONFIG_STRING(config, "service.protocol") == "prpl-novell") {

				std::string username(purple_account_get_username_wrapped(account));

				std::vector <std::string> u = split(username, '@');

				purple_account_set_username_wrapped(account, (const char*) u.front().c_str());

				std::vector <std::string> s = split(u.back(), ':'); 

				purple_account_set_string_wrapped(account, "server", s.front().c_str());

				purple_account_set_int_wrapped(account, "port", atoi(s.back().c_str()));  

			}

			if (!CONFIG_STRING_DEFAULTED(config, "proxy.type", "").empty()) {

				PurpleProxyInfo *info = purple_proxy_info_new_wrapped();

				if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "http") {

					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_HTTP);

				}

				else if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "socks4") {

					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_SOCKS4);

				}

				else if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "socks5") {

					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_SOCKS5);

				}

				else {

					LOG4CXX_ERROR(logger, "Unknown proxy.type " << CONFIG_STRING_DEFAULTED(config, "proxy.type", ""));

				}

				info->username = NULL;

				info->password = NULL;

				purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_SOCKS5);

				purple_proxy_info_set_host_wrapped(info, CONFIG_STRING_DEFAULTED(config, "proxy.host", "").c_str());

				if (CONFIG_INT_DEFAULTED(config, "proxy.port", 0)) {

					purple_proxy_info_set_port_wrapped(info, CONFIG_INT_DEFAULTED(config, "proxy.port", 0));

				}

				if (!CONFIG_STRING_DEFAULTED(config, "proxy.username", "").empty()) {

					purple_proxy_info_set_username_wrapped(info, CONFIG_STRING_DEFAULTED(config, "proxy.username", "").c_str());

				}

				if (!CONFIG_STRING_DEFAULTED(config, "proxy.password", "").empty()) {

					purple_proxy_info_set_password_wrapped(info, CONFIG_STRING_DEFAULTED(config, "proxy.password", "").c_str());

				}

				purple_account_set_proxy_info_wrapped(account, info);

			}

		}

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

			PurpleAccount *account = NULL;

			std::string name;

			std::string protocol;

			getProtocolAndName(legacyName, name, protocol);

			if (password.empty() && CONFIG_STRING(config, "service.protocol") != "prpl-telegram") {

				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");

				np->handleDisconnected(user, 1, "Empty password.");

				return;

			}

			if (!purple_find_prpl_wrapped(protocol.c_str())) {

				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");

				np->handleDisconnected(user, 1, "Invalid protocol " + protocol);

				return;

			}

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

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

				if (m_accounts.find(account) != m_accounts.end() && m_accounts[account] != user) {

					LOG4CXX_INFO(logger, "Account '" << name << "' is already used by '" << m_accounts[account] << "'");

					np->handleDisconnected(user, 1, "Account '" + name + "' is already used by '" + m_accounts[account] + "'");

					return;

				}

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

			}