/* Copyright 2008 Vicente J. Botet Escriba
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See http://www.boost.org/libs/ for library home page.
 */


#ifndef BOOST_DSL_EXPR_HPP_
#define BOOST_DSL_EXPR_HPP_

#if !defined(BOOST_DSL_EXPR_MAX_SIZE)
#	define BOOST_DSL_EXPR_MAX_SIZE 5
#endif

#if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
#   define BOOST_MPL_LIMIT_METAFUNCTION_ARITY BOOST_DSL_EXPR_MAX_SIZE 
#elif BOOST_MPL_LIMIT_METAFUNCTION_ARITY < BOOST_DSL_EXPR_MAX_SIZE
#	define BOOST_MPL_LIMIT_METAFUNCTION_ARITY BOOST_DSL_EXPR_MAX_SIZE
#endif

#if !defined(BOOST_PARAMETER_MAX_ARITY)
#   define BOOST_PARAMETER_MAX_ARITY BOOST_DSL_EXPR_MAX_SIZE
#elif BOOST_PARAMETER_MAX_ARITY < BOOST_DSL_EXPR_MAX_SIZE
#	define BOOST_PARAMETER_MAX_ARITY BOOST_DSL_EXPR_MAX_SIZE
#endif

#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/dsl/or_seq.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/type_traits/detail/type_trait_def.hpp>
#include <boost/parameter/binding.hpp>

namespace boost { 
namespace dsl {

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

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

namespace detail{

template <typename Parameter>
struct get_default_impl {
		typedef typename Parameter::default_t type;
};
template <>
struct get_default_impl<mpl_::void_> {
		typedef mpl::void_ type;
};

template <typename Parameter>
struct get_tag_impl {
		typedef typename Parameter::tag type;
};

BOOST_TT_AUX_TYPE_TRAIT_DEF1(get_tag,T,typename get_tag_impl<T>::type)


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

// gets the default type associated to a tag
template <typename Tag, typename Parameters> 
struct default_t2 {
	typedef typename mpl::find_if<Parameters, has_tag<mpl::_1,Tag> >::type iter;
	typedef mpl::eval_if<is_same< iter, mpl::end<Parameters> >, 
			mpl::identity<mpl::void_>,
			get_default_impl<typename mpl::deref<iter>::type>
			> type;
};
template <typename Parameters> 
struct default_t2<mpl_::void_, Parameters> {
	typedef mpl::void_ type;

};

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::default_t type;
};

// transform T to a parameter::parameters type

template <typename T> struct signature_parameter;

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

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

template <typename T> struct signature;

// bind to the signature the Args provided

template <typename Signature, typename Args> 
struct args;

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

struct unmatched_arg;

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)

template <typename Args, typename Parameters>
struct parameter_binding_impl {
	template <typename Tag>
	struct xx {
		typedef typename mpl::eval_if<
			boost::is_same<mpl_::void_, Tag>,
			mpl::identity<mpl::void_>,
			parameter::binding<
					Args, Tag , typename detail::default_t2<Tag, Parameters>::type
				>
			>::type type;
	};
};

template <typename Args, typename Parameter>
struct parameter_binding {
	template< typename T >	
	struct apply {
		typedef typename parameter_binding_impl<Args, Parameter>::template xx<T>::type type;
	};
};


template <typename Parameters> 
struct unmatched_signature {
	typedef typename mpl::transform<Parameters, get_pred<mpl::_1>, 
	mpl::back_inserter< mpl::vector0<> > >::type preds;
	
    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<detail::unmatched_arg>, 
    		mpl::not_< or_seq<preds> >    		
    	>
    >  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;

}
}
}

// include variadic templates using the preprocesor
#include <boost/dsl/expr_pp.hpp>

namespace boost { 
namespace dsl {

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));
    
//	typedef typename mpl::transform<Parameters, detail::get_tag<mpl::_1> >::type tags;

public:
	template <typename TagP>
    struct get{
  	  typedef typename parameter::binding<
  	  	args, TagP, typename detail::default_t<TagP, parameters>::type
  	  >::type                                      type;
    };
};

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