/*
 # 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

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

	static void initialize()
	{
	}
};

namespace policy {

struct NoSecurityCheck {
	static bool allow(InputEvent const&) {
		return true;
	}
};

struct PhysicalSeatSecurityCheck {
	static bool allow(InputEvent const&) {
		return /* TODO implement */ true;
	}
};

struct AlwaysDenySecurityCheck {
	static bool allow(InputEvent const&) {
		return false;
	}
};

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:
	static bool handle(InputEvent const& evt) {
		if(!SecurityPolicy::allow(evt))
		{
			return true;
		}
		if(Delegate::matches(evt)) {
			Delegate::handle(evt);
			return true;
		} else {
			return false;
		}
	}

	static void initialize()
	{
		Delegate::initialize();
	}
};

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

	static void initialize()
	{
	}
};

template<typename Delegate, typename SecurityPolicy = policy::NoSecurityCheck, typename SystemPolicy = policy::RequireNoSystem>
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;

public:
	static void handle(InputEvent const& evt) {
		if(!handler_type::handle(evt)) {
			next_in_chain::handle(evt);
		}
	}

	static void initialize() {
		handler_type::initialize();
		next_in_chain::initialize();
	}
};

template<typename End>
struct InputEventHandlerChainHelper<End, End>
{
public:
	static void handle(InputEvent const&) {
		// do nothing
	}

	static 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_ */