// TestProto.cpp : Defines the entry point for the console application.
//

#include <iostream>

#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
#include <boost/proto/domain.hpp>

#include <boost/mpl/vector.hpp>

BOOST_MPL_HAS_XXX_TRAIT_DEF(type)

using namespace std;
namespace proto = boost::proto;
namespace mpl = boost::mpl;


struct state_tag{};
struct event_tag{};
struct action_tag{};
struct guard_tag{};


struct none{};
template <class T1=none,class T2=none,class T3=none,class T4=none,class T5=none>
struct Row
{
    typedef T1 Source;
    typedef T2 Evt;
    typedef T3 Target;
    typedef T4 Action;
    typedef T5 Guard;
};


template <class TAG, class Enable = void>
struct make_type 
{
    typedef TAG type;
};
template <class TAG>
struct make_type<TAG, typename boost::enable_if<has_type<TAG> >::type> 
{
    typedef typename TAG::type type;
};


template <class Left,class Right>
struct fusion_left_right 
{
    typedef Row<typename Left::Source,typename Left::Evt,typename Right::Target
               ,typename Right::Action,typename Right::Guard> type;
};

template <class Target,class ActionGuard>
struct fusion_target_action_guard 
{
    typedef Row<none,none,typename Target::Target,typename ActionGuard::Action,typename ActionGuard::Guard> type;
};


// row grammar
struct BuildSourcePlusEvent
    : proto::when<
            proto::plus<proto::terminal<state_tag>,proto::terminal<event_tag> >,
            Row<make_type<proto::_left>(),make_type<proto::_right>()>()
        >
{};
struct BuildActionPlusGuard
    : proto::when<
            proto::mem_ptr<proto::terminal<action_tag>,proto::terminal<guard_tag> >,
            Row<none,none,none,make_type<proto::_left>(),make_type<proto::_right>()>()
        >
{};
struct BuildTarget
    : proto::when<
            proto::terminal<state_tag>,
            Row<none,none,make_type<proto::_>()>()
        >
{};
struct BuildRight
    : proto::or_<
        // after >>, if just state without guard/action
         proto::when<
                proto::terminal<state_tag>,
                Row<none,none,make_type<proto::_>(),none>() >
        // >> target / action
       , proto::when<
                proto::divides<proto::terminal<state_tag>,proto::terminal<action_tag> >,
                Row<none,none,make_type<proto::_left>(),make_type<proto::_right>()>() >
        // >> target ->* guard
       , proto::when<
                proto::mem_ptr<proto::terminal<state_tag>,proto::terminal<guard_tag> >,
                Row<none,none,make_type<proto::_left>(),none,make_type<proto::_right>()>() >
        // >> target / action ->* guard
       , proto::when<
                proto::divides<BuildTarget,
                               BuildActionPlusGuard >,
                fusion_target_action_guard<Row<none,none,make_type<proto::_left>()>,
                                               BuildActionPlusGuard(proto::_right)>() 
                >
        >
{};

struct BuildRow
    : proto::or_<     
        proto::when<
            proto::equal_to<BuildSourcePlusEvent,BuildRight >,
            fusion_left_right<BuildSourcePlusEvent(proto::_left),BuildRight(proto::_right)>()
        >
    , proto::nary_expr<proto::_, proto::vararg<BuildRow> >
    >
{};

template <class Expr>
void print_row(Expr const& expr)
{
    cout << "in print_row" << endl;
    cout << "matches:" << proto::matches<Expr,BuildRow>::value << endl;
    typedef
        boost::result_of<BuildRow(Expr)>::type
        result_type;
    cout << "result_type" << endl;
    cout << typeid(result_type).name() << endl;

    cout << "end print_row" << endl;
}

struct s1{};
struct s2{};
struct e1: proto::terminal<event_tag>::type{};

template<typename T>
struct is_terminal
  : mpl::false_
{};

// OK, s1,s2,s3 are custom terminal types
template<>
struct is_terminal<s1>
  : mpl::true_
{};
template<>
struct is_terminal<s2>
  : mpl::true_
{};


//BOOST_PROTO_DEFINE_OPERATORS(is_terminal, proto::default_domain)


int main()
{
    print_row( s1() +  e1() == s2() );
    return 0;
}