#include <iosfwd>
#include <boost/mpl/int.hpp>
#include <boost/fusion/container/vector/vector10.hpp>
#include <boost/proto/proto.hpp>

#define BOOST_PHOENIX_LIMIT 10
#define BOOST_PHOENIX_ARG_LIMIT BOOST_PHOENIX_LIMIT

namespace boost
{
    namespace phoenix
    {
        ////////////////////////////////////////////////////////////////////////////////////////////
        struct evaluator;

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename Expr>
        struct actor;

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct make_actor
          : proto::call<proto::pod_generator<actor>(proto::_)>
        {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct generator_cases
        {
            template<typename>
            struct case_
              : proto::when<proto::_, make_actor>
            {};
        };

        namespace detail
        {
            ////////////////////////////////////////////////////////////////////////////////////////////
            struct generator
              : proto::switch_<generator_cases>
            {};

            ////////////////////////////////////////////////////////////////////////////////////////////
            struct domain
              : proto::domain<generator>
            {};

            ////////////////////////////////////////////////////////////////////////////////////////
            template<typename Int>
            struct argument
            {
                typedef typename Int::tag tag;
                typedef typename Int::value_type value_type;
                typedef argument<Int> type;
                typedef argument<typename Int::next> next;
                typedef argument<typename Int::prior> prior;
                static value_type const value = Int::value;

                friend std::ostream &operator<<(std::ostream &sout, argument<Int>)
                {
                    return sout << "boost::phoenix::arg_names::arg" << (Int::value+1);
                }
            };

            template<typename Int>
            typename Int::value_type const argument<Int>::value;

            ////////////////////////////////////////////////////////////////////////////////////////
            struct at : proto::callable
            {
                template<typename Sig>
                struct result;

                template<typename This, typename Cont, typename Arg>
                struct result<This(Cont &, Arg &)>
                  : fusion::result_of::at<Cont, Arg>
                {};

                template<typename Cont, typename Arg>
                typename fusion::result_of::at<Cont, Arg>::type
                operator ()(Cont &cont, Arg &) const
                {
                    return fusion::at<Arg>(cont);
                }
            };

            ////////////////////////////////////////////////////////////////////////////////////////
            template<typename Sig>
            struct result;

            template<typename This>
            struct result<This()>
              : result_of<evaluator(This &, int const &, fusion::vector0 &)>
            {};

            #define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A, A_const_ref_a, ref_a)                     \
            template<typename This, typename_A(N)>                                                      \
            struct result<This(A(N))>                                                                   \
              : result_of<evaluator(This &, int const &, BOOST_PP_CAT(fusion::vector, N)<A(N)> &)>      \
            {};                                                                                         \
            /**/

            #define BOOST_PROTO_LOCAL_A BOOST_PROTO_A
            #define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PHOENIX_ARG_LIMIT)
            #include BOOST_PROTO_LOCAL_ITERATE()
        }

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct evaluator_cases
        {
            template<typename>
            struct case_
              : proto::when<proto::_, proto::_default<evaluator> >
            {};
        };

        template<>
        struct evaluator_cases::case_<proto::tag::terminal>
          : proto::or_<
                proto::when<
                    proto::terminal<detail::argument<proto::_> >
                  , detail::at(proto::_data, proto::_value)
                >
              , proto::otherwise<proto::_default<evaluator> >
            >
        {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct evaluator
          : proto::switch_<evaluator_cases>
        {};

        #define BOOST_PHOENIX_INVOKE(N, typename_A, A_const_ref, A_const_ref_a, a)                  \
        template<typename_A(N)>                                                                     \
        typename detail::result<proto_derived_expr const(A_const_ref(N))>::type                     \
        operator()(A_const_ref_a(N)) const                                                          \
        {                                                                                           \
            BOOST_PP_CAT(fusion::vector, N)<A_const_ref(N)> args(a(N));                             \
            return evaluator()(*this, 0, args);                                                     \
        }                                                                                           \
        /**/

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename Expr>
        struct actor
        {
            BOOST_PROTO_BASIC_EXTENDS(Expr, actor<Expr>, detail::domain)

            template<typename Sig>
            struct result : detail::result<Sig>
            {};

            // TODO: handle nullary lambdas
            #define BOOST_PROTO_LOCAL_MACRO BOOST_PHOENIX_INVOKE
            #define BOOST_PROTO_LOCAL_a BOOST_PROTO_a
            #define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PHOENIX_ARG_LIMIT)
            #include BOOST_PROTO_LOCAL_ITERATE()
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<int I, typename _ = proto::is_proto_expr>
        struct argument
        {
            typedef
                typename proto::terminal<detail::argument<mpl::int_<I> > >::type
            base_type;

            BOOST_PROTO_BASIC_EXTENDS(base_type, argument<I>, detail::domain)

            // For backwards compatibility
            operator actor<argument<I> > const &() const
            {
                return argument<I,_>::argI;
            }

            static actor<argument<I> > const argI;
        };

        template<int I, typename _>
        actor<argument<I> > const argument<I,_>::argI = {{{{}}}};

        ////////////////////////////////////////////////////////////////////////////////////////////
        namespace arg_names
        {
        //  Phoenix style names
            actor<argument<0> > const arg1  = {{{{}}}};
            actor<argument<1> > const arg2  = {{{{}}}};
            actor<argument<2> > const arg3  = {{{{}}}};

        //  BLL style names
            actor<argument<0> > const _1    = {{{{}}}};
            actor<argument<1> > const _2    = {{{{}}}};
            actor<argument<2> > const _3    = {{{{}}}};

        //  Bring in the rest or the Phoenix style arguments (arg4 .. argN+1)
        //  and BLL style arguments (_4 .. _N+1), using PP
            #define BOOST_PHOENIX_DECLARE_ARG(Z, N, DATA)                                                     \
            actor<argument<N> > const BOOST_PP_CAT(arg, BOOST_PP_INC(N))  = {{{{}}}};                   \
            actor<argument<N> > const BOOST_PP_CAT(_, BOOST_PP_INC(N))    = {{{{}}}};                   \
            /**/

            BOOST_PP_REPEAT_FROM_TO(3, BOOST_PHOENIX_ARG_LIMIT, BOOST_PHOENIX_DECLARE_ARG, _)
            #undef BOOST_PHOENIX_DECLARE_ARG
        }

        //
        // Begin implementation of if_/else_ here
        //

        namespace tag
        {
            struct if_ {};
            struct else_ {};
        }

        namespace detail
        {
            // Proto transform for evaluating lambdas like: if_(foo)[bar]
            struct if_evaluator : proto::transform<if_evaluator>
            {
                template<typename Expr, typename State, typename Data>
                struct impl : proto::transform_impl<Expr, State, Data>
                {
                    typedef void result_type;
                    void operator()(
                        typename impl::expr_param e
                      , typename impl::state_param s
                      , typename impl::data_param d
                    ) const
                    {
                        if(evaluator()(proto::child_c<0>(e), s, d))
                        {
                            evaluator()(proto::child_c<1>(e), s, d);
                        }
                    }
                };
            };

            // Proto transform for evaluating lambdas like: if_(foo)[bar].else_[baz]
            struct else_evaluator : proto::transform<else_evaluator>
            {
                template<typename Expr, typename State, typename Data>
                struct impl : proto::transform_impl<Expr, State, Data>
                {
                    typedef void result_type;
                    void operator()(
                        typename impl::expr_param e
                      , typename impl::state_param s
                      , typename impl::data_param d
                    ) const
                    {
                        if(evaluator()(proto::child_c<0>(e), s, d))
                        {
                            evaluator()(proto::child_c<1>(e), s, d);
                        }
                        else
                        {
                            evaluator()(proto::child_c<2>(e), s, d);
                        }
                    }
                };
            };
        }

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename Expr>
        struct actor_with_else
        {
            BOOST_PROTO_BASIC_EXTENDS(Expr, actor_with_else<Expr>, detail::domain)

            template<typename Sig>
            struct result : detail::result<Sig>
            {};

            // TODO: handle nullary lambdas
            #define BOOST_PROTO_LOCAL_MACRO BOOST_PHOENIX_INVOKE
            #define BOOST_PROTO_LOCAL_a BOOST_PROTO_a
            #define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PHOENIX_ARG_LIMIT)
            #include BOOST_PROTO_LOCAL_ITERATE()

            typedef typename proto::result_of::child_c<Expr const &, 0>::type A;
            typedef typename proto::result_of::child_c<Expr const &, 1>::type B;

            // if_ statements get an else_ defined thusly:
            struct else_type
            {
                template<typename C>
                typename proto::result_of::make_expr<tag::else_, detail::domain, A, B, C const &>::type
                operator[](C const &c) const
                {
                    actor_with_else const & cond
                      = *(actor_with_else const *)
                        ((char *)this - BOOST_PROTO_OFFSETOF(actor_with_else, else_));

                    return proto::make_expr<tag::else_, detail::domain>(
                        boost::ref(proto::child_c<0>(cond))
                      , boost::ref(proto::child_c<1>(cond))
                      , boost::ref(c)
                    );
                }
            } else_;
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct make_actor_with_else
          : proto::call<proto::pod_generator<actor_with_else>(proto::_)>
        {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        struct if_type
        {
            template<typename A>
            struct stmt
            {
                template<typename B>
                typename proto::result_of::make_expr<tag::if_, detail::domain, A const &, B const &>::type
                operator[](B const &b) const
                {
                    return proto::make_expr<tag::if_, detail::domain>(boost::ref(a), boost::ref(b));
                }

                A const &a;
            };

            template<typename A>
            stmt<A> operator()(A const &a) const
            {
                stmt<A> ret = {a};
                return ret;
            }
        } const if_ = {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        // This instructs Proto to wrap if_ expressions in actor_with_else
        template<>
        struct generator_cases::case_<tag::if_>
          : proto::when<proto::_, make_actor_with_else>
        {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        // This tells Proto how to evaluate if_ statements with the if_evaluator
        template<>
        struct evaluator_cases::case_<tag::if_>
          : proto::when<proto::_, detail::if_evaluator>
        {};

        ////////////////////////////////////////////////////////////////////////////////////////////
        // This tells Proto how to evaluate else_ statements with the else_evaluator
        template<>
        struct evaluator_cases::case_<tag::else_>
          : proto::when<proto::_, detail::else_evaluator>
        {};
    }
}

#include <iostream>
#include <typeinfo>
namespace proto = boost::proto;
namespace phoenix = boost::phoenix;
using namespace phoenix::arg_names;

int main()
{
    proto::display_expr(_1 + _2);

    int j = (_1 + _2)(1, 2);
    std::cout << j << "\n";

    j = (_2 * 2)(1, 2);
    std::cout << j << "\n";

    char const *name = typeid(phoenix::if_(_1)[_2].else_).name();
    std::cout << name << "\n";

    name = typeid(phoenix::if_(_1)[_2].else_[_1]).name();
    std::cout << name << "\n";

    phoenix::if_(_1)[_2].else_[_3](1,2,3);
    phoenix::if_(_1)[_2].else_[_3](0,2,3);
}