cmake_minimum_required(VERSION 2.6)

project(libtransport)

set(CMAKE_MODULE_PATH "cmake_modules")

set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(cppunit)

set(sqlite3_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(sqlite3)

set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(mysql)

set(purple_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(purple)

set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(glib)

set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(event)

set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Swiften REQUIRED)

set(Boost_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Boost COMPONENTS date_time system filesystem regex thread signals REQUIRED)

message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")

set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Protobuf REQUIRED)

set(IRCClientQt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(IRCClientQt)

set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(log4cxx)

find_package(Doxygen)

INCLUDE(FindQt4)

FIND_PACKAGE(Qt4 COMPONENTS QtCore)

# ADD_DEFINITIONS(${SWIFTEN_CFLAGS})

ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)

message("  Supported features")

message("-----------------------")

if (SQLITE3_FOUND)

	ADD_DEFINITIONS(-DWITH_SQLITE)

	include_directories(${SQLITE3_INCLUDE_DIR})

	message("SQLite3           : yes")

else (SQLITE3_FOUND)

	set(SQLITE3_LIBRARIES "")

	message("SQLite3           : no")

endif (SQLITE3_FOUND)

if (MYSQL_FOUND)

	ADD_DEFINITIONS(-DWITH_MYSQL)

	include_directories(${MYSQL_INCLUDE_DIR})

	message("MySQL             : yes")

else (MYSQL_FOUND)

	set(MYSQL_LIBRARIES "")

	message("MySQL             : no (install mysql-devel)")

endif (MYSQL_FOUND)

if (PROTOBUF_FOUND)

	ADD_DEFINITIONS(-DWITH_PROTOBUF)

	include_directories(${PROTOBUF_INCLUDE_DIRS})

	message("Network plugins   : yes")

	if(PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR)

		message("Libpurple plugin  : yes")

		include_directories(${PURPLE_INCLUDE_DIR})

		include_directories(${GLIB2_INCLUDE_DIR})

	else()

		message("Libpurple plugin  : no (install libpurple)")

	endif()

	if(IRC_FOUND)

		ADD_DEFINITIONS(-DIRC_SHARED)

		message("IRC plugin        : yes")

		include_directories(${IRC_INCLUDE_DIR})

		include(${QT_USE_FILE})

	else()

		message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")

	endif()

	message("Frotz plugin      : yes")

else()

	message("Network plugins   : no (install libprotobuf-dev)")

	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")

	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")

	message("Frotz plugin      : no (install libprotobuf-dev)")

endif()

if (LOG4CXX_FOUND)

	message("Logging           : yes")

	include_directories(${LOG4CXX_INCLUDE_DIR})

else()

	message(FATAL_ERROR "Logging           : no (install log4cxx-devel)")

endif()

if(CMAKE_BUILD_TYPE MATCHES Debug)

	ADD_DEFINITIONS(-O0)

	ADD_DEFINITIONS(-ggdb)

	ADD_DEFINITIONS(-DDEBUG)

	ADD_DEFINITIONS(-Wall)

	ADD_DEFINITIONS(-W)

	ADD_DEFINITIONS(-Wcast-align)

	ADD_DEFINITIONS(-Wextra -Wno-sign-compare -Wno-unused-parameter)

	ADD_DEFINITIONS(-Winit-self)

	ADD_DEFINITIONS(-Wmissing-declarations)

	ADD_DEFINITIONS(-Wpointer-arith)

	ADD_DEFINITIONS(-Wreorder)

	ADD_DEFINITIONS(-Woverloaded-virtual)

	ADD_DEFINITIONS(-Wsign-promo)

	ADD_DEFINITIONS(-Wundef -Wunused)

	message("Debug             : yes")

else(CMAKE_BUILD_TYPE MATCHES Debug)

	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")

endif(CMAKE_BUILD_TYPE MATCHES Debug)

SET(TRANSPORT_VERSION 2.0)

SET(PROJECT_VERSION 2.0)

include_directories(include)

include_directories(${EVENT_INCLUDE_DIRS})

include_directories(${SWIFTEN_INCLUDE_DIR})

include_directories(${Boost_INCLUDE_DIRS})

ADD_SUBDIRECTORY(src)

ADD_SUBDIRECTORY(include)

#ADD_SUBDIRECTORY(examples)

ADD_SUBDIRECTORY(spectrum)

ADD_SUBDIRECTORY(backends)

#ADD_SUBDIRECTORY(tests)

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "transport/util.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/filesystem.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include <pwd.h>

#include <grp.h>

#else

#include <Windows.h>

#include <tchar.h>

#endif

#include "log4cxx/logger.h"

#include "log4cxx/patternlayout.h"

#include "log4cxx/propertyconfigurator.h"

#include "log4cxx/consoleappender.h"

#include "libgen.h"

using namespace log4cxx;

using namespace Transport;

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

Swift::SimpleEventLoop *eventLoop_ = NULL;

Component *component_ = NULL;

UserManager *userManager_ = NULL;

static void stop_spectrum() {

	userManager_->removeAllUsers();

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

}

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

		exit(0);

	}

	/* At this point we are executing as the child process */

	/* Change the file mode mask */

	umask(0);

	/* Create a new SID for the child process */

	sid = setsid();

	if (sid < 0) {

		exit(1);

	}

	/* Change the current working directory.  This prevents the current

		directory from being locked; hence not being able to remove it. */

	if ((chdir(cwd)) < 0) {

		exit(1);

	}

	if (lock_file) {

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

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

		if (lock_file_f == NULL) {

			std::cout << "EE cannot create lock file " << lock_file << ". Exiting\n";

			exit(1);

		}

		sprintf(process_pid,"%d\n",getpid());

		if (fwrite(process_pid,1,strlen(process_pid),lock_file_f) < strlen(process_pid)) {

			std::cout << "EE cannot write to lock file " << lock_file << ". Exiting\n";

			exit(1);

		}

		fclose(lock_file_f);

	}

	if (freopen( "/dev/null", "r", stdin) == NULL) {

		std::cout << "EE cannot open /dev/null. Exiting\n";

		exit(1);

	}

}

#endif

int main(int argc, char **argv)

{

	Config config;

	boost::program_options::variables_map vm;