#include <boost/proto/proto.hpp>

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

typedef proto::terminal<int> int_terminal;
typedef proto::terminal<double> double_terminal;

////////////////////////////////////////////////////////////////////////////////
template <typename Expr>
struct actor1;

struct grammar1;

// define our base domain
struct domain1
    : proto::domain<
        proto::pod_generator<actor1>
      , grammar1
      , proto::default_domain
    >
{};

// define the grammar for that domain
struct grammar1
    : proto::switch_<grammar1>
{
    // The actual grammar is parametrized on a Grammar parameter as well
    // This allows us to effectively reuse that grammar in subdomains.
    template <typename Tag, typename Grammar = grammar1>
    struct case_
        : proto::or_<
            proto::plus<Grammar, Grammar>
          , int_terminal
        >
    {};
};

// boring expression wrapper
template <typename Expr>
struct actor1
{
    BOOST_PROTO_BASIC_EXTENDS(Expr, actor1<Expr>, domain1)
};
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
template <typename Expr>
struct actor2;

struct grammar2;

// our domain2 ... this is a subdomain of domain1
struct domain2
    : proto::domain<
        proto::pod_generator<actor2>
      , grammar2
      , domain1
    >
{};

// the grammar2
struct grammar2
    : proto::switch_<grammar2>
{
    // again parameterized on a Grammar, defaulting to grammar2
    // This is not really needed here, but allows to reuse that grammar as well
    template <typename Tag, typename Grammar = grammar2>
    struct case_
        : proto::or_<
            // here we go ... reuse grammar1::case_ with our new grammar
            grammar1::case_<Tag, Grammar>
          , double_terminal
        >
    {};
};

// boring expression wrapper
template <typename Expr>
struct actor2
{
    BOOST_PROTO_BASIC_EXTENDS(Expr, actor2<Expr>, domain2)
};
////////////////////////////////////////////////////////////////////////////////

actor1<int_terminal::type> t1 = {{42}};
actor2<double_terminal::type> t2 = {{3.14}};


////////////////////////////////////////////////////////////////////////////////
// specialize is_extension trait, so actor1 and actor2 don't get picked up
// by proto's default operators.
// otherwise, expression like t1 + t2 would not work.
namespace boost { namespace proto {
    template <typename T>
    struct is_extension<actor1<T> > : mpl::false_ {};

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

// define a trait which marks the actors as special classes
template <typename T>
struct is_actor : boost::mpl::false_ {};

template <typename T>
struct is_actor<actor1<T> > : boost::mpl::true_ {};

template <typename T>
struct is_actor<actor2<T> > : boost::mpl::true_ {};

template <typename Domain0, typename Domain1>
struct is_super_domain;

template <typename Domain0, typename Domain1>
struct is_super_domain
    : mpl::eval_if<
        boost::is_same<Domain0, typename Domain1::proto_super_domain>
      , mpl::true_
      , is_super_domain<Domain0, typename Domain1::proto_super_domain> 
    >
{};

template <typename Domain0>
struct is_super_domain<Domain0, Domain0>
    : mpl::true_
{};

template <typename Domain0>
struct is_super_domain<Domain0, proto::no_super_domain>
    : mpl::false_
{};


// strongest domain selects the most specialised domain
// meaning that if:
//  1. D0 is a super domain of D1, D1 is the strongest
//  2. D1 is a super domain of D0, D0 is the strongest
//  3. if 1 and 2 are false, the common domain is selected.
template <typename D0, typename D1>
struct strongest_domain2_impl
    : boost::mpl::eval_if<
        typename is_super_domain<D0, D1>::type//boost::is_same<D0, typename D1::proto_super_domain>
      , boost::mpl::identity<D1>
      , boost::mpl::eval_if<
            typename is_super_domain<D1, D0>::type//boost::is_same<typename D0::proto_super_domain, D1>
          , boost::mpl::identity<D0>
          , proto::detail::common_domain2<D0, D1>
        >
    >
{};

template <typename E0>
struct strongest_domain1
    : proto::domain_of<E0>
{};

template <typename E0, typename E1>
struct strongest_domain2
    : strongest_domain2_impl<
        typename proto::domain_of<E0>::type
      , typename proto::domain_of<E1>::type
    >
{};


////////////////////////////////////////////////////////////////////////////////
// Extension to proto to select the strongest domain, as described below.
struct strongest_domain
    : proto::domain<
        proto::detail::not_a_generator
      , proto::detail::not_a_grammar
      , proto::detail::not_a_domain
    >
{};

namespace boost { namespace proto {
    namespace detail
    {
        template <typename Trait, typename Tag, typename Expr>
        struct enable_unary<strongest_domain, not_a_grammar, Trait, Tag, Expr>
            : enable_unary<
                typename strongest_domain1<Expr>::type
              , typename strongest_domain1<Expr>::type::proto_grammar
              , Trait
              , Tag
              , Expr
            >
        {};

        template <typename Trait, typename Tag, typename Left, typename Right>
        struct enable_binary<strongest_domain, not_a_grammar, Trait, Tag, Left, Right>
            : enable_binary<
                typename strongest_domain2<Left, Right>::type
              , typename strongest_domain2<Left, Right>::type::proto_grammar
              , Trait
              , Tag
              , Left
              , Right
            >
        {};

        template <typename Tag, typename A0>
        struct make_expr_<Tag, strongest_domain, A0>
            : make_expr_<
                Tag
              , typename strongest_domain1<A0>::type
              , A0
            >
        {};

        template <typename Tag, typename A0, typename A1>
        struct make_expr_<Tag, strongest_domain, A0, A1>
            : make_expr_<
                Tag
              , typename strongest_domain2<A0, A1>::type
              , A0
              , A1
            >
        {};
    }
}}
////////////////////////////////////////////////////////////////////////////////

// define operators for that kind of classes, we do not want the deduced domain
// but the strongest domain.
// Meaning:
//   For "actor1<Expr> + actor2<Expr>" the result must be in domain2, not domain1
//   as deduce_domain would calculate the resulting domain.
//   If the resulting domain is domain1, the resulting expression would not match
//   the grammar of domain1 ...
BOOST_PROTO_DEFINE_OPERATORS(is_actor, strongest_domain)
////////////////////////////////////////////////////////////////////////////////

template <typename T>
void test(T const & t)
{
    std::cout << typeid(T).name() << "\n";
    std::cout << std::boolalpha;
    std::cout << "    matches grammar1? " << proto::matches<T, grammar1>::type::value << "\n";
    std::cout << "    matches grammar2? " << proto::matches<T, grammar2>::type::value << "\n";
}

template <typename T0, typename T1>
void test(T0 const& t0, T1 const& t1)
{
    test(t0 + t1);
    test(t1 + t0);
    std::cout << "\n";
}

template <typename T0, typename T1, typename T2>
void test(T0 const& t0, T1 const& t1, T2 const& t2)
{
    test(t0 + t1, t2);
    test(t1 + t0, t2);
    test(t1 + t2, t0);
    test(t2 + t1, t0);
    test(t0 + t2, t1);
    test(t2 + t0, t1);
    std::cout << "\n";
}

int main()
{
    test(t1);
    test(t2);
    test(t1, t1);
    test(t2, t2);
    test(t1, t2);
    test(t1, t1, t1);
    test(t2, t1, t1);
    test(t1, t2, t1);
    test(t1, t1, t2);
    test(t2, t2, t1);
    test(t2, t1, t2);
    test(t1, t2, t2);
    test(t2, t2, t2);
}