// test_boost_proto 
// - Small test program to illustrate wrapper removal issue

#include  <boost/proto/proto.hpp>

namespace clifford {
    
    namespace proto = boost::proto;

    // expression tags 
    namespace tag  {
	struct reverse_ {};
    }
    
	  
    ////////////////////////////////////////////////////////////////////
    // Grammar    
    struct ga_grammar;
 
    struct ga_grammar_cases {
	template <class Tag>
	struct case_ : proto::not_<proto::_> {};
    };

    // terminals - usually multivectors or doubles 
    template<> struct  ga_grammar_cases::case_<proto::tag::terminal>
    : proto::_ {};

    // reverse operator
    template<> struct  ga_grammar_cases::case_<tag::reverse_>
    : proto::unary_expr<tag::reverse_, ga_grammar> {};

    struct ga_grammar : proto::switch_<ga_grammar_cases> {};
  
   
    struct ga_domain;
  
    template<typename Expr>
    struct ga_expr
	: proto::extends<Expr, ga_expr<Expr>, ga_domain>
    {
	typedef proto::extends<Expr, ga_expr<Expr>, ga_domain> base_type;

	typedef void clifford_is_expr_;

	ga_expr(const Expr& expr = Expr() )
	    : base_type( expr ) 
	    {}
    };

    struct ga_domain : proto::domain<proto::generator<ga_expr>, ga_grammar> {};


    //////////////////////////////////////////////////////////////////
    // Capture the expression 

    // control overloads 
    namespace detail_ 
    {
	template <class Tag, class Arg, class Enable = void>
	struct make_unary_expr_if {};

	template <class T, class Arg>
	struct make_unary_expr_if<T, Arg, typename Arg::clifford_is_multivector_> 
	    : proto::result_of::make_expr<T, ga_domain,  const Arg&> {};

	template <class T, class Arg>
	struct make_unary_expr_if<T, Arg, typename Arg::clifford_is_expr_> 
	    : proto::result_of::make_expr<T, ga_domain, const Arg&> {};

    } // namespace detail_ 

#define  CLIFFORD_DEFINE_UNARY_OPERATOR(OP, TAG)			\
    template<typename A>						\
    const typename detail_::make_unary_expr_if<TAG, A>::type			\
    OP(A const &a)  {							\
	return proto::make_expr<TAG, ga_domain >(boost::ref(a));	\
    }

    CLIFFORD_DEFINE_UNARY_OPERATOR(operator~, tag::reverse_)


    ////////////////////////////////////////////////////////////////////
    /// Transform the expression

    //struct transform_expression : proto::_ {}; // <= this is fine  
    
     struct transform_expression  
	: proto::nary_expr<proto::_, proto::vararg<transform_expression> > {};
    

    //////////////////////////////////////////////////////////////////
    // Evaluate the expression
    
    template <class Res, class Expr> 
    void evaluate_expr(Res& res, const ga_expr<Expr>& expr)  {
	// do something ... 
    }

    template <class Res, class Expr> 
    void evaluate(Res& res, const ga_expr<Expr>& expr)  {
	BOOST_MPL_ASSERT((proto::matches< ga_expr<Expr>, ga_grammar>));
	evaluate_expr(res, transform_expression()(expr) );
    }

    // "stub" structs for multivector terminals

    template <class T>  struct multivector_base {
	typedef void clifford_is_multivector_; 
	/// \brief cast to the actual mulivector type
	T& operator()() { return static_cast<T&>(*this); }
	/// \overload
	const T& operator()() const { return static_cast<const T&>(*this); } 
    };

    // general geometric algebra multivector template
    template <class B, class A>   
    class multivector : public multivector_base< multivector<B, A> >
    {
    public:
	multivector () {};

	// generalised assign 
	template <class T>
	multivector& operator=(const ga_expr<T>& expr) {
	    evaluate(*this, expr);
	    return *this;
	}

	// implementation ... 
    }; // class multivector

    ///////////////////////////////////////////////////////////////////// 
    // make some multivector types - stubs

    // (p,q) signature of space, p positive and q negative basis elements
    template <size_t p, size_t q>
    struct algebra {}; // implementation ... 
  
    typedef algebra<4,1> ga41; 

    namespace cga3 {
	struct cga3 : ga41{};      // 3D conformal geometric algebra,  cga 

	// some bases ( implemented using mpl integral sequences wrappers)
	struct ebivector_basis{};     // {e12, e13, e23 }
	struct rotator_basis{};    //  {1, e12, e23, e31} 
	// ...  
    
	// some useful general multivector types
	typedef multivector<ebivector_basis, cga3> ebivector;
	typedef multivector<rotator_basis, cga3> rotator; // Rotation about origin, aka Quaternion
	// ...  

    } // namespace cga3
} // namespace clifford


int main()
{
    clifford::cga3::rotator R;
    clifford::cga3::ebivector B;

    R = ~B;    
}