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

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

template<typename T>
struct program_variable {
  T value;
  friend std::ostream &operator<<(std::ostream &s, program_variable<T> v) {
    s << "V";
    return s;
  }
};

struct program_tag
{
  friend std::ostream &operator<<(std::ostream &s, program_tag v) {
    s << "Program";
    return s;
  }
};

template<class E>
struct fragment_expr;

template<class E>
struct program_expr;

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_generator
  : proto::or_<
proto::when<
proto::subscript<program_decl, _>
, proto::pod_generator<program_expr>(_)
>
, proto::otherwise<
  proto::pod_generator<fragment_expr>(_)
  >
>
{};

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

struct get_val : proto::callable
{
  template<typename Sig>
  struct result;
  
  template<typename This, typename T>
  struct result<This(program_variable<T> &)> {
    typedef T& type;
  };

  template<typename T>
  typename result<get_val(program_variable<T> &)>::type
  operator()(program_variable<T> &var) const {
    return var.value;
  }
};

struct program_eval
  : proto::or_<
proto::when<
proto::terminal<program_variable<_> >
, get_val(proto::_value)
>
, proto::otherwise<
  proto::_default<program_eval>
  >
>
{};

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

template<class E>
struct program_expr
{
  BOOST_PROTO_BASIC_EXTENDS(E, program_expr<E>, program_domain)
  
  typedef void result_type;

  // TODO : Make the type based on the type of E
  result_type operator()(int &a0, int &a1) const {
    proto::value(proto::left(proto::left(proto::left(*this)))).value = a0;
    proto::value(proto::left(proto::right(proto::left(*this)))).value = a1;
    program_eval()(proto::right(*this));
    a0 = proto::value(proto::left(proto::left(proto::left(*this)))).value;
    a1 = proto::value(proto::left(proto::right(proto::left(*this)))).value;
  }
  
};

typedef fragment_expr<proto::terminal<program_variable<int> >::type> int_;
typedef fragment_expr<proto::terminal<program_variable<float> >::type> float_;
typedef fragment_expr<proto::terminal<program_variable<double> >::type> double_;

#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, rb = 4;
  p(ra, rb);
  assert(8 == ra);
  std::cout << "ra = " << ra << "\n";
  
  return 0;
}