#include <boost/proto/proto.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/fusion/iterator.hpp>
#include <boost/fusion/include/transform.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/bind.hpp>

#include <tr1/memory>
#include <iostream>
#include <vector>

class Type {
public:
  virtual void print(void) const = 0;  
};

// The toy IR
class IntType : public Type { 
  int sz;
public:
  IntType(int s) : sz(s) {};
  int size(void) const {
    return sz;
  }

  void print(void) const {
    std::cout << "int" << size();
  }
};

class TypeList : public Type {
  typedef std::vector<std::tr1::shared_ptr<Type> > ListType;
  ListType types;

  void push_back(std::tr1::shared_ptr<Type> t) {
    types.push_back(t);
  }

public:
  TypeList(std::tr1::shared_ptr<Type> member) {
    types.push_back(member);
  }

  template<typename Sequence>
  TypeList(Sequence members) {
    // Add the member types.
    typedef typename boost::fusion::result_of::begin<Sequence>::type begType;
    typedef typename boost::fusion::result_of::end<Sequence>::type endType;
    unsigned dist =
      boost::fusion::result_of::distance<begType, endType>::type::value;
    std::cout << dist << " members for list" << std::endl;

    boost::fusion::for_each(members,
                            boost::bind(&TypeList::push_back,
                                        this,
                                        _1));
  }

  void print(void) const {
    std::cout << "Type list members:\n";
    for (ListType::const_iterator i = types.begin();
         i != types.end();
         ++i) {
      (*i)->print();
      std::cout << std::endl;
    }
  }
};

template<typename Expr>
std::tr1::shared_ptr<Type> translate(const Expr &e);

// The grammar
namespace keyword {
  struct list {
    friend std::ostream& operator<<(std::ostream& sout, list) {
      return sout << "list";
    }
  };
  struct int_ {
    friend std::ostream& operator<<(std::ostream& sout, int_) {
      return sout << "int_";
    }
  };
}

class Domain;

template<typename Expr/*, typename Dummy = boost::proto::is_proto_expr*/>
struct Wrapper {
  BOOST_PROTO_EXTENDS(Expr, Wrapper<Expr>, Domain)
};

typedef Wrapper<boost::proto::terminal<
                  boost::proto::convertible_to<std::string> 
                  >::type> StringTerminal;
typedef Wrapper<boost::proto::terminal<keyword::list>::type> ListTerminal;
typedef Wrapper<boost::proto::terminal<keyword::int_>::type> IntTerminal;
typedef Wrapper<boost::proto::terminal<
                  boost::proto::convertible_to<int> >::type> IntegerTerminal;

// Matches int_(<int>)
struct IntRule : boost::proto::function<
  IntTerminal,
  IntegerTerminal
  > {};

struct TypeListBody;

struct StrictTypeList : boost::proto::comma<
  TypeListBody,
  IntRule
  > {};

// Matches <inttype>{, <inttpe>}*
struct TypeListBody : boost::proto::or_< 
  IntRule,
  StrictTypeList
  > {};

// Matches list[ <type>{, <type>}* ]
struct TypeListRule : boost::proto::subscript<
  ListTerminal,
  TypeListBody
  > {};

struct TypeRule : boost::proto::or_<
  IntRule,
  TypeListRule
  > {};

// Grammar actions
template<typename SymbolType,
  typename Dummy = boost::proto::callable>
struct UnaryConstructSymbol  : boost::proto::callable {
  typedef std::tr1::shared_ptr<Type> result_type;

  template<typename Arg>
  result_type operator()(Arg a) {
    std::tr1::shared_ptr<Type> sym(new SymbolType(a));
    return sym;
  }
};

/// This is a callable transform to translate a proto expression
/// to a symbol.
template<typename SymbolType>
class TranslateToSymbol : boost::proto::callable {
public:
  typedef std::tr1::shared_ptr<SymbolType> result_type;

