#include "stdafx.h"
#include <string>
#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/has_xxx.hpp>

namespace boost { namespace proto
{
    namespace detail
    {
        // Define has_which trait
        BOOST_MPL_HAS_XXX_TRAIT_DEF(which)
        BOOST_MPL_HAS_XXX_TRAIT_DEF(rule_name)

        template<typename Grammar, typename EnableIf = void>
        struct get_rule_name
        {
            typedef Grammar type;
        };

        template<typename Grammar>
        struct get_rule_name<
            Grammar
          , typename boost::enable_if_c<has_rule_name<Grammar>::value >::type
        >
        {
            typedef typename Grammar::rule_name type;
        };

        template<typename Expr, typename Grammar, typename EnableIf = void>
        struct get_which
          : get_rule_name<Grammar>
        {};

        // Only proto::or_, proto::switch_ and proto::if_ have branches and
        // need to define a which member.
        template<typename Expr, typename Grammar>
        struct get_which<
            typename Expr
          , typename Grammar
          , typename boost::enable_if_c<
                mpl::and_<
                    has_which<proto::matches<Expr, Grammar> >
                  , mpl::not_<has_rule_name<Grammar> >
                >::value
            >::type
        >
          : get_which<Expr, typename proto::matches<Expr, Grammar>::which>
        {};
    }

    template<typename Name, typename Grammar>
    struct named_rule
      : Grammar
    {
        typedef Name rule_name;
    };

    template<typename Grammar, typename Actions>
    struct algorithm
      : proto::transform<algorithm<Grammar, Actions> >
    {
        typedef Grammar proto_grammar;

        // Cheating! relies on Proto implementation details (the
        // presence of a nested which typedef in proto::matches).
        template <typename Expr, typename State, typename Data>
        struct impl
          : Actions::template
                when<typename detail::get_which<Expr, Grammar>::type, Actions>::template
                    impl<Expr, State, Data>
        {};
    };

    template <typename Grammar, typename Actions>
    struct is_callable<algorithm<Grammar, Actions> >
      : mpl::true_
    {};
}}

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

struct nothing
  : proto::named_rule<nothing, proto::not_<proto::_> >
{};

struct int_terminal
  : proto::named_rule<int_terminal, proto::terminal<int> >
{};

struct char_terminal
  : proto::named_rule<char_terminal, proto::terminal<char> >
{};

struct plus_int_int
  : proto::named_rule<plus_int_int, proto::plus<int_terminal, int_terminal> >
{};

//struct my_grammar
//  : proto::or_<
//        int_terminal
//      , char_terminal
//      , plus_int_int
//    >
//{};

struct my_grammar
  : proto::switch_<my_grammar>
{
    template<typename Tag>
    struct case_
      : nothing
    {};
};

template<>
struct my_grammar::case_<proto::tag::terminal>
  : proto::or_<
        int_terminal
      , char_terminal
    >
{};

template<>
struct my_grammar::case_<proto::tag::plus>
  : //proto::or_<
        plus_int_int
    //>
{};

struct my_actions;

struct print : proto::callable
{
    typedef std::string result_type;

    result_type operator()(int) const
    {
        return "int";
    }

    result_type operator()(char) const
    {
        return "char";
    }

    template <typename T1, typename T2>
    result_type operator()(T1 res, T2 t2) const
    {
        res += " + ";
        res += t2;
        return res;
    }
};

struct my_actions
{
    template <typename Grammar, typename Actions = my_actions>
    struct when;

    template <typename Actions>
    struct when<int_terminal, Actions>
      : proto::call<print(proto::_value)>
    {};
    
    template <typename Actions>
    struct when<char_terminal, Actions>
      : proto::call<print(proto::_value)>
    {};
    
    template <typename Actions>
    struct when<plus_int_int, Actions>
      : proto::call<
            print(
                proto::call<proto::algorithm<my_grammar, Actions>(proto::_left)>
              , proto::call<proto::algorithm<my_grammar, Actions>(proto::_right)>
            )
        >
    {};
};

int main()
{
    proto::literal<int> i(8), j(9);
    proto::literal<char> a('a'), b('b');

    std::cout << proto::algorithm<char_terminal, my_actions>()(a)  << "\n"; // printing char
    proto::assert_matches_not<proto::algorithm<int_terminal, my_actions> >(a);
    //std::cout << proto::algorithm<int_terminal, my_actions>()(a)   << "\n"; // precondition violation
    proto::assert_matches_not<proto::algorithm<char_terminal, my_actions> >(i);
    //std::cout << proto::algorithm<char_terminal, my_actions>()(i)  << "\n"; // precondition violation
    std::cout << proto::algorithm<int_terminal, my_actions>()(j)   << "\n"; // printing int
    std::cout << proto::algorithm<my_grammar, my_actions>()(j)     << "\n"; // printing int
    std::cout << proto::algorithm<my_grammar, my_actions>()(a)     << "\n"; // printing char
    std::cout << proto::algorithm<my_grammar, my_actions>()(i + i) << "\n"; // printing int + int
}