#include <boost/proto/proto.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/make_vector.hpp>
#include <iostream>

#ifdef _MSC_VER
#pragma warning(disable: 4355)
#endif

namespace boost { namespace proto
{
    struct external;

    template<typename Grammar>
    struct when<Grammar, external>
    {
        typedef typename Grammar::proto_grammar proto_grammar;

        template<typename Expr, typename State, typename Data>
        struct impl
          : Data::template when<Grammar>::template impl<Expr, State, Data>
        {};

        template<typename Expr, typename State, typename Data>
        struct impl<Expr, State, Data &>
          : Data::template when<Grammar>::template impl<Expr, State, Data &>
        {};
    };
}}

namespace mpl = boost::mpl;
namespace proto = boost::proto;
namespace fusion = boost::fusion;
using proto::_;

// A transform that packs the state and data parameter
struct _phoenix_env
  : proto::transform<_phoenix_env>
{
    template<typename Expr, typename State, typename Data>
    struct impl
      : proto::transform_impl<Expr, State, Data>
    {
        typedef fusion::vector2<State, Data> result_type;

        result_type operator()(
            typename impl::expr_param
          , typename impl::state_param s
          , typename impl::data_param d
        ) const
        {
            return fusion::vector2<State, Data>(s, d);
        };
    };
};

namespace functional
{
    template<typename N, typename Callable = proto::callable>
    struct at
      : proto::callable
    {
        typedef typename boost::remove_reference<N>::type index;

        template<typename Sig>
        struct result;

        template<typename This, typename Seq>
        struct result<This(Seq)>
          : fusion::result_of::at_c<
                typename boost::remove_reference<Seq>::type
              , index::value
            >
        {};

        template<typename Seq>
        typename result<at(Seq &)>::type
        operator()(Seq &seq) const
        {
            return fusion::at_c<index::value>(seq);
        }
    };

    typedef at<mpl::int_<0> > params;
    typedef at<mpl::int_<1> > actions;

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

        template<typename This, typename N, typename Env>
        struct result<This(N, Env)>
          : boost::result_of<at<N>(typename boost::result_of<params(Env)>::type)>
        {};

        template<typename N, typename Env>
        typename result<param_at(N, Env &)>::type
        operator()(N const &, Env &env) const
        {
            return at<N>()(params()(env));
        }
    };
}

// A collection of semantic actions, indexed by phoenix grammar rules
struct PhoenixDefaultActions
{
    template<typename Rule>
    struct when;
};

struct PhoenixGrammar;

// The Phoenix "default" rule, which handles most operands by
// delegating to proto::_default.
struct PhoenixRuleDefault
  : proto::_default< PhoenixGrammar >
{};

// Add to the collection of semantic actions the thing to
// do in the "default" case.
template<>
struct PhoenixDefaultActions::when<PhoenixRuleDefault>
  : proto::_default< PhoenixGrammar >
{};

// An openly extensible collection of phoenix rules and actions.
// "Tag" here is an expression tag.
struct PhoenixGrammar
  : proto::switch_<PhoenixGrammar>
{
    template<typename Tag>
    struct case_
      : proto::when<PhoenixRuleDefault, proto::external>
    {};
};

// Hide the fact that there is an Actions parameter being
// passed around as Data. The user shouldn't care.
struct PhoenixEval
  : proto::call<
        PhoenixGrammar(_, functional::params(proto::_state), functional::actions(proto::_state))
    >
{};

// Define placeholders
template<typename I>
struct placeholder
{
    typedef I type;
    typedef typename I::value_type value_type;
    static value_type const value = I::value;
};

// Here is the arg1 placeholder
proto::terminal<placeholder<mpl::int_<0> > >::type const arg1 = {};

// The phoenix rule for matching placeholder
// (Can later be generalized with boost::is_placeholer)
struct PhoenixRulePlaceholder
  : proto::terminal<placeholder<_> >
{};

// The action to take for placeholders
template<>
struct PhoenixDefaultActions::when<PhoenixRulePlaceholder>
  : proto::call<functional::param_at(proto::_value, _phoenix_env)>
{};

// Customization point for special terminal handling
template<typename T>
struct is_custom_terminal
  : mpl::false_
{};

// Customization point for special terminal handling
template<typename T>
struct get_custom_terminal;

// Phoenix rule for matching custom terminals
struct PhoenixRuleCustomTerminal
  : proto::if_<is_custom_terminal<proto::_value>()>
{};

// Phoenix action to take for custom terminals
template<>
struct PhoenixDefaultActions::when<PhoenixRuleCustomTerminal>
  : proto::lazy<get_custom_terminal<proto::_value>(proto::_value)>
{};

// Rules for terminals
template<>
struct PhoenixGrammar::case_<proto::tag::terminal>
  : proto::or_<
        proto::when<PhoenixRulePlaceholder, proto::external>
      , proto::when<PhoenixRuleCustomTerminal, proto::external>
      , proto::when<PhoenixRuleDefault, proto::external>
    >
{};

// Create a phoenix terminal, stored by value
template<typename T>
typename proto::terminal<T>::type const val(T t)
{
    return proto::terminal<T>::type::make(t);
}

// Create a phoenix terminal, stored by reference
template<typename T>
typename proto::terminal<boost::reference_wrapper<T> >::type const ref(T &t)
{
    return proto::terminal<boost::reference_wrapper<T> >::type::make(boost::ref(t));
}

// Create a phoenix terminal, stored by const reference
template<typename T>
typename proto::terminal<boost::reference_wrapper<T const> >::type const cref(T const &t)
{
    return proto::terminal<boost::reference_wrapper<T const> >::type::make(boost::cref(t));
}

