#include <map>
#include <vector>
#include <cassert>
#include <iostream>
#include <boost/proto/proto.hpp>
#include <boost/proto/proto_typeof.hpp>

#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()

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

struct program_tag
{};

template<class T>
struct program_variable
{};

template<class E>
struct fragment_expr;

template<class E>
struct program_expr;

struct slot
{
    template<typename T, typename Map>
    slot(program_variable<T> const &var, Map &map)
      : i_((*map.insert(std::make_pair(&var, map.size())).first).second)
    {}

    int i_;
};

BOOST_TYPEOF_REGISTER_TYPE(slot)
BOOST_TYPEOF_REGISTER_TYPE(program_tag)
BOOST_TYPEOF_REGISTER_TEMPLATE(fragment_expr, (typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(program_expr, (typename))

struct program_args
  : proto::or_<
        proto::terminal<program_variable<_> >
      , proto::address_of<proto::terminal<program_variable<_> > >
    >
{};

struct program_decl
  : proto::nary_expr<program_tag, proto::vararg<program_args> >
{};

struct program_rewrite;

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

    template<typename This, typename Expr>
    struct result<This(Expr)>
    {
        typedef typename boost::add_reference<typename boost::add_const<Expr>::type>::type expr_type;
        typedef typename boost::result_of<program_rewrite(expr_type)>::type program_type;
        typedef program_expr<program_type> type;
    };

    template<typename Expr>
    typename result<compile_program(Expr const &)>::type
    operator ()(Expr const &expr) const
    {
        std::map<void const *, int> state;
        typedef result<compile_program(Expr const &)> result_;
        typename result_::program_type prog = program_rewrite()(expr, state);
        typename result_::type that = {prog, state};
        return that;
    }
};

struct program_rewrite
  : proto::or_<
        proto::when<
            proto::terminal<program_variable<_> >
          , proto::_make_terminal(slot(proto::_value, proto::_state))
        >
      , proto::when<
            proto::terminal<_>
          , proto::_make_terminal(proto::_byval(proto::_value))
        >
      , proto::nary_expr<_, proto::vararg<program_rewrite> >
    >
{};

struct program_generator
  : proto::or_<
        proto::when<
            proto::subscript<program_decl, _>
          , compile_program(_)
        >
      , proto::otherwise<
            proto::pod_generator<fragment_expr>(_)
        >
    >
{};

struct program_domain
  : proto::domain<program_generator>
{};

struct get_slot : proto::callable
{
    typedef int &result_type;

    int &operator ()(slot const &s, std::vector<int> &args) const
    {
        return args[s.i_];
    }
};

struct program_eval
  : proto::or_<
        proto::when<
            proto::terminal<slot>
          , get_slot(proto::_value, proto::_state)
        >
      , proto::otherwise<
            proto::_default<program_eval>
        >
    >
{};

template<class E>
struct program_expr
{
    // E is "Program(args...)[ program ]". It is a binary subscript
    // expression.
    BOOST_PROTO_BASIC_EXTENDS(E, program_expr<E>, program_domain)

    // TODO: generate this signature from information on the LHS
    void operator ()(int &ra, int b) const
    {
        std::vector<int> state(slots_.size(), 0);
        state[0] = ra;
        state[1] = b;
        program_eval()(proto::right(*this), state);
        ra = state[0];
    }

    std::map<void const *, int> slots_;
};

template<class E>
struct fragment_expr
{
    BOOST_PROTO_EXTENDS(E, fragment_expr<E>, program_domain)
};

typedef fragment_expr<proto::terminal<program_variable<int> >::type> int_;

#define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref, A_const_ref_a, ref_a)                       \
template<typename_A(N)>                                                                                 \
typename boost::proto::result_of::make_expr<program_tag, program_domain, A_const_ref(N)>::type const    \
Program(A_const_ref_a(N))                                                                               \
{                                                                                                       \
    return proto::make_expr<program_tag, program_domain>(ref_a(N));                                     \
}                                                                                                       \
/**/

#include BOOST_PROTO_LOCAL_ITERATE()

int main()
{
    int_ a,b,c;
    BOOST_AUTO( p, (Program(&a,b) [c = b*2, a = c]) );

    int ra = 0;
    p(ra, 4);

    assert(8 == ra);
    std::cout << ra << std::endl;
}