#include <boost/fusion/sequence/adapted/bind_arg_sequence.hpp>

// for testing only
#include <boost/static_assert.hpp>
#include <boost/mpl/aux_/test/test_case.hpp>
#include <boost/mpl/aux_/test/assert.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/fusion/support/tag_of.hpp>

namespace _bi=boost::_bi;
namespace mpl=boost::mpl;
namespace fusion=boost::fusion;
namespace result_of=boost::fusion::result_of;
using boost::fusion::bind_arg_sequence_iterator;
using boost::mpl::equal;

#include <boost/fusion/iterator/value_of.hpp>
#include <boost/fusion/iterator/deref.hpp>

struct T{};

typedef _bi::list0 _list0;
typedef _bi::list1<int> _list1;
typedef _bi::list2<int,int> _list2;
typedef _bi::list3<int,int,int> _list3;
typedef _bi::list4<int,int,int,int> _list4;
typedef _bi::list5<int,int,int,int,int> _list5;
typedef _bi::list6<int,int,int,int,int,int> _list6;
typedef _bi::list7<int,int,int,char,int,int,int> _list7;
typedef _bi::list8<int,int,int,int,int,int,int,int> _list8;
typedef _bi::list9<int,int,int&,int,int,int,int,int,double> _list9;

template<typename Sequence,int size>
void do_checks()
{
    BOOST_MPL_ASSERT(( _bi::is_bind_sequence<Sequence> ));
    BOOST_STATIC_ASSERT((size==_bi::bind_sequence_size<Sequence>::value));
    // can't do type at index check here... doh
}

MPL_TEST_CASE()
{
#define BS_CHECK(N) do_checks<BOOST_PP_CAT(_list,N),N>()

    BS_CHECK(0);
    BS_CHECK(1);
    BS_CHECK(2);
    BS_CHECK(3);
    BS_CHECK(4);
    BS_CHECK(5);
    BS_CHECK(6);
    BS_CHECK(7);
    BS_CHECK(8);
    BS_CHECK(9);

#undef BS_CHECK

    MPL_ASSERT_NOT (( _bi::is_bind_sequence<int> ));
    MPL_ASSERT_NOT (( _bi::is_bind_sequence<T> ));

    MPL_ASSERT(( equal<_bi::type_at_index<_list1,0>::type,int> ));
    MPL_ASSERT(( equal<_bi::type_at_index<_list9,8>::type, double> ));
    MPL_ASSERT(( equal<_bi::type_at_index<_list7,3>::type,char> ));
}

MPL_TEST_CASE()
{
    typedef bind_arg_sequence_iterator<_list1,0> first;
    typedef result_of::value_of<first>::type type;
    BOOST_MPL_ASSERT((boost::is_same
		      <
		      int,
		      result_of::value_of<first>::type
		      >));
	
    BOOST_MPL_ASSERT((boost::is_same
		      <
		      int&,
		      result_of::deref<first>::type
		      >));
}

MPL_TEST_CASE()
{
    typedef bind_arg_sequence_iterator<_list9,2> first;
    typedef result_of::value_of<first>::type type;
    BOOST_MPL_ASSERT((boost::is_same
		      <
		      int &,
		      type>));
    BOOST_MPL_ASSERT((boost::is_same
		      <
		      int &,
		      result_of::deref<first>::type
		      >));
}

#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/iterator/next.hpp>

MPL_TEST_CASE()
{
    typedef _bi::list4<int,char,char &,double> list_t;

    typedef result_of::begin<list_t>::type first;
    BOOST_STATIC_ASSERT(( first::index::value==0 ));

    typedef result_of::next<first>::type second;
    BOOST_STATIC_ASSERT(( second::index::value==1 ));

    typedef result_of::next<second>::type third;

    BOOST_MPL_ASSERT((boost::is_same<
		      int,
		      result_of::value_of<first>::type
		      >));
    BOOST_MPL_ASSERT((boost::is_same<
		      char,
		      result_of::value_of<second>::type
		      >));
    BOOST_MPL_ASSERT((boost::is_same<
		      char &,
		      result_of::value_of<third>::type
		      >));
    char c='h';
    list_t l(1,'e',c,1.);
    first f(l);
}

