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

//#include <boost/shared_ptr.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/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 {

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{
// transform T to a parameter::parameters nmatched signature

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

#ifdef BOOST_HAS_VARIADIC_TMPL
template <typename... ARGS>
struct signature<mpl::vector<ARGS...>>
{
    typedef parameter::parameters<
    	typename signature_parameter<ARGS>::type...    
    >                                      type;
};
#else
template <typename T> struct signature;

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

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

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

template <typename Param0,typename Param1,typename Param2,typename Param3,typename Param4,typename Param5,typename Param6,typename Param7> 
struct signature<mpl::vector<Param0, Param1, Param2, Param3, Param4, Param5, Param6, Param7> >{
    typedef parameter::parameters<
    	typename signature_parameter<Param0>::type,
    	typename signature_parameter<Param1>::type,
    	typename signature_parameter<Param2>::type,
    	typename signature_parameter<Param3>::type,
    	typename signature_parameter<Param4>::type,
    	typename signature_parameter<Param5>::type,
    	typename signature_parameter<Param6>::type,
    	typename signature_parameter<Param7>::type
    >                                      type;
};

#endif
#endif
// bind to the signature the Args provided
#ifdef BOOST_HAS_VARIADIC_TMPL
template <typename Signature, typename... ARGS>
struct args {
typedef typename Signature::template bind<ARGS...>::type type;
};
#else

template <typename Signature, typename Args> 
struct args;

#ifndef BOOST_DSL_EXPR_PP
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;
};
template <typename Signature, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7> 
struct args<Signature, mpl::vector<Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> > {
    typedef typename Signature::template bind<Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>::type type;
};
#endif
#endif
/* 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 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;
	};
};
//BOOST_TT_AUX_TYPE_TRAIT_DEF1(parameter_binding,T,typename parameter_binding_impl<T>::type)



#ifdef BOOST_HAS_VARIADIC_TMPL
template <typename... ARGS>
struct unmatched_signature {
    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<detail::unmatched_arg>, 
    		mpl::not_< mpl::or_<get_preds<ARGS>...> >    		
    	>
    >  type;
};
#else
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;
};
#endif

// 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;
// };

#ifdef BOOST_HAS_VARIADIC_TMPL
template <typename Signature, typename... ARGS>
struct unmatched_args {
	typedef typename Signature::template bind<ARGS...>::type type;
};
#else
template <typename UnmatchedSignature, typename Args> 
struct unmatched_args;

#ifndef BOOST_DSL_EXPR_PP
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 UnmatchedSignature, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7> 
struct unmatched_args<UnmatchedSignature, mpl::vector<Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> > {
    typedef typename UnmatchedSignature::template bind<Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>::type type;
};
#endif
#endif

}
}
}

#ifdef BOOST_DSL_EXPR_PP
#include <boost/dsl/expr_pp.hpp>
#endif

namespace boost { 
namespace dsl {

#ifdef BOOST_HAS_VARIADIC_TMPL
template <typename Tag, typename Parameters, typename Args...> 
class expr {
public:	
	typedef Tag 			tag;
    typedef expr 			base_expr;
private:	
	typedef Parameters		parameters;
    typedef count<Args>::value 	arity;
    typedef parameter::parameters<
    	typename signature_parameter<Args>::type...    
    >                                      signature;
//    typedef typename detail::signature<Parameters>::type signature;
    
    typedef typename signature::template bind<Args...>::type type;
//    typedef typename detail::args<signature, Args>::type args;

    typedef parameter::parameters<
    	parameter::optional<
    		parameter::deduced<detail::unmatched_arg>, 
    		mpl::not_< mpl::or_<get_preds<Args>...> >    		
    	>
    >  unmatched_signature;
//    typedef typename detail::unmatched_signature<Parameters>::type unmatched_signature;
    
	typedef typename unmatched_signature::template bind<Args...>::type type;
//    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;
    };
};
#else //BOOST_HAS_VARIADIC_TMPL
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;
    };
};
#endif //BOOST_HAS_VARIADIC_TMPL

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