#ifndef BOOST_DSL_EXPR_HPP_
#define BOOST_DSL_EXPR_HPP_

#include <boost/parameter/parameters.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/size.hpp>
#include <boost/type_traits/detail/type_trait_def.hpp>
#include <boost/parameter/binding.hpp>

namespace boost { 
namespace dsl {

template <typename Tag, typename Pred, typename Default> 
struct optional {
	typedef Tag tag;
	typedef Pred pred;
	typedef Default default_t;
};

template <typename Tag, typename Pred, typename Default> 
struct required {
	typedef Tag tag;
	typedef Pred pred;
	typedef Default default_t;
};

namespace detail{

#if 0
template <typename Parameter, typename Tag>
struct has_tag : is_same<typename Parameter::tag, Tag> {
};

template <typename Parameter>
struct get_pred_impl {
		typedef typename Parameter::pred type;
};

BOOST_TT_AUX_TYPE_TRAIT_DEF1(get_pred,T,typename get_pred_impl<T>::type)
#endif
#if 1
// gets the default type associated to a tag
template <typename Tag, typename T, typename Parameters> 
struct default_aux;

template <typename Tag, typename Pred, typename Default, typename Parameters> 
struct default_aux<Tag, optional<Tag, Pred, Default>, Parameters> {
	typedef Default type;
};

template <typename Tag, typename Pred, typename Default, typename Parameters> 
struct default_aux<Tag, required<Tag, Pred, Default>, Parameters> {
	typedef Default type;
};

template <typename Tag, typename T, typename Parameters> 
struct default_aux {
	typedef typename default_aux<Tag, 	
		typename mpl::front<Parameters>::type,
		typename mpl::pop_front<Parameters>::type
	>::type type;
};

template <typename Tag, typename Parameters> 
struct default_t {
	typedef typename default_aux<Tag, 
	typename mpl::front<Parameters>::type,
	typename mpl::pop_front<Parameters>::type
	>::type type;
};
#else
// gets the default type associated to a tag
template <typename Tag, typename Parameters> 
struct default_t {
	typedef typename mpl::find_if<Parameters, has_tag<mpl::_1,Tag> >::type iter;
	typedef typename mpl::deref<iter>::type type;
};
#endif

// transform T to a parameter::parameters type
template <typename T> struct signature;

template <typename Tag, typename Pred, typename Default> 
struct signature<optional<Tag, Pred, Default> >{
	typedef parameter::optional<parameter::deduced<Tag>, Pred>  type;
};

template <typename Tag, typename Pred, typename Default> 
struct signature<required<Tag, Pred, Default> >{
	typedef parameter::required<parameter::deduced<Tag>, Pred>  type;
};

template <typename Param0> 
struct signature<mpl::vector<Param0> >{
    typedef parameter::parameters<
      typename signature<Param0>::type
    >                                     type;
};

template <typename Param0,typename Param1> 
struct signature<mpl::vector<Param0, Param1> >{
    typedef parameter::parameters<
    	typename signature<Param0>::type,
    	typename signature<Param1>::type
    >                                      type;
};

template <typename Param0,typename Param1,typename Param2> 
struct signature<mpl::vector<Param0, Param1, Param2> >{
    typedef parameter::parameters<
    	typename signature<Param0>::type,
    	typename signature<Param1>::type,
    	typename signature<Param2>::type
    >                                      type;
};

// bind to the signature the Args provided
// template <typename Signature, typename... Args> 
// struct args;

template <typename Signature, typename Args> 
struct args;

template <typename Signature, typename Arg0> 
struct args<Signature, mpl::vector<Arg0> > {
    typedef typename Signature::template bind<Arg0>::type type;
};

template <typename Signature, typename Arg0, typename Arg1> 
struct args<Signature, mpl::vector<Arg0, Arg1> > {
    typedef typename Signature::template bind<Arg0, Arg1>::type type;
};

template <typename Signature, typename Arg0, typename Arg1, typename Arg2> 
struct args<Signature, mpl::vector<Arg0, Arg1, Arg2> > {
    typedef typename Signature::template bind<Arg0, Arg1, Arg2>::type type;
};

/* Used for the detection of unmatched template args in a
 * dsl instantiations.
 */

struct unmatched_arg;

// transform T to a parameter::parameters nmatched signature
template <typename T> struct unmatched_signature;

//template <typename Tag, typename Pred, typename Default> 
//struct unmatched_signature<optional<Tag, Pred, Default> >{
//	typedef Pred  type;
//};
//
//template <typename Tag, typename Pred, typename Default> 
//struct unmatched_signature<required<Tag, Pred, Default> >{
//	typedef Pred  type;
//};

template <typename Param0> 
struct unmatched_signature<mpl::vector<Param0> >{
    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<
    			detail::unmatched_arg
    		>,
    		mpl::not_<
    			mpl::or_<
					typename Param0::pred
    			>	        
    		>
    	>	    
    >                                     type;
};

template <typename Param0,typename Param1> 
struct unmatched_signature<mpl::vector<Param0, Param1> >{
    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<
    			detail::unmatched_arg
    		>,
    		mpl::not_<
    			mpl::or_<
					typename Param0::pred,
					typename Param1::pred
    			>	        
    		>
    	>
    >                                      type;
};
template <typename Param0,typename Param1,typename Param2> 
struct unmatched_signature<mpl::vector<Param0, Param1, Param2> >{
    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<
    			detail::unmatched_arg
    		>,
    		mpl::not_<
    			mpl::or_<
					typename Param0::pred,
					typename Param1::pred,
					typename Param2::pred
    			>	        
    		>
    	>
    >                                      type;
};

// bind to the unmatched signature the Args provided
// template <typename UnmatchedSignature, typename... Args> 
// struct unmatched_args<UnmatchedSignature, mpl::vector<Args> > {
//   typedef typename UnmatchedSignature::template bind<Args...>::type type;
// };

template <typename UnmatchedSignature, typename Args> 
struct unmatched_args;

template <typename UnmatchedSignature, typename Arg0> 
struct unmatched_args<UnmatchedSignature, mpl::vector<Arg0> > {
    typedef typename UnmatchedSignature::template bind<Arg0>::type type;
};

template <typename UnmatchedSignature, typename Arg0, typename Arg1> 
struct unmatched_args<UnmatchedSignature, mpl::vector<Arg0, Arg1> > {
    typedef typename UnmatchedSignature::template bind<Arg0, Arg1>::type type;
};

template <typename UnmatchedSignature, typename Arg0, typename Arg1, typename Arg2> 
struct unmatched_args<UnmatchedSignature, mpl::vector<Arg0, Arg1, Arg2> > {
    typedef typename UnmatchedSignature::template bind<Arg0, Arg1, Arg2>::type type;
};

}

template <typename Tag, typename Parameters, typename Args> 
class expr {
public:	
	typedef Tag 			tag;
    typedef expr 			base_expr;
private:	
	typedef Parameters		parameters;
    typedef mpl::size<Parameters> 	arity;
    typedef typename detail::signature<Parameters>::type signature;
    typedef typename detail::args<signature, Args>::type args;

