/* 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: selector.h 616 2010-03-11 06:23:14Z prez $
 */

#ifndef MANTRA_ADMIN_SELECTOR_H
#define MANTRA_ADMIN_SELECTOR_H 1

#include <mantra/utils/trace/trace.h>
#include <mantra/admin/command.h>
#include <mantra/admin/param_extractor.h>

#include <boost/regex.hpp>
#include <boost/variant.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/algorithm/string.hpp>

namespace mantra {
namespace admin {

// For now, this is just a way to classify selectors.
class MANTRA_API selector : public command
{
protected:
	boost::shared_ptr<param_extractor> extractor_;
	std::string post_complete_;

	// What to do if rest is empty (or we cannot extract anything selectable from it).
	boost::function<command::type> default_act_;

	virtual command::error_code find(const boost::shared_ptr<session> &sess,
							 const std::string &word, boost::shared_ptr<command> &cmd,
							 const boost::shared_ptr<mantra::priv::context> &ctx) const = 0;
	virtual command::complete_replace complete(const boost::shared_ptr<session> &sess,
							const std::string &word, 
							const boost::shared_ptr<mantra::priv::context> &ctx) const = 0;
	virtual void help(const boost::shared_ptr<session> &sess,
			  const boost::shared_ptr<mantra::priv::context> &ctx) const = 0;

	selector(const std::string &desc, const std::string &domain,
			 const boost::shared_ptr<param_extractor> &pe,
			 const std::string &pc);
public:
	// Make it public, since it is not a hand-crafted command :)
	using command::set_permission;

	void default_action(const boost::function<command::type> &in);

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

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

class MANTRA_API command_name
{
	std::string value_;
	bool complete_;
public:
	command_name(const std::string &value, bool complete = true)
		: value_(value), complete_(complete) { }

	operator const std::string &() const
		{ return value_; }
	const std::string &value() const
		{ return value_; }
	bool complete() const
		{ return complete_; }

	bool operator<(const command_name &rhs) const
		{ return value_ < rhs.value_; }
	bool operator==(const command_name &rhs) const
		{ return value_ == rhs.value_; }

	bool operator<(const std::string &rhs) const
		{ return value_ < rhs; }
	bool operator==(const std::string &rhs) const
		{ return value_ == rhs; }
};

class MANTRA_API map_selector : public selector
{
	typedef std::map<command_name, std::vector<boost::shared_ptr<command> > > select_type;

	bool nocase_;
	select_type select_;

	MANTRA_LOCAL command::error_code find(const boost::shared_ptr<session> &sess,
							 const std::string &word, boost::shared_ptr<command> &cmd,
							 const boost::shared_ptr<mantra::priv::context> &ctx) const;

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

	MANTRA_LOCAL void help(const boost::shared_ptr<session> &sess,
			  const boost::shared_ptr<mantra::priv::context> &ctx) const;
public:
	map_selector(const std::string &desc, const std::string &domain,
				 const boost::shared_ptr<param_extractor> &pe,
				 const std::string &pc, bool case_insensitive = true);

	using selector::complete;
	using selector::help;

	void add(const command_name &in, const boost::shared_ptr<command> &cmd);
	void add(const char *in, const boost::shared_ptr<command> &cmd)
		{ return add(std::string(in), cmd); }
	void del(const std::string &in);

	typedef void visit_func(const command_name &, const boost::shared_ptr<command> &);
	template<typename T> void visit(T &cmd) const;
	template<typename T> void visit(const std::string &key, T &cmd) const;
};

class MANTRA_API regex_selector : public selector
{
	typedef std::vector<std::pair<boost::regex, std::pair<command_name, boost::shared_ptr<command> > > > select_type;

	bool nocase_;
	select_type select_;

	MANTRA_LOCAL command::error_code find(const boost::shared_ptr<session> &sess,
							 const std::string &word, boost::shared_ptr<command> &cmd,
							 const boost::shared_ptr<mantra::priv::context> &ctx) const;

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

	MANTRA_LOCAL void help(const boost::shared_ptr<session> &sess,
			  const boost::shared_ptr<mantra::priv::context> &ctx) const;
public:
	regex_selector(const std::string &desc, const std::string &domain,
				   const boost::shared_ptr<param_extractor> &pe,
				   const std::string &pc, bool case_insensitive = true);

	using selector::complete;
	using selector::help;

	void add(const std::string &in, const command_name &name,
			 const boost::shared_ptr<command> &cmd);
	void add(const std::string &in, const char *name,
			 const boost::shared_ptr<command> &cmd)
		{ return add(in, std::string(name), cmd); }
	void del(const std::string &in);

	typedef void visit_func(const boost::regex &, const command_name &, const boost::shared_ptr<command> &);
	template<typename T> void visit(T &cmd) const;
};

class MANTRA_API glob_selector : public selector
{
	typedef std::vector<std::pair<std::string, std::pair<command_name, boost::shared_ptr<command> > > > select_type;

