#include <boost/proto/proto.hpp>
#include <boost/shared_ptr.hpp>

#include <string>
#include <iostream>

// The toy IR
struct Base {
  virtual void print(std::ostream &) = 0;
};

class Reference : public Base {
  std::string name;

public:
  Reference(const std::string &n) : name(n) {};

  const std::string &getName(void) const {
    return name;
  }

  void print(std::ostream &out) {
    out << getName();
  }
};

class Add : public Base {
public:
  typedef boost::shared_ptr<Base> child_ptr;

private:
  child_ptr left;
  child_ptr right;

public:
  Add(child_ptr l, child_ptr r) : left(l), right(r) {};

  void print(std::ostream &out) {
    out << "+ ";
    left->print(out);
    out << " ";
    right->print(out);
  }
};

class Less : public Base {
public:
  typedef boost::shared_ptr<Base> child_ptr;

private:
  child_ptr left;
  child_ptr right;

public:
  Less(child_ptr l, child_ptr r) : left(l), right(r) {};

  void print(std::ostream &out) {
    out << "< ";
    left->print(out);
    out << " ";
    right->print(out);
  }
};

class Assign : public Base {
public:
  typedef boost::shared_ptr<Base> child_ptr;

private:
  child_ptr left;
  child_ptr right;

public:
  Assign(child_ptr l, child_ptr r) : left(l), right(r) {};

  void print(std::ostream &out) {
    out << "= ";
    left->print(out);
    out << " ";
    right->print(out);
  }
};

class If : public Base {
public:
  typedef boost::shared_ptr<Base> child_ptr;

private:
  child_ptr left;
  child_ptr right;

public:
  If(child_ptr l, child_ptr r) : left(l), right(r) {};

  void print(std::ostream &out) {
    out << "if ";
    left->print(out);
    out << " ";
    right->print(out);
  }
};

// Define grammar
struct ConstructExpressionGrammar;
struct ConstructStatementGrammar;
struct ConstructGrammar;

namespace keyword {
  struct if_ { friend std::ostream& operator<<(std::ostream& sout, if_) { return sout << "if_"; } };
  struct else_ { friend std::ostream& operator<<(std::ostream& sout, else_) { return sout << "else_"; } };
  struct do_ { friend std::ostream& operator<<(std::ostream& sout, do_) { return sout << "do_"; } };
  struct while_ { friend std::ostream& operator<<(std::ostream& sout, while_) { return sout << "while_"; } };
}

class Domain;

// Expression wrapper
template<class Expr/*, class Dummy = boost::proto::is_proto_expr*/>
struct Expression {
  BOOST_PROTO_EXTENDS(Expr, Expression<Expr>, Domain)

  // Use BOOST_PROTO_EXTENDS_MEMBERS() to define "virtual"
  // data members that all expressions in the mini-lambda
  // domain will have. They can be used to create expressions
  // like "if_(x)[y].else_[z]" and "do_[y].while_(z)".
  BOOST_PROTO_EXTENDS_MEMBERS(
    ((keyword::else_,   else_))
    ((keyword::while_,  while_))
  )
};

// Convenience typedefs
typedef Expression<boost::proto::terminal<boost::shared_ptr<Reference> >::type>
        Variable;
typedef Expression<boost::proto::terminal<keyword::if_>::type> IfTerminal;
typedef boost::proto::plus<ConstructExpressionGrammar,
			   ConstructExpressionGrammar> AddRule;
typedef boost::proto::less<ConstructExpressionGrammar,
			   ConstructExpressionGrammar> LessRule;
typedef boost::proto::assign<ConstructExpressionGrammar,
			     ConstructExpressionGrammar> AssignRule;
typedef boost::proto::subscript<
  boost::proto::function<
    IfTerminal,
    ConstructExpressionGrammar
    >,
  ConstructStatementGrammar
  > IfRule;

// Semantic Actions
// Transform a one-operand node
template<typename NodeType,
	 typename Child = typename NodeType::child_ptr,
	 typename Dummy = boost::proto::callable>
struct ConstructUnary : boost::proto::callable {
  typedef boost::shared_ptr<NodeType> result_type;
  
  result_type operator()(Child child) {
    return result_type(new NodeType(child));
  }
};

