#include "glib.h"

#include <iostream>

#include "transport/config.h"

#include "transport/logging.h"

#include "transport/transport.h"

#include "transport/usermanager.h"

#include "transport/memoryusage.h"

#include "transport/sqlite3backend.h"

#include "transport/userregistration.h"

#include "transport/user.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "transport/conversation.h"

#include "transport/networkplugin.h"

#include <boost/filesystem.hpp>

#include "sys/wait.h"

#include "sys/signal.h"

// #include "valgrind/memcheck.h"

#ifndef __FreeBSD__

#include "malloc.h"

#endif

#include <dbus-1.0/dbus/dbus-glib-lowlevel.h>

DEFINE_LOGGER(logger, "backend");

using namespace Transport;

class SpectrumNetworkPlugin;

#define GET_RESPONSE_DATA(RESP, DATA) ((RESP.find(std::string(DATA) + " ") != std::string::npos) ? RESP.substr(RESP.find(DATA) + strlen(DATA) + 1) : "");

#define GET_PROPERTY(VAR, OBJ, WHICH, PROP) std::string VAR = sk->send_command(std::string("GET ") + OBJ + " " + WHICH + " " + PROP); \

					try {\

						VAR = GET_RESPONSE_DATA(VAR, PROP);\

					}\

					catch (std::out_of_range& oor) {\

						VAR="";\

					}

SpectrumNetworkPlugin *np;

int m_sock;

static int writeInput;

static std::string host;

static int port = 10000;

DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data);

static pbnetwork::StatusType getStatus(const std::string &st) {

	pbnetwork::StatusType status = pbnetwork::STATUS_ONLINE;

	if (st == "SKYPEOUT" || st == "OFFLINE") {

		status = pbnetwork::STATUS_NONE;

	}

	else if (st == "DND") {

		status = pbnetwork::STATUS_DND;

	}

	else if (st == "NA") {

		status = pbnetwork::STATUS_XA;

	}

	else if (st == "AWAY") {

		status = pbnetwork::STATUS_AWAY;

	}

	return status;

}

class Skype {

	public:

		Skype(const std::string &user, const std::string &username, const std::string &password);

		~Skype() { LOG4CXX_INFO(logger, "Skype instance desctuctor"); logout(); }

		void login();

		void logout();

		std::string send_command(const std::string &message);

		const std::string &getUser() {

			return m_user;

		}

		const std::string &getUsername() {

			return m_username;

		}

		bool createDBusProxy();

		bool loadSkypeBuddies();

		int getPid() {

			return (int) m_pid;

		}

	private:

		std::string m_username;

		std::string m_password;

		GPid m_pid;

		DBusGConnection *m_connection;

		DBusGProxy *m_proxy;

		std::string m_user;

		int m_timer;

		int m_counter;

		int fd_output;

};

class SpectrumNetworkPlugin : public NetworkPlugin {

	public:

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

			this->config = config;

			LOG4CXX_INFO(logger, "Starting the backend.");

		}

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/filetransfermanager.h"

#include "transport/usermanager.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "transport/statsresponder.h"

#include "transport/usersreconnecter.h"

#include "transport/util.h"

#include "transport/gatewayresponder.h"

#include "transport/logging.h"

#include "transport/discoitemsresponder.h"

#include "transport/adhocmanager.h"

#include "transport/settingsadhoccommand.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include "sys/stat.h"

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#ifndef __FreeBSD__

#include <malloc.h>

#endif

#else

#include <process.h>

#define getpid _getpid

#include "win32/ServiceWrapper.h"

#endif

#include <sys/stat.h>

using namespace Transport;

using namespace Transport::Util;

DEFINE_LOGGER(logger, "Spectrum");

Swift::SimpleEventLoop *eventLoop_ = NULL;

Component *component_ = NULL;

UserManager *userManager_ = NULL;

Config *config_ = NULL;

static void stop_spectrum() {

	userManager_->removeAllUsers(false);

	component_->stop();

	eventLoop_->stop();

}

static void spectrum_sigint_handler(int sig) {

	eventLoop_->postEvent(&stop_spectrum);

}

static void spectrum_sigterm_handler(int sig) {

	eventLoop_->postEvent(&stop_spectrum);

}

#ifdef WIN32

BOOL spectrum_control_handler( DWORD fdwCtrlType ) { 

	if (fdwCtrlType == CTRL_C_EVENT || fdwCtrlType == CTRL_CLOSE_EVENT) {

		eventLoop_->postEvent(&stop_spectrum);

		return TRUE;

	}

	return FALSE;

} 

#endif

static void removeOldIcons(std::string iconDir) {

	std::vector<std::string> dirs;

	dirs.push_back(iconDir);

	boost::thread thread(boost::bind(Util::removeEverythingOlderThan, dirs, time(NULL) - 3600*24*14));

}

#ifndef WIN32

static void daemonize(const char *cwd, const char *lock_file) {

	pid_t pid, sid;

	FILE* lock_file_f;

	char process_pid[20];

	/* already a daemon */

	if ( getppid() == 1 ) return;

	/* Fork off the parent process */

	pid = fork();

	if (pid < 0) {

		exit(1);

	}

	/* If we got a good PID, then we can exit the parent process. */

	if (pid > 0) {

		if (lock_file) {

			/* write our pid into it & close the file. */

			lock_file_f = fopen(lock_file, "w+");

			if (lock_file_f == NULL) {

				std::cerr << "Cannot create lock file " << lock_file << ". Exiting\n";

				exit(1);