	bool nocase_;
	select_type select_;

	MANTRA_LOCAL command::error_code find(const boost::shared_ptr<session> &sess,
							 const std::string &word, boost::shared_ptr<command> &cmd,
							 const boost::shared_ptr<mantra::priv::context> &ctx) const;

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

	MANTRA_LOCAL void help(const boost::shared_ptr<session> &sess,
			  const boost::shared_ptr<mantra::priv::context> &ctx) const;
public:
	glob_selector(const std::string &desc, const std::string &domain,
				  const boost::shared_ptr<param_extractor> &pe,
				  const std::string &pc, bool case_insensitive = true);

	using selector::complete;
	using selector::help;

	void add(const std::string &in, const command_name &name,
			 const boost::shared_ptr<command> &cmd);
	void add(const std::string &in, const char *name,
			 const boost::shared_ptr<command> &cmd)
		{ return add(in, std::string(name), cmd); }
	void del(const std::string &in);

	typedef void visit_func(const std::string &, const command_name &, const boost::shared_ptr<command> &);
	template<typename T> void visit(T &cmd) const;
};

// What we use internally as the default selector.
typedef regex_selector default_selector;

// ---------------------------------------------------------------------------
// Inline Functions
// ---------------------------------------------------------------------------

inline selector::selector(const std::string &desc, const std::string &domain,
						  const boost::shared_ptr<param_extractor> &pe,
						  const std::string &pc)
	: command(desc, domain), extractor_(pe), post_complete_(pc)
{
}

inline void selector::default_action(const boost::function<command::type> &in)
{
	default_act_ = in;
}

inline map_selector::map_selector(const std::string &desc, const std::string &domain,
								  const boost::shared_ptr<param_extractor> &pe,
								  const std::string &pc, bool case_insensitive)
	: selector(desc, domain, pe, pc), nocase_(case_insensitive)
{
}

inline void map_selector::add(const command_name &in, const boost::shared_ptr<command> &cmd)
{
	std::pair<select_type::iterator, bool> rv =
		select_.insert(std::make_pair(nocase_ ? command_name(boost::algorithm::to_upper_copy(in.value()), in.complete()) : in,
								std::vector<boost::shared_ptr<command> >()));
	rv.first->second.push_back(cmd);
}

inline void map_selector::del(const std::string &in)
{
	select_.erase(nocase_ ? boost::algorithm::to_upper_copy(in) : in);
}

template<typename T>
inline void map_selector::visit(T &cmd) const
{
	MT_FB(cmd);

	select_type::const_iterator i;
	for (i = select_.begin(); i != select_.end(); ++i)
	{
		for (size_t j = 0; j < i->second.size(); ++j)
			(cmd)(i->first, i->second[j]);
	}

	MT_FE();
}

template<typename T>
inline void map_selector::visit(const std::string &key, T &cmd) const
{
	MT_FB(key << cmd);

	select_type::const_iterator i = select_.lower_bound(nocase_ ? boost::algorithm::to_upper_copy(key) : key);
	if (i != select_.end())
		for (size_t j = 0; j < i->second.size(); ++j)
			(cmd)(i->first, i->second[j]);

	MT_FE();
}

inline regex_selector::regex_selector(const std::string &desc, const std::string &domain,
									  const boost::shared_ptr<param_extractor> &pe,
									  const std::string &pc, bool case_insensitive)
	: selector(desc, domain, pe, pc), nocase_(case_insensitive)
{
}

inline void regex_selector::add(const std::string &in, const command_name &name,
								const boost::shared_ptr<command> &cmd)
{
	select_.push_back(std::make_pair(boost::regex(in, boost::regex::normal |
										(nocase_ ? boost::regex::icase : 0)),
									std::make_pair(name, cmd)));
}

template<typename T>
inline void regex_selector::visit(T &cmd) const
{
	MT_FB(cmd);

	select_type::const_iterator i;
	for (i = select_.begin(); i != select_.end(); ++i)
		(cmd)(i->first, i->second.first, i->second.second);

	MT_FE();
}


inline glob_selector::glob_selector(const std::string &desc, const std::string &domain,
									const boost::shared_ptr<param_extractor> &pe,
									const std::string &pc, bool case_insensitive)
	: selector(desc, domain, pe, pc), nocase_(case_insensitive)
{
}


inline void glob_selector::add(const std::string &in, const command_name &name,
							   const boost::shared_ptr<command> &cmd)
{
	select_.push_back(std::make_pair(in, std::make_pair(name, cmd)));
}

template<typename T>
inline void glob_selector::visit(T &cmd) const
{
	MT_FB(cmd);

	select_type::const_iterator i;
	for (i = select_.begin(); i != select_.end(); ++i)
		(cmd)(i->first, i->second.first, i->second.second);

	MT_FE();
}

} } // namespace mantra::admin

#endif // MANTRA_ADMIN_SELECTOR_H