// Transform a two-operand node
template<typename NodeType,
	 typename Child = typename NodeType::child_ptr,
	 typename Dummy = boost::proto::callable>
struct ConstructBinary : boost::proto::callable {
  typedef boost::shared_ptr<NodeType> result_type;

  result_type operator()(Child left, Child right) {
    return result_type(new NodeType(left, right));
  }
};

// Grammar rules
struct ConstructExpressionGrammarCases {
  // The primary template matches nothing:
  template<typename Tag>
  struct case_ : boost::proto::not_<boost::proto::_> {};
};

template<>
struct ConstructExpressionGrammarCases::case_<boost::proto::tag::terminal>
  : boost::proto::or_<
  boost::proto::when<
    Variable,
    boost::proto::_value> > {};

template<>
struct ConstructExpressionGrammarCases::case_<boost::proto::tag::plus>
  : boost::proto::when<
  AddRule,
  ConstructBinary<
    Add,
    boost::shared_ptr<Base> >(ConstructExpressionGrammar(boost::proto::_left),
			      ConstructExpressionGrammar(boost::proto::_right))> {};

template<>
struct ConstructExpressionGrammarCases::case_<boost::proto::tag::less>
  : boost::proto::when<
  LessRule,
  ConstructBinary<
    Less,
    boost::shared_ptr<Base> >(ConstructExpressionGrammar(boost::proto::_left),
			      ConstructExpressionGrammar(boost::proto::_right))> {};

struct ConstructExpressionGrammar :
  boost::proto::switch_<ConstructExpressionGrammarCases> {};

struct ConstructStatementGrammarCases {
  // The primary template matches nothing:
#ifdef NO_SPECIALIZATION
  template<typename Tag>
  struct case_ : boost::proto::when<
    IfRule,
    ConstructBinary<If>(ConstructExpressionGrammar(boost::proto::_right(boost::proto::_left)),
			ConstructStatementGrammar(boost::proto::_right))> {};
#else
  template<typename Tag>
  struct case_ : boost::proto::not_<boost::proto::_> {};
#endif
};

template<>
struct ConstructStatementGrammarCases::case_<boost::proto::tag::assign>
  : boost::proto::when<
  AssignRule,
  ConstructBinary<
    Assign,
    boost::shared_ptr<Base> >(ConstructExpressionGrammar(boost::proto::_left),
			      ConstructExpressionGrammar(boost::proto::_right))> {};

#ifdef NO_SPECIALIZATION
template<>
struct ConstructStatementGrammarCases::case_<boost::proto::tag::subscript>
  : boost::proto::when<
  IfRule,
  ConstructBinary<If>(ConstructExpressionGrammar(boost::proto::_right(boost::proto::_left)),
		      ConstructStatementGrammar(boost::proto::_right))> {};
#endif

struct ConstructStatementGrammar :
  boost::proto::switch_<ConstructStatementGrammarCases> {};

// General IR grammar.
struct ConstructGrammar
  : boost::proto::or_<
  ConstructExpressionGrammar,
  ConstructStatementGrammar> {};

struct Domain : boost::proto::domain<boost::proto::pod_generator<Expression> > {};

// An if_ "operator"
template<typename Expr>
typename boost::proto::result_of::make_expr<
    boost::proto::tag::function,
    Domain,
    keyword::if_,
    Expr const &>::type
if_(Expr const &expr)
{
  return boost::proto::make_expr<boost::proto::tag::function, Domain>(
    keyword::if_(),
    boost::ref(expr));
}

template<typename Expr>
boost::shared_ptr<Base> translate(const Expr &expr) {
  ConstructGrammar trans;
  return trans(expr);
}

int main(void)
{
  Variable a = {{boost::shared_ptr<Reference>(new Reference("a"))}};
  Variable b = {{boost::shared_ptr<Reference>(new Reference("b"))}};
  Variable c = {{boost::shared_ptr<Reference>(new Reference("c"))}} ;

  boost::proto::display_expr(
    if_(a < b) [
      a = a + c
    ]
  );

  //#if 0
  // Does not compile.
  boost::shared_ptr<Base> expr = translate(
    if_(a < b) [
      a = a + c
    ]
  );

  expr->print(std::cout);
  std::cout << '\n';
  //#endif

  return 0;
}