#ifndef glas_conj_expression_hpp
#define glas_conj_expression_hpp

//#include <glas/backend/default.hpp>
//#ifdef GLAS_BACKEND_GLAS
//#  include <glas/backend/glas/inner_product.hpp>
//#endif
//#ifdef GLAS_BACKEND_BLAS
//#  include <glas/backend/blas/inner_product.hpp>
//#endif
//#ifdef GLAS_BACKEND_VSIPLPP
//#  include <glas/backend/vsiplpp/inner_product.hpp>
//#endif

#include <glas/concept/is_vector_expression.hpp>
#include <glas/concept/is_scalar_expression.hpp>
#include <glas/concept/scalar_expression_concept.hpp>
#include <glas/concept/vector_expression_concept.hpp>
#include <glas/concept/concept.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/assert.hpp>

#ifdef GLAS_COMPLEX
#  include <complex>
#endif

namespace glas {

  template <class T>
  struct conj_functor
  {
    typedef T argument_type ;
    typedef T result_type ;

    result_type operator()(argument_type const & v) const
    { return v ; }
  } ;

#ifdef GLAS_COMPLEX
  template <class T>
  struct conj_functor< std::complex<T> >
  {
    typedef std::complex<T> argument_type ;
    typedef std::complex<T> result_type ;

    result_type operator()(argument_type const & v) const
    { return std::conj( v ) ; }
  } ;
#endif

  template <class T>
  class scalar_conj_expression
  {
  public:

    typedef T                        argument_type ;

  public:
    
    scalar_conj_expression(T const & t)
      : argument_( t )    
    {}

    argument_type const & argument() const
    { return argument_ ; }

    template <class C>
    operator C () const 
    { return conj_functor<argument_type>()(argument_) ; }

  private:
    
    void operator=(scalar_conj_expression const &) ;


  private:
    argument_type const & argument_ ;
  } ;

  template <class V>
  class vector_conj_expression
  {
  public:
    typedef V                         argument_type ;
    typedef typename V::value_type    value_type ;
    typedef typename V::size_type     size_type ;       // required by VectorExpression
    typedef typename V::value_type    const_reference ; 

  public:

    // required by binary-expression
    vector_conj_expression(V const & v)
      : argument_( v )
    {} 

    // required by binary-expression
    argument_type const& argument() const 
    { return argument_ ; }

    // required by VectorExpression
    size_type size() const
    { return argument_.size() ; }

    // required by VectorExpression
    const_reference operator[](size_type i) const
    { return conj_functor<value_type>()(argument_[i]) ; }

  private:
    
    void operator=(vector_conj_expression const &) ;


  private:
    argument_type const& argument_ ;
  } ;


  template <class T>
  struct concept< scalar_conj_expression<T> > {
    typedef boost::mpl::vector< scalar_expression_concept > type ;
  } ;

  template <class T>
  struct concept< vector_conj_expression<T> > {
    typedef boost::mpl::vector< vector_expression_concept > type ;
  } ;


  namespace detail {

    /// Helper class to determine the return-type of the conj
    template <class T>
    struct conj_return_type
    : boost::mpl::if_< ::glas::is_vector_expression<T>, vector_conj_expression<T>, scalar_conj_expression<T> >
    {} ;

  }

  /// conj free functor.
  /// 
  /// create scalar_conj_expression for scalar arguments
  /// create vector_conj_expression for vector arguments
  template <class T>
  typename detail::conj_return_type<T>::type conj( T const& v ) 
  { 
    typename detail::conj_return_type<T>::type ret( v ) ;
    return ret ;
  }

}

#endif // glas_conj_expression_hpp