#include <boost/fusion/container/vector.hpp>
#include <boost/proto/proto.hpp>
#include <iostream>
#include "function.hpp"

using namespace std;

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

template<class Expr>
struct actor;

struct phoenix_domain
  : proto::domain<proto::pod_generator<actor> >
{};

struct eval;

template<class Expr>
struct actor {
  BOOST_PROTO_BASIC_EXTENDS(Expr, actor<Expr>, phoenix_domain)
  BOOST_PROTO_EXTENDS_SUBSCRIPT()

  template<typename Sig>
  struct result;

  typedef actor<Expr> actor_type;
  
  template<typename E, typename A0>
  struct result<E(A0)>
    : boost::result_of<eval(E&, fusion::vector<A0>&)>
  {};

  template<typename E, typename A0, typename A1>
  struct result<E(A0, A1)>
    : boost::result_of<eval(E&, fusion::vector<A0, A1>&)>
  {};

  template<typename A0>
  typename boost::result_of<actor_type(const A0 &)>::type
  operator()(const A0 &a0) const
  {
    fusion::vector<const A0 &> args(a0);
    return eval()(*this, args);
  }

  template<typename A0, typename A1>
  typename boost::result_of<actor_type(const A0 &, const A1 &)>::type
  operator()(const A0 &a0, const A1 &a1) const
  {
    fusion::vector<const A0 &, const A1 &> args(a0, a1);
    return eval()(*this, args);
  }

};

template<typename>
struct arg {};

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

  template<class This, class Cont, class N>
  struct result<This(Cont &, const arg<N> &)>
    : fusion::result_of::at<Cont, N>
  {};

  template<class This, class Cont, class N>
  struct result<This(Cont &, arg<N> &)>
    : fusion::result_of::at<Cont, N>
  {};

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


actor<proto::terminal<arg<mpl::int_<0> > >::type> const _1 = {{{}}};
actor<proto::terminal<arg<mpl::int_<1> > >::type> const _2 = {{{}}};
actor<proto::terminal<arg<mpl::int_<2> > >::type> const _3 = {{{}}};

struct eval
  : proto::or_<
proto::function<apply_tag, const function&, eval>,
    proto::when<proto::terminal<arg<proto::_> >, at(proto::_state, proto::_value)>
  , proto::when<proto::_, proto::_default<eval> >
> {};

int main()
{
  int i = 41;

  int j = (_1+1)(i);

  function func1 = _1 + func1(_1);

  func1.display();
  cout << j << "\n";

  return 0;
}