/* Mantra - http://www.neuromancy.net/mantra
 * (c) 2007-2009 - The Neuromancy Society
 *
 * This code is released under the Artistic License 2.0.  If you have not
 * received a copy of the license with this source code, you may find
 * this license at:
 *     http://www.opensource.org/licenses/artistic-license-2.0.php
 *
 * $Id: command.h 611 2010-03-06 10:00:20Z prez $
 */

#ifndef MANTRA_ADMIN_COMMAND_H
#define MANTRA_ADMIN_COMMAND_H 1

#include <mantra/priv/permission_set.h>
#include <mantra/utils/complex_format.h>
#include <mantra/utils/intl.h>
#include <mantra/utils/properties.h>
#include <boost/variant.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/thread/tss.hpp>

namespace mantra {
namespace admin {

class session;
class MANTRA_API command
{
	typedef boost::variant<std::pair<std::string, bool>, mantra::table,
							mantra::tree> help_data_type;

	boost::shared_ptr<mantra::priv::permission_set> perm_set_;
	std::string perm_name_;
	std::string desc_;
	std::string domain_;
	std::vector<help_data_type> help_;

protected:
	command(const std::string &desc, const std::string &domain);
	virtual ~command() {}

	void set_permission(const boost::shared_ptr<mantra::priv::permission_set> &in,
						const std::string &name);

public:
	bool access(const boost::shared_ptr<session> &sess,
				const boost::shared_ptr<mantra::priv::context> &ctx) const;

	const std::string &domain() const;
	std::string description(const std::locale &loc = std::locale()) const;

	enum error_code {
		no_error,			//< Ready to execute command.
		no_terminator,		//< No terminator found.
		handled_error,		//< An error that we have already reported.
		unknown_error,		//< ?!
		invalid_session,	//< Problem with the session.
		parse_error,		//< Could not split line into 'words'.
		no_such_command,	//< No such command.
		incomplete_cmd,		//< Continuation required (operator())
		incomplete_help,	//< Continuation required (help)
		permission_denied,	//< Not allwed to execute command.
		not_enough_args,	//< Incomplete command without continuation.
		invalid_arg,		//< An argument is not valid/understood.
		sess_not_supp,		//< Not supported in this session.
		sys_not_supp,		//< Not supported on this system.
		NUM_ERROR_CODES
	};

	class complete_replace
	{
		// Possible completions.  If this is empty, no possible
		// completions exist.  If there is more than one entry in
		// here, then multiple possibilities exist.
		std::vector<std::string> poss_;
		std::string append_;
		size_t remove_;

	public:
		complete_replace() : remove_(0) {}
		complete_replace(size_t r, const std::string &app = std::string())
			: append_(app), remove_(r) {}

		void add(const std::string &in);
		void add(const complete_replace &in);

		// Largest string that is common to all possibilities.
		std::string common() const;
		const std::string &append() const;
		size_t remove() const;

		const std::vector<std::string> &poss() const;
	};

	typedef complete_replace complete_type(const boost::shared_ptr<session> &,
						const std::vector<std::string> &, const std::string &,
						size_t, const boost::shared_ptr<mantra::priv::context> &ctx);

