/*
 # Copyright (c) 2009 - OpenSLX Project, Computer Center University of Freiburg
 #
 # This program is free software distributed under the GPL version 2.
 # See http://openslx.org/COPYING
 #
 # If you have any feedback please consult http://openslx.org/feedback and
 # send your suggestions, praise, or complaints to feedback@openslx.org
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # --------------------------------------------------------------------------
 # inputEventHandler.h:
 #  - Common definitions for input event handlers
 # --------------------------------------------------------------------------
 */

#ifndef INPUTEVENTHANDLER_H_
#define INPUTEVENTHANDLER_H_

#include <QtGlobal>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/vector.hpp>
#include <src/input/inputEvent.h>

#define HANDLER_TYPE_DONT_CARE 0xffff
#define HANDLER_CODE_DONT_CARE 0xffff
#define HANDLER_VALUE_DONT_CARE 0xffffffff

class InputEventContext
{
public:
	virtual pid_t getSenderPid() const = 0;
	virtual uid_t getSenderUid() const = 0;
	virtual gid_t getSenderGid() const = 0;
};

struct SpecialInputEventDescription
{
	SpecialInputEventDescription(QString const& d, quint16 t, quint16 c, quint32 v = 0)
		: descriptionString(d), evtType(t), evtCode(c), evtValue(v)
	{
	}

	QString descriptionString;
	quint16 evtType;
	quint16 evtCode;
	quint32 evtValue;

	InputEvent toEvent() const
	{
		return InputEvent(evtType, evtCode, evtValue);
	}
};

template<quint16 Type = HANDLER_TYPE_DONT_CARE,
		quint16 Code = HANDLER_CODE_DONT_CARE,
		quint32 Value = HANDLER_VALUE_DONT_CARE>
class DefaultInputEventHandler {
public:
	virtual bool matches(InputEvent const& evt, InputEventContext const*) {
		if(Type != HANDLER_TYPE_DONT_CARE) {
			if(evt.type() != Type)
				return false;
		}
		if(Code != HANDLER_CODE_DONT_CARE) {
			if(evt.code() != Code)
				return false;
		}
		if(Value != HANDLER_VALUE_DONT_CARE) {
			if(evt.value() != Value)
				return false;
		}
		return true;
	}

	virtual void initialize()
	{
	}

	virtual void handle(InputEvent const& evt, InputEventContext const*) = 0;

	static void describeInto(QList<SpecialInputEventDescription>& description)
	{
	}
};

namespace policy {

enum SecurityFlags {
	SEC_PHYSICAL_SEAT = 1,
	SEC_PRIVILEGED_USER = 2
};

bool allowPhysicalSeat(InputEvent const& evt, InputEventContext const* ctx);
bool allowPrivilegedUser(InputEvent const& evt, InputEventContext const* ctx);

template<int flags = 0>
struct Security
{
	bool allow(InputEvent const& evt, InputEventContext const* ctx)
	{
		if((flags & SEC_PHYSICAL_SEAT) && !allowPhysicalSeat(evt, ctx))
			return false;
		if((flags & SEC_PRIVILEGED_USER) && !allowPrivilegedUser(evt, ctx))
			return false;
		return true;
	}
};

struct UnixLike;
struct Linux;
struct Windows;

#if defined(__linux)
typedef boost::mpl::vector2<UnixLike,Linux>::type Systems;
#elif defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
typedef boost::mpl::vector1<Windows>::type Systems;
#else
# error "Porting is needed!"
#endif

struct SystemEnabled;
struct SystemDisabled;

template<typename System>
struct RequireSystem
{
	typedef typename boost::mpl::contains<Systems, System>::type enabled_type;
	static const bool enabled = enabled_type::value;
};

struct RequireNoSystem
{
	typedef boost::mpl::bool_<true>::type enabled_type;
	static const bool enabled = enabled_type::value;
};

}

template<bool Enabled, typename Delegate, typename SecurityPolicy>
class HandlerHelper
{
public:
	bool handle(InputEvent const& evt, InputEventContext const* context = 0) {
		if(!securityPolicy.allow(evt, context))
		{
			return true;
		}
		if(delegate.matches(evt, context)) {
			delegate.handle(evt, context);
			return true;
		} else {
			return false;
		}
	}

	void initialize()
	{
		delegate.initialize();
	}

private:
	Delegate delegate;
	SecurityPolicy securityPolicy;
};

template<typename Delegate, typename SecurityPolicy>
class HandlerHelper<false, Delegate, SecurityPolicy>
{
public:
	bool handle(InputEvent const& evt, InputEventContext const* context = 0) {
		return false;
	}

	void initialize()
	{
	}
};

template<typename Delegate, typename SystemPolicy = policy::RequireNoSystem, typename SecurityPolicy = policy::Security<> >
struct Handler : public HandlerHelper<SystemPolicy::enabled, Delegate, SecurityPolicy>
{
};

template<typename Begin, typename End>
struct InputEventHandlerChainHelper
{
private:
	typedef typename boost::mpl::next<Begin>::type next_iterator_type;
	typedef InputEventHandlerChainHelper<next_iterator_type, End> next_in_chain;

	typedef typename boost::mpl::deref<Begin>::type handler_type;

	handler_type _handler;
	next_in_chain _next;

public:
	void handle(InputEvent const& evt, InputEventContext const* context = 0) {
		if(!_handler.handle(evt, context)) {
			_next.handle(evt, context);
		}
	}

	void initialize() {
		_handler.initialize();
		_next.initialize();
	}
	}
};

template<typename End>
struct InputEventHandlerChainHelper<End, End>
{
	void handle(InputEvent const&, InputEventContext const* context = 0) {
		// do nothing
	}

	void initialize() {
		// do nothing
	}
};

template<typename Collection>
struct InputEventHandlerChain : public InputEventHandlerChainHelper<typename boost::mpl::begin<Collection>::type, typename boost::mpl::end<Collection>::type>
{
};

#endif /* INPUTEVENTHANDLER_H_ */