#include "transport/transport.h"

#include "transport/filetransfermanager.h"

#include "transport/usermanager.h"

#include "transport/logger.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);

}

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

			}

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

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

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

				exit(1);

			}

			fclose(lock_file_f);

		}

		exit(0);

	}

	/* 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 (freopen( "/dev/null", "r", stdin) == NULL) {

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

		exit(1);

	}

}

#endif

int mainloop() {

#ifndef WIN32

	mode_t old_cmask = umask(0007);

#endif

	Logging::initMainLogging(config_);

#ifndef WIN32

	if (!CONFIG_STRING(config_, "service.group").empty() ||!CONFIG_STRING(config_, "service.user").empty() ) {

		struct rlimit limit;

		getrlimit(RLIMIT_CORE, &limit);

		if (!CONFIG_STRING(config_, "service.group").empty()) {

			struct group *gr;

			if ((gr = getgrnam(CONFIG_STRING(config_, "service.group").c_str())) == NULL) {

				std::cerr << "Invalid service.group name " << CONFIG_STRING(config_, "service.group") << "\n";

				return 1;

			}

			if (((setgid(gr->gr_gid)) != 0) || (initgroups(CONFIG_STRING(config_, "service.user").c_str(), gr->gr_gid) != 0)) {

				std::cerr << "Failed to set service.group name " << CONFIG_STRING(config_, "service.group") << " - " << gr->gr_gid << ":" << strerror(errno) << "\n";

				return 1;

			}

		}

		if (!CONFIG_STRING(config_, "service.user").empty()) {

			struct passwd *pw;

			if ((pw = getpwnam(CONFIG_STRING(config_, "service.user").c_str())) == NULL) {

				std::cerr << "Invalid service.user name " << CONFIG_STRING(config_, "service.user") << "\n";

				return 1;

			}

			if ((setuid(pw->pw_uid)) != 0) {

				std::cerr << "Failed to set service.user name " << CONFIG_STRING(config_, "service.user") << " - " << pw->pw_uid << ":" << strerror(errno) << "\n";

				return 1;

			}

		}

		setrlimit(RLIMIT_CORE, &limit);

	}

	struct rlimit limit;

	limit.rlim_max = RLIM_INFINITY;

	limit.rlim_cur = RLIM_INFINITY;

	setrlimit(RLIMIT_CORE, &limit);

#endif

	if (userRegistration) {

		userRegistration->stop();

		delete userRegistration;

	}

	if (usersReconnecter) {

		delete usersReconnecter;

	}

	delete storageBackend;

	delete factories;

	return 0;

}

int main(int argc, char **argv)

{

	Config config(argc, argv);

	config_ = &config;

	boost::program_options::variables_map vm;

	bool no_daemon = false;

	std::string config_file;

	std::string jid;

#ifdef WIN32

	std::string install_service_name, uninstall_service_name, run_service_name;

	// determine the name of the currently executing file

	char szFilePath[MAX_PATH];

	GetModuleFileNameA(NULL, szFilePath, sizeof(szFilePath));

	std::string exe_file(szFilePath);					

#endif	

	setlocale(LC_ALL, "");

#ifndef WIN32

#ifndef __FreeBSD__

	mallopt(M_CHECK_ACTION, 2);

	mallopt(M_PERTURB, 0xb);

#endif

#endif

#ifndef WIN32

	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {

		std::cout << "SIGINT handler can't be set\n";

		return -1;

	}

	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

		std::cout << "SIGTERM handler can't be set\n";

		return -1;

	}

#endif

	boost::program_options::options_description desc(std::string("Spectrum version: ") + SPECTRUM_VERSION + "\nUsage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");

	desc.add_options()

		("help,h", "help")

		("no-daemonize,n", "Do not run spectrum as daemon")

		("no-debug,d", "Create coredumps on crash")

		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

		("config", boost::program_options::value<std::string>(&config_file)->default_value(""), "Config file")

		("version,v", "Shows Spectrum version")

		;

#ifdef WIN32

 	desc.add_options()

		("install-service,i", boost::program_options::value<std::string>(&install_service_name)->default_value(""), "Install spectrum as Windows service")

 		("uninstall-service,u", boost::program_options::value<std::string>(&uninstall_service_name)->default_value(""), "Uninstall Windows service")

		("run-as-service,r", boost::program_options::value<std::string>(&run_service_name)->default_value(""), "stub for Windows Service Manager");

#endif

	try

	{

		boost::program_options::positional_options_description p;

		p.add("config", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

          options(desc).positional(p).allow_unregistered().run(), vm);

		boost::program_options::notify(vm);

		if (vm.count("version")) {

			std::cout << SPECTRUM_VERSION << "\n";

			return 0;

		}

		if(vm.count("help"))

		{

			std::cout << desc << "\n";

			return 1;

		}

		if(vm.count("config") == 0) {

			std::cout << desc << "\n";

			return 1;

		}

		if(vm.count("no-daemonize")) {

			no_daemon = true;

		}

#ifdef WIN32	

		if (!install_service_name.empty()) {				

			// build command line for Service Manager

			std::string service_path = exe_file + std::string(" --config ") + vm["config"].as<std::string>() 

						+ std::string(" --run-as-service ") + install_service_name;													

	switch(action) {

	case DO_INSTALL:

		service = CreateServiceA(

			scm, 

			ServiceName, 

			ServiceName, 

			SERVICE_ALL_ACCESS, 

			SERVICE_WIN32_OWN_PROCESS, 

			SERVICE_DEMAND_START, 

			SERVICE_ERROR_NORMAL, 

			path,

			NULL,

			NULL,

			NULL,

			NULL,

			NULL

			);

		return (service != NULL);

		break;

	case DO_DELETE:

		service = OpenServiceA(scm, ServiceName, DELETE);

		if (service == NULL)

			return FALSE;

		if (DeleteService(service))

			return TRUE;

		break;

	case DO_CHECK:

		service = OpenServiceA(scm, ServiceName, SERVICE_QUERY_STATUS);

		return (service != NULL);

	default:

		return FALSE;

	}

	CloseServiceHandle(service);		

	CloseServiceHandle(scm);

	return FALSE;

}

void WINAPI ServiceControlHandler(DWORD controlCode) {

	switch (controlCode) {

	case SERVICE_CONTROL_INTERROGATE:

		break;

	case SERVICE_CONTROL_STOP:

		ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;		

		break;

	default:

		break;

	}

	SetServiceStatus(ServiceStatusHandle, &ServiceStatus);	

}

void WINAPI ServiceMain(DWORD argc, LPSTR *argv) {

	ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;

	ServiceStatus.dwServiceSpecificExitCode = NO_ERROR;

	ServiceStatusHandle = RegisterServiceCtrlHandlerA(ServiceName, ServiceControlHandler);

	if (ServiceStatusHandle) {

		ServiceStatus.dwCurrentState = SERVICE_START_PENDING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		ServiceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);

		ServiceStatus.dwCurrentState = SERVICE_RUNNING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		mainloop();

		ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		ServiceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);

		ServiceStatus.dwCurrentState = SERVICE_STOPPED;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

	}	

}

void ServiceWrapper::RunService() {

	SERVICE_TABLE_ENTRYA serviceTable[] = {

		{ ServiceName, ServiceMain },

		{ NULL, NULL}

	};

	StartServiceCtrlDispatcherA(serviceTable);

}

#pragma once

#include "transport/config.h"

#include <windows.h>

#include <tchar.h>

class ServiceWrapper

{

public:

	ServiceWrapper(LPSTR serviceName);

	~ServiceWrapper(void);

	bool Install(LPSTR commandLine);

	bool UnInstall();

	bool IsInstalled();

	void RunService();

};

int mainloop();