// Call out boost::reference_wrapper for special handling
template<typename T>
struct is_custom_terminal<boost::reference_wrapper<T> >
  : mpl::true_
{};

// Special handling for boost::reference_wrapper
template<typename T>
struct get_custom_terminal<boost::reference_wrapper<T> >
{
    typedef T &result_type;

    T &operator()(boost::reference_wrapper<T> r) const
    {
        return r;
    }
};

//-----
// Begin if_/then_/else_ implementation
//-----

// Define some tags for additional statements
namespace tag
{
    struct if_then {};
    struct if_then_else {};
}

template<typename Cond, typename Then, typename Else>
struct if_then_else
  : proto::nary_expr<tag::if_then_else, Cond, Then, Else>
{};

template<typename Cond, typename Then>
struct else_gen
{
    else_gen(Cond const& cond, Then const& then)
      : cond(cond)
      , then(then)
    {}

    template <typename Else>
    typename if_then_else<Cond, Then, Else>::type const
    operator[](Else const &else_) const
    {
        return if_then_else<Cond, Then, Else>::type::make(cond, then, else_);
    }

    Cond const &cond;
    Then const &then;
};

template<typename Expr>
struct if_expr
  : Expr
{
    if_expr(Expr const& expr)
      : Expr(expr)
      , else_(proto::child_c<0>(*this), proto::child_c<1>(*this))
    {}

    typedef typename proto::result_of::child_c<Expr, 0>::type cond_type;
    typedef typename proto::result_of::child_c<Expr, 1>::type then_type;
    else_gen<cond_type, then_type> else_;
};

template<typename Cond, typename Then>
struct if_then
  : proto::binary_expr<tag::if_then, Cond, Then>
{};

template<typename Cond>
struct if_gen
{
    explicit if_gen(Cond const& cond)
      : cond(cond)
    {}

    template<typename Then>
    if_expr<typename if_then<Cond const &, Then const &>::type> const
    operator[](Then const &then) const
    {
        return if_then<Cond const &, Then const &>::type::make(cond, then);
    }

    Cond const &cond;
};

template <typename Cond>
if_gen<Cond> const if_(Cond const &cond)
{
    return if_gen<Cond>(cond);
}

// Callable for evaluating if_/then_ statements
//template<typename Actions>
struct if_then_eval : proto::callable
{
    typedef void result_type;

    template <typename Cond, typename Then, typename Env>
    result_type operator()(Cond const& cond, Then const& then, Env& env) const
    {
        if(PhoenixEval()(cond, env))
        {
            PhoenixEval()(then, env);
        }
    }
};

// Phoenix rule for matching if_/then_ statements
struct PhoenixRuleIfThen
  : if_then<PhoenixGrammar, PhoenixGrammar>
{};

// Phoenix action to take for if_/then_ statements
template<>
struct PhoenixDefaultActions::when<PhoenixRuleIfThen>
  : proto::call<if_then_eval(proto::_child0, proto::_child1, _phoenix_env)>
{};

// Bind actions to rules for if_/then_ statements
template<>
struct PhoenixGrammar::case_<tag::if_then>
  : proto::when<PhoenixRuleIfThen, proto::external>
{};

// Callable for evaluating if_/then_/else_ statements
struct if_then_else_eval : proto::callable
{
    typedef void result_type;

    template <typename Cond, typename Then, typename Else, typename Env>
    result_type operator()(Cond const& cond, Then const& then, Else const& else_, Env& env) const
    {
        if(PhoenixEval()(cond, env))
        {
            PhoenixEval()(then, env);
        }
        else
        {
            PhoenixEval()(else_, env);
        }
    }
};

// Phoenix rule for matching custom terminals
struct PhoenixRuleIfThenElse
  : if_then_else<PhoenixGrammar, PhoenixGrammar, PhoenixGrammar>
{};

// Phoenix action to take for custom terminals
template<> //typename Actions>
struct PhoenixDefaultActions::when<PhoenixRuleIfThenElse>
  : proto::call<if_then_else_eval(proto::_child0, proto::_child1, proto::_child2, _phoenix_env)>
{};

// Bind actions to rules for terminals
template<>
struct PhoenixGrammar::case_<tag::if_then_else >
  : proto::when<PhoenixRuleIfThenElse, proto::external>
{};

//-----
// End if_/then_/else_ implementation
//-----

// With this set of semantic actions, we can easily force
// arg1 to always evaluate to int(0). Nice little example
// of how the Phoenix expression evaluator can be customized.
struct MyActions
{
    template<typename Rule>
    struct when
      : PhoenixDefaultActions::when<Rule>
    {};
};

template<>
struct MyActions::when<PhoenixRulePlaceholder>
  : proto::make<int()>
{};

int main()
{
    PhoenixEval phoenix_eval;
    typedef fusion::vector1<int> params_type;
    fusion::vector2< params_type, PhoenixDefaultActions > env(params_type(42), PhoenixDefaultActions());
    proto::literal<int> i(1), j(2);

    int k = phoenix_eval(i + j, env);
    std::cout << k << std::endl; // should be 3

    k = phoenix_eval(i + arg1, env);
    std::cout << k << std::endl; // should be 43

    k = phoenix_eval(cref(7), env);
    std::cout << k << std::endl; // should be 7

    phoenix_eval( if_(i == 1)[ ++i ], env);
    std::cout << i.get() << std::endl; // should be 2

    phoenix_eval( if_(i == 1)[ ++i ].else_[ --i ], env);
    std::cout << i.get() << std::endl; // should be 1

    // Test for custom semantic actions
    fusion::vector2< params_type, MyActions > my_env(params_type(42), MyActions());
    k = phoenix_eval( arg1 + 7, my_env );
    std::cout << k << std::endl; // should be 7
}