#include <boost/fusion/sequence/intrinsic/begin.hpp>

MPL_TEST_CASE()
{
    typedef _bi::list3<int,double,char> list3;
    typedef result_of::begin<list3>::type first;    
    BOOST_MPL_ASSERT(( boost::is_same
		       <first,
		        bind_arg_sequence_iterator<list3,0> 
		       >::type ));

    BOOST_MPL_ASSERT(( boost::is_same
		       <result_of::value_of<first>::type,
		       int
		       >::type ));

    typedef result_of::next<first>::type second;

    BOOST_MPL_ASSERT(( boost::is_same
		       <second,
		        bind_arg_sequence_iterator<list3,1> 
		       >::type ));

    BOOST_MPL_ASSERT(( boost::is_same
		       <result_of::value_of<second>::type,
		       double
		       >::type));

    typedef result_of::next<second>::type third;

    BOOST_MPL_ASSERT(( boost::is_same
		       <third,
		       bind_arg_sequence_iterator<list3,2>
		       >::type));
    
    BOOST_MPL_ASSERT(( boost::is_same
		       <result_of::value_of<third>::type,
		       char
		       >::type));
}

#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/intrinsic/empty.hpp>
#include <boost/fusion/sequence/intrinsic/front.hpp>

template<typename BindSequence,int Size>
void test_fwd_impl()
{
    typedef typename result_of::begin<BindSequence>::type first;
    BOOST_MPL_ASSERT(( mpl::not_<boost::is_same<first,mpl::void_> > ));

    typedef typename result_of::end<BindSequence>::type end;
    BOOST_MPL_ASSERT(( mpl::not_<boost::is_same<end,mpl::void_> > ));
    
    BOOST_STATIC_ASSERT(( result_of::size<BindSequence>::value == Size ));
}

template<typename BindSequence,int Size>
void test_fwd()
{
    test_fwd_impl<BindSequence,Size>();

    BOOST_STATIC_ASSERT(( ! result_of::empty<BindSequence>::value ));

    typedef typename result_of::begin<BindSequence>::type first;

    // only nonempty sequences iterators can be derefernced
    typedef typename result_of::front<BindSequence>::type front;
    typedef typename result_of::deref<first>::type first_type;

    BOOST_MPL_ASSERT(( boost::is_same<front,first_type> ));
}

template<>
void test_fwd<_bi::list0,0>()
{
    test_fwd_impl<_bi::list0,0>();
    // additionally want to check that its empty
    BOOST_STATIC_ASSERT(( result_of::empty<_bi::list0>::value ));
}

MPL_TEST_CASE()
{
    // test fwd sequence stuff
#define BS_CHECK(N) test_fwd<BOOST_PP_CAT(_list,N),N>()

    BS_CHECK(0);
    BS_CHECK(1);
    BS_CHECK(2);
    BS_CHECK(3);
    BS_CHECK(4);
    BS_CHECK(5);
    BS_CHECK(6);
    BS_CHECK(7);
    BS_CHECK(8);
    BS_CHECK(9);
    
#undef BS_CHECK
}

#include <boost/fusion/algorithm/query/find_if.hpp>
#include <boost/mpl/placeholders.hpp>

#include <boost/fusion/algorithm/transformation/filter_if.hpp>
#include <boost/fusion/algorithm/iteration/accumulate.hpp>

#include <boost/fusion/sequence/container/vector.hpp>
#include <boost/fusion/sequence/conversion/as_vector.hpp>

template<typename BindSequence,typename FindType>
void find_type()
{
    typedef typename result_of::find_if<BindSequence,
	boost::is_same<mpl::_,FindType> >::type find_it;

    typedef typename result_of::value_of<find_it>::type found_type;
    BOOST_MPL_ASSERT(( boost::is_same<found_type,FindType> ));

    // now count all the types FindType
    typedef typename result_of::filter_if
	<
	BindSequence
	, boost::is_same<mpl::_1,FindType>
	>::type filter_type;
    // and make sure there is atleast 1
    BOOST_STATIC_ASSERT(( result_of::size<filter_type>::value >= 1));
}

