#include <boost/signal.hpp>

#define CONFIG_STRING(PTR, KEY) (*PTR)[KEY].as<std::string>()

#define CONFIG_INT(PTR, KEY) (*PTR)[KEY].as<int>()

#define CONFIG_BOOL(PTR, KEY) (*PTR)[KEY].as<bool>()

#define CONFIG_LIST(PTR, KEY) (*PTR)[KEY].as<std::list<std::string> >()

#define CONFIG_VECTOR(PTR, KEY) (*PTR)[KEY].as<std::vector<std::string> >()

#define CONFIG_HAS_KEY(PTR, KEY) (*PTR).hasKey(KEY)

namespace Transport {

/// Represents variable:value pairs.

typedef boost::program_options::variables_map Variables;

/// Represents config file.

/// It's used to load config file and allows others parts of libtransport to be configured

/// properly. Config files are text files which use "ini" format. Variables are divided into multiple

/// sections. Every class is configurable with some variables which change its behavior. Check particular

/// class documentation to get a list of all relevant variables for that class.

class Config {

	public:

		/// Constructor.

		/// Destructor

		virtual ~Config() {}

		/// Loads data from config file.

		/// You can pass your extra options which will be recognized by

		/// the parser using opts parameter.

		/// \param configfile path to config file

		/// \param opts extra options which will be recognized by a parser

		bool load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid = "");

		bool load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &jid = "");

		bool load(std::istream &ifs);

		/// Loads data from config file.

		/// This function loads only config variables needed by libtransport.

		/// \see load(const std::string &, boost::program_options::options_description &)

		/// \param configfile path to config file

		bool load(const std::string &configfile, const std::string &jid = "");

		bool reload();

		bool hasKey(const std::string &key) {

			return m_variables.find(key) != m_variables.end();

		}

		/// Returns value of variable defined by key.

		/// For variables in sections you can use "section.variable" key format.

		/// \param key config variable name

		const boost::program_options::variable_value &operator[] (const std::string &key) {

			return m_variables[key];

		}

		/// Returns path to config file from which data were loaded.

		const std::string &getConfigFile() { return m_file; }

		const std::map<std::string, std::string> &getUnregistered() {

			return m_unregistered;

		}

		/// This signal is emitted when config is loaded/reloaded.

		boost::signal<void ()> onConfigReloaded;

	private:

		Variables m_variables;

		std::map<std::string, std::string> m_unregistered;

		std::string m_file;

};

}

	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 main(int argc, char **argv)

{

	boost::program_options::variables_map vm;

	bool no_daemon = false;

	std::string config_file;

	std::string jid;

#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")

[service]

jid = localhost

password = secret

server = 127.0.0.1

port = 5222

server_mode = 1

backend_host=localhost

pidfile=./test.pid

# < this option doesn't work yet

#backend_port=10001

admin_password=test

#cert=server.pfx #patch to PKCS#12 certificate

#cert_password=test #password to that certificate if any

users_per_backend=10

protocol=prpl-jabber

#protocol=prpl-msn

#protocol=any

#protocol=prpl-icq

working_dir=./

[backend]

#default_avatar=catmelonhead.jpg

#no_vcard_fetch=true

[logging]

#config=logging.cfg # log4cxx/log4j logging configuration file

#backend_config=/home/hanzz/code/libtransport/spectrum/src/backend-logging.cfg # log4cxx/log4j logging configuration file for backends

[database]

type = none # or "none" without database backend

database = test.sql

prefix=icq

#type = mysql # or "none" without database backend.......................................................................................................................

#database = test

#prefix=

#user=root

#password=yourrootsqlpassword

#encryption_key=hanzzik

		value.push_back("/var/run/spectrum2/$jid.pid");

		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));

	}

	if (!found_backend_port) {

		std::vector<std::string> value;

		std::string p = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));

		value.push_back(p);

		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));

	}

	if (!found_database) {

		std::vector<std::string> value;

		value.push_back("/var/lib/spectrum2/$jid/database.sql");

		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));

	}

	BOOST_FOREACH(option &opt, parsed.options) {

		if (opt.unregistered) {

			m_unregistered[opt.string_key] = opt.value[0];

		}

		else if (opt.value[0].find("$jid") != std::string::npos) {

			boost::replace_all(opt.value[0], "$jid", jid);

		}

	}

	store(parsed, m_variables);

	notify(m_variables);

	onConfigReloaded();

	return true;

}

bool Config::load(std::istream &ifs) {

	options_description opts("Transport options");

	return load(ifs, opts);

}

bool Config::load(const std::string &configfile, const std::string &jid) {

	try {

		options_description opts("Transport options");

		return load(configfile, opts, jid);

	} catch ( const boost::program_options::multiple_occurrences& e ) {

#if (BOOST_MAJOR_VERSION >= 1 && BOOST_MINOR_VERSION >= 42)

		std::cerr << configfile << " parsing error: " << e.what() << " from option: " << e.get_option_name() << std::endl;

#else

		std::cerr << configfile << " parsing error: " << e.what() << std::endl;

#endif

		return false;