#include "utils.h"

#include "glib.h"

#include "purple.h"

#include <algorithm>

#include <iostream>

#include "transport/networkplugin.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 "log4cxx/helpers/transcoder.h"

// #include "valgrind/memcheck.h"

#include "malloc.h"

#include <algorithm>

#include "errno.h"

#ifdef WITH_LIBEVENT

#include <event.h>

#endif

using namespace log4cxx;

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

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

int main_socket;

static int writeInput;

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 void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);

class SpectrumNetworkPlugin;

GKeyFile *keyfile;

SpectrumNetworkPlugin *np;

static std::string replaceAll(

  std::string result,

  const std::string& replaceWhat,

  const std::string& replaceWithWhat)

{

  while(1)

  {

	const int pos = result.find(replaceWhat);

	if (pos==-1) break;

	result.replace(pos,replaceWhat.size(),replaceWithWhat);

  }

  return result;

}

static std::string KEYFILE_STRING(const std::string &cat, const std::string &key, const std::string &def = "") {

	gchar *str = g_key_file_get_string(keyfile, cat.c_str(), key.c_str(), 0);

	if (!str) {

		return def;

	}

	std::string ret(str);

	g_free(str);

	if (ret.find("#") != std::string::npos) {

		ret = ret.substr(0, ret.find("#"));

		while(*(ret.end() - 1) == ' ') {

			ret.erase(ret.end() - 1);

		}

	}

	if (ret.find("$jid") != std::string::npos) {

		std::string jid = KEYFILE_STRING("service", "jid");

		ret = replaceAll(ret, "$jid", jid);

	}

	return ret;

}

#define KEYFILE_BOOL(CAT, KEY) g_key_file_get_boolean(keyfile, CAT, KEY, 0)

static gchar *host = NULL;

static int port = 10000;

struct FTData {

	unsigned long id;

	unsigned long timer;

	bool paused;

};

static GOptionEntry options_entries[] = {

	{ "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 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((PurpleXfer *) data);

	return FALSE;

}

struct authRequest {

	PurpleAccountRequestAuthorizationCb authorize_cb;

	PurpleAccountRequestAuthorizationCb deny_cb;

	void *user_data;