MPL_TEST_CASE()
{
    // test some algorithms
    find_type<_list1,int>();
    find_type<_list2,int>();
    find_type<_list3,int>();
    find_type<_list4,int>();
    find_type<_list5,int>();
    find_type<_list6,int>();
    find_type<_list7,char>();
    find_type<_list8,int>();
    find_type<_list9,int &>();
}

#include <boost/mpl/less.hpp>

template<typename T>
struct argument_position_impl
{
    typedef mpl::int_<0> type;
};

template<int N>
struct argument_position_impl<boost::arg<N>(*)()>
{
    typedef mpl::int_<N> type;
};

struct argument_position
{
    template<typename T>
    struct result 
    {
	typedef typename argument_position_impl<T>::type type;
    };
};

template<typename BindExpression>
struct placeholders
{
    typedef typename boost::bind_arg_sequence<BindExpression>::type bind_arg_sequence;
    typedef typename result_of::filter_if
	<
	bind_arg_sequence
	, boost::is_placeholder<mpl::_1>
	>::type placeholders_list;
};

template<int NumPlaceholders,typename BindExpression>
struct count_placeholders_impl_assert;

template<typename BindExpression>
struct count_placeholders_impl_assert<0,BindExpression>
{
    typedef typename placeholders<BindExpression>::placeholders_list placeholders_list;
    BOOST_STATIC_ASSERT(( result_of::size<placeholders_list>::value == 0));
};

template<int NumPlaceholders, typename BindExpression>
struct count_placeholders_impl_assert
{
    typedef typename placeholders<BindExpression>::placeholders_list placeholders_list;
    BOOST_STATIC_ASSERT(( result_of::size<placeholders_list>::value == NumPlaceholders));

    typedef typename result_of::begin<placeholders_list>::type first;
    typedef typename result_of::value_of<first>::type first_type;
    BOOST_STATIC_ASSERT(( argument_position_impl<first_type>::type::value > 0 ));
};

template<int NumPlaceholders,typename BindExpression>
void count_placeholders(BindExpression)
{
    count_placeholders_impl_assert<NumPlaceholders,BindExpression>();
}

void fn_0(){}
void fn_1(int){}
void fn_2(int,int){}
void fn_3(int,int,int){}
void fn_4(int,int,int,int){}

MPL_TEST_CASE()
{
    count_placeholders<0>(boost::bind(&fn_0));
    count_placeholders<1>(boost::bind(&fn_1,_1));
    int a = 5;
    count_placeholders<1>(boost::bind(&fn_2,a,_2));
    count_placeholders<3>(boost::bind(&fn_3,_1,_2,_3));
    count_placeholders<4>(boost::bind(&fn_4,_1,_2,_3,_4));
}

#include <boost/fusion/algorithm/iteration/fold.hpp>
#include <boost/fusion/algorithm/transformation/transform.hpp>
#include <boost/fusion/sequence/intrinsic/mpl.hpp>
#include <boost/mpl/max_element.hpp>
#include <boost/mpl/eval_if.hpp>

template<int MinArity,typename BindExpression>
void min_arity(BindExpression const &)
{
    typedef typename placeholders<BindExpression>::placeholders_list 
	placeholders_list;

    typedef typename result_of::transform<
	placeholders_list,
	argument_position
	>::type arg_positions;

    typedef typename mpl::max_element<
	arg_positions>::type iter;

    typedef typename result_of::empty<arg_positions>::type no_placeholders;

    typedef typename mpl::eval_if<
	no_placeholders,
	mpl::int_<0>,
	mpl::deref<iter>
	>::type min_arity_type;

    BOOST_MPL_ASSERT(( boost::is_same<min_arity_type,mpl::int_<MinArity> >));
}

MPL_TEST_CASE()
{
    min_arity<0>(boost::bind(&fn_0));
    min_arity<5>(boost::bind(&fn_2,_4,_5));
    min_arity<1>(boost::bind(&fn_1,_1));
    int a=9;
    min_arity<2>(boost::bind(&fn_3,a,_1,_2));
    min_arity<3>(boost::bind(&fn_3,_1,_2,_3));
    min_arity<4>(boost::bind(&fn_3,a,a,_4));
    min_arity<9>(boost::bind(&fn_3,_7,_9,_8));
}

int main()
{
    return boost::report_errors();
}