  template<typename Expr>
  result_type operator()(const Expr &e) const {
    std::cout << "Translating to symbol:\n";
    boost::proto::display_expr(e);
    return translate(e);
  }
};

/// This is the grammar to build integer types
struct IntBuilder : boost::proto::when<
  IntRule,
  UnaryConstructSymbol<IntType>(boost::proto::_value(boost::proto::_right))
  > {};

namespace detail {
  // Some helpers to translate type lists

  // Translate a list of size > 1
  template<typename ResultType, bool Matches>
  class TranslateListImpl {
  public:
    template<typename List>
    ResultType operator()(const List typeList) {
      TranslateToSymbol<Type> translator;
      return boost::fusion::transform(
        boost::proto::flatten(typeList), translator);
    };
  };

  // Translate a list of size 1
  template<typename ResultType>
  class TranslateListImpl<ResultType, false> {
  public:
    template<typename List>
    ResultType operator()(const List typeList) {
      return TranslateToSymbol<Type>()(typeList);
    }
  };

  // Choose whether to translate a single type or a list of types
  template<typename List>
  class TranslateList {
  public:
    typedef typename boost::mpl::if_<
    boost::proto::matches<List, StrictTypeList>,
    typename boost::fusion::result_of::transform<
      const typename boost::proto::result_of::flatten<const List>::type,
      TranslateToSymbol<Type> >::type,
    std::tr1::shared_ptr<Type>
    >::type result_type;

    result_type operator()(const List theList) {
      return TranslateListImpl<result_type,
        boost::proto::matches<List, StrictTypeList>::value>()(theList);
    };
  };

  template<typename List>
  typename TranslateList<List>::result_type
  translateList(List typeList) {
    return TranslateList<List>()(typeList);
  }
}

/// This is a callable transform to construct a type list.
struct ConstructTypeList : boost::proto::callable {
  typedef std::tr1::shared_ptr<Type> result_type;

  template<typename List>
  result_type operator()(List memberList) {
    std::cout << "Building type list:\n";
    boost::proto::display_expr(memberList);

    return UnaryConstructSymbol<TypeList>()(detail::translateList(memberList));
  }
};

// This is the grammar to construct type lists
struct TypeListBuilder : boost::proto::when<
  TypeListRule,
  ConstructTypeList(
    // Member type list
    boost::proto::_right)
> {};

// This is the grammar to construct types
struct TypeBuilder : boost::proto::or_<
  IntBuilder,
  TypeListBuilder
  > {};

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

const ListTerminal list = {{}};
const IntTerminal int_ = {{}};

// Some helpers
template<typename Grammar, typename Expr>
void
checkMatch(const Expr &expr) {
  BOOST_MPL_ASSERT(( boost::proto::matches<Expr, Grammar> ));
}

template<typename Grammar, typename Expr>
void
checkNotMatch(const Expr &expr) {
  BOOST_MPL_ASSERT(( !boost::proto::matches<Expr, Grammar> ));
}

template<typename Expr>
std::tr1::shared_ptr<Type>
translate(const Expr &expr) {
  std::cout << "Translating:\n";
  boost::proto::display_expr(expr);
  checkMatch<TypeBuilder>(expr);
  TypeBuilder trans;
  return trans(expr);
}

int main(void)
{
  std::tr1::shared_ptr<Type> type = translate(
    int_(32)
  );

  type->print();
  std::cout << std::endl;

  std::tr1::shared_ptr<Type> singlelist = translate(
    list [
      int_(32)
    ]
  );

  singlelist->print();

  checkMatch<StrictTypeList>((
      int_(32),
      int_(16),
      int_(64)
  ));

  checkNotMatch<StrictTypeList>((
      int_(32)
  ));

  std::tr1::shared_ptr<Type> typelist = translate(
    list [
      int_(32),
      int_(16),
      int_(64)
    ]
  );

  typelist->print();

  return 0;
}