	// rv.first = what to insert into the string at offs.
	// rv.second = whether we found a unique completion.
	virtual complete_replace complete(const boost::shared_ptr<session> &sess,
						const std::vector<std::string> &prev, const std::string &rest,
						size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	typedef std::pair<command::error_code, boost::shared_ptr<command> > return_type;

	typedef return_type type(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	virtual return_type operator()(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>()) = 0;

	virtual return_type help(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());
};

// A generic command to handle HELP calls, it basically invokes the stored command's
// HELP function (and completion command).  In and of itself, its very stupid.
class MANTRA_API command_help : public command
{
	command &root_;
public:
	command_help(command &root);

	command::complete_replace complete(const boost::shared_ptr<session> &sess,
						const std::vector<std::string> &prev, const std::string &rest,
						size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	command::return_type operator()(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	command::return_type help(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());
};

class MANTRA_API command_set : public command
{
	std::string section_;
	properties *props_;

public:
	command_set(const std::string &desc, const std::string &domain,
				const std::string &section, mantra::properties *props = NULL);

	command::complete_replace complete(const boost::shared_ptr<session> &sess,
						const std::vector<std::string> &prev, const std::string &rest,
						size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	command::return_type operator()(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());

	command::return_type help(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx =
							boost::shared_ptr<mantra::priv::context>());
};

class MANTRA_API command_property_proxy
{
public:
	typedef boost::optional<property_value_type> get_property_func(
			const boost::shared_ptr<session> &,
			const boost::shared_ptr<mantra::priv::context> &,
			const std::string &, const std::string &);
	typedef bool set_property_func(const boost::shared_ptr<session> &,
			const boost::shared_ptr<mantra::priv::context> &,
			const std::string &, const std::string &, const property_value_type &);
	typedef void clear_property_func(const boost::shared_ptr<session> &,
			const boost::shared_ptr<mantra::priv::context> &,
			const std::string &, const std::string &);

	command_property_proxy(const boost::function<get_property_func> &gpf,
							const boost::function<set_property_func> &spf = boost::function<set_property_func>(),
							const boost::function<clear_property_func> &cpf = boost::function<clear_property_func>());

	static void set_command_data(const boost::shared_ptr<session> &s,
								 const boost::shared_ptr<mantra::priv::context> &c =
									boost::shared_ptr<mantra::priv::context>());
	static void clear_command_data(bool erase = false);

	boost::optional<property_value_type> get_property(const std::string &section, const std::string &key);
	bool set_property(const std::string &section, const std::string &key, const property_value_type &value);
	void clear_property(const std::string &section, const std::string &key);

private:
	static boost::thread_specific_ptr<std::pair<boost::shared_ptr<session>,
										boost::shared_ptr<mantra::priv::context> > > ptr;

	boost::function<get_property_func> get;
	boost::function<set_property_func> set;
	boost::function<clear_property_func> clear;
};

// This is just for convenience.
#define DECLARE_PROPERTY(x)													\
	mantra::admin::command_property_proxy x##_proxy_;						\
	boost::optional<mantra::property_value_type> x##_get(					\
				const boost::shared_ptr<mantra::admin::session> &sess,		\
				const boost::shared_ptr<mantra::priv::context> &ctx,		\
				const std::string &section, const std::string &key) const;	\
	bool x##_set(const boost::shared_ptr<mantra::admin::session> &sess,		\
				const boost::shared_ptr<mantra::priv::context> &ctx,		\
				const std::string &section, const std::string &key,			\
				const mantra::property_value_type value);					\
	void x##_clear(const boost::shared_ptr<mantra::admin::session> &sess,	\
				const boost::shared_ptr<mantra::priv::context> &ctx,		\
				const std::string &section, const std::string &key);

MANTRA_API std::string assemble_cmd(const std::vector<std::string> &prev,
						 const std::string &delim = " ");

MANTRA_API command::error_code load_config(boost::property_tree::iptree &pt,
								const boost::shared_ptr<session> &sess,
								const std::vector<std::string> &prev,
								const std::string &rest);

MANTRA_API command::complete_replace complete_config(const boost::shared_ptr<session> &sess,
				const std::vector<std::string> &prev, const std::string &rest,
				size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx);

MANTRA_API command::complete_replace complete_filename(const boost::shared_ptr<session> &sess,
				const std::string &word, const boost::shared_ptr<mantra::priv::context> &ctx);

// ---------------------------------------------------------------------------
// inline functions
// ---------------------------------------------------------------------------

inline command::command(const std::string &desc, const std::string &domain)
	: desc_(desc), domain_(domain)
{
}

inline const std::string &command::domain() const
{
	return domain_;
}

inline std::string command::description(const std::locale &loc) const
{
	return mantra::translate::get(domain_.c_str(), desc_, loc);
}

inline const std::string &command::complete_replace::append() const
{
	return append_;
}

inline size_t command::complete_replace::remove() const
{
	return remove_;
}

inline const std::vector<std::string> &command::complete_replace::poss() const
{
	return poss_;
}

// Default is no completion.
inline command::complete_replace command::complete(const boost::shared_ptr<session> &sess,
				const std::vector<std::string> &prev, const std::string &rest,
				size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx)
{
	static_cast<void>(sess);
	static_cast<void>(prev);
	static_cast<void>(rest);
	static_cast<void>(offs);
	static_cast<void>(ctx);
	return complete_replace();
}

inline command_help::command_help(command &root)
	: command(INTL_N("Retrieve help on other commands"), MANTRA_DOMAIN), root_(root)
{
}

inline command::return_type command_help::operator()(const boost::shared_ptr<session> &sess,
						std::vector<std::string> &prev, std::string &rest,
						const boost::shared_ptr<mantra::priv::context> &ctx)
{
	prev.pop_back();
	return root_.help(sess, prev, rest, ctx);
}

inline command::complete_replace command_help::complete(const boost::shared_ptr<session> &sess,
				const std::vector<std::string> &prev, const std::string &rest,
				size_t offs, const boost::shared_ptr<mantra::priv::context> &ctx)
{
	return root_.complete(sess, prev, rest, offs, ctx);
}

inline command_property_proxy::command_property_proxy(
				const boost::function<get_property_func> &gpf,
				const boost::function<set_property_func> &spf,
				const boost::function<clear_property_func> &cpf)
	: get(gpf), set(spf), clear(cpf)
{
}

inline boost::optional<property_value_type> command_property_proxy::get_property(const std::string &section, const std::string &key)
{
	if (!get)
		return boost::optional<property_value_type>();
	return get(ptr->first, ptr->second, section, key);
}

inline bool command_property_proxy::set_property(const std::string &section, const std::string &key, const property_value_type &value)
{
	if (!set)
		return false;
	return set(ptr->first, ptr->second, section, key, value);
}

inline void command_property_proxy::clear_property(const std::string &section, const std::string &key)
{
	if (!clear)
		return;
	clear(ptr->first, ptr->second, section, key);
}

} } // namespace mantra::admin

#endif // MANTRA_ADMIN_COMMAND_H