    typedef typename detail::unmatched_signature<Parameters>::type unmatched_signature;
    typedef typename detail::unmatched_args<unmatched_signature, Args>::type unmatched_args;
    typedef typename parameter::binding<
      unmatched_args,detail::unmatched_arg,  detail::unmatched_arg
    >::type                                      unmatched_arg_detected;
    /* You have passed a type in the specification of a expr type that
     * could not be interpreted as a valid argument.
     */
    BOOST_STATIC_ASSERT((
      is_same<unmatched_arg_detected,detail::unmatched_arg>::value));
public:
    template <typename TagP>
    struct get{
  	  typedef typename parameter::binding<
  	  	args, TagP, typename detail::default_t<TagP, parameters>::type
  	  >::type                                      type;
    };


};
namespace detail {

template<typename Expr, typename Grammar>
struct matches_
  : mpl::false_
{};

template<typename Expr>
struct matches_<Expr, Expr>
  : mpl::true_
{};

template<typename Expr>
struct matches_< Expr, parameter::void_ >
  : mpl::true_
{};

template<typename Tag, typename Parameters, 
			typename Arg1, 
			typename Arg2>
struct matches_< expr<Tag, Parameters, mpl::vector<Arg1> >, 
				 expr<Tag, Parameters, mpl::vector<Arg2> >
				>
: mpl::or_<matches_<Arg1,Arg2>, is_same<Arg1,Arg2> >
{};

template<typename Tag, typename Parameters, 
			typename Arg11, typename Arg12, 
			typename Arg21, typename Arg22>
struct matches_< expr<Tag, Parameters, mpl::vector<Arg11, Arg12> >, 
				 expr<Tag, Parameters, mpl::vector<Arg21, Arg22> >
				>
: mpl::and_<
	mpl::or_<matches_<Arg11,Arg21>, is_same<Arg11,Arg21> >,
	mpl::or_<matches_<Arg12,Arg22>, is_same<Arg12,Arg22> >
	>
{};

}

template<typename Expr, typename Grammar>
struct matches
  : detail::matches_<
        typename Expr::base_expr
      , typename Grammar::base_expr
    >
{};



} // dsl
} // boost
#endif // BOOST_DSL_EXPR_HPP_