#pragma once

#ifndef TCG_TRAITS_H
#define TCG_TRAITS_H

// tcg includes
#include "sfinae.h"

// STD includes
#include <iterator>

//--------------------------------------------------------------------------

namespace tcg {

//****************************************************************************
//    TCG traits for generic type concepts
//****************************************************************************

template <typename T>
struct traits {
  typedef T *pointer_type;
  typedef T pointed_type;
  typedef T &reference_type;
  typedef T referenced_type;
  typedef T element_type;
};

template <typename T>
struct traits<T *> {
  typedef T **pointer_type;
  typedef T pointed_type;
  typedef T *&reference_type;
  typedef T *referenced_type;
  typedef T *element_type;
};

template <typename T>
struct traits<T[]> : public traits<T *> {
  typedef T element_type;
};

template <typename T>
struct traits<T &> : public traits<T> {};

template <>
struct traits<void> {
  typedef void *pointer_type;
  typedef void pointed_type;
  typedef void reference_type;
  typedef void referenced_type;
};

//****************************************************************************
//    Qualifier removers
//****************************************************************************

template <typename T>
struct remove_const {
  typedef T type;
};
template <typename T>
struct remove_const<const T> {
  typedef T type;
};

template <typename T>
struct remove_ref {
  typedef T type;
};
template <typename T>
struct remove_ref<T &> {
  typedef T type;
};

template <typename T>
struct remove_cref {
  typedef typename remove_const<typename remove_ref<T>::type>::type type;
};

//****************************************************************************
//    TCG traits for function types
//****************************************************************************

template <typename Func>
class function_traits {
  template <typename F, bool>
  struct result;

  template <typename F>
  struct result<F, true> {
    typedef typename F::result_type type;
  };

  template <typename F>
  struct result<F, false> {
    typedef struct { } type; };

  template <typename Q>
  static typename enable_if_exists<typename Q::result_type, char>::type
  result_fun(Q *);
  static double result_fun(...);

  template <typename F, bool>
  struct argument;

  template <typename F>
  struct argument<F, true> {
    typedef typename F::argument_type type;
  };

  template <typename F>
  struct argument<F, false> {
    typedef void type;
  };
  template <typename Q>

  static typename enable_if_exists<typename Q::argument_type, char>::type
  argument_fun(Q *);
  static double argument_fun(...);

  template <typename F, bool>
  struct first_arg;

  template <typename F>
  struct first_arg<F, true> {
    typedef typename F::first_argument_type type;
  };

  template <typename F>
  struct first_arg<F, false> {
    typedef void type;
  };
  template <typename Q>

  static typename enable_if_exists<typename Q::first_argument_type, char>::type
  first_arg_fun(Q *);
  static double first_arg_fun(...);

  template <typename F, bool>
  struct second_arg;

  template <typename F>
  struct second_arg<F, true> {
    typedef typename F::second_argument_type type;
  };

  template <typename F>
  struct second_arg<F, false> {
    typedef void type;
  };

  template <typename Q>
  static typename enable_if_exists<typename Q::second_argument_type, char>::type
  second_arg_fun(Q *);
  static double second_arg_fun(...);

public:
  enum {
    has_result =
        (sizeof(result_fun(typename tcg::traits<Func>::pointer_type())) ==
         sizeof(char)),
    has_argument =
        (sizeof(argument_fun(typename tcg::traits<Func>::pointer_type())) ==
         sizeof(char)),
    has_first_arg =
        (sizeof(first_arg_fun(typename tcg::traits<Func>::pointer_type())) ==
         sizeof(char)),
    has_second_arg =
        (sizeof(second_arg_fun(typename tcg::traits<Func>::pointer_type())) ==
         sizeof(char))
  };

  typedef typename result<Func, has_result>::type ret_type;
  typedef typename argument<Func, has_argument>::type arg_type;
  typedef typename first_arg<Func, has_first_arg>::type arg1_type;
  typedef typename second_arg<Func, has_second_arg>::type arg2_type;
};

//-----------------------------------------------------------------------

template <typename Ret>
struct function_traits<Ret()> {
  enum {
    has_result     = true,
    has_argument   = false,
    has_first_arg  = false,
    has_second_arg = false
  };

  typedef Ret ret_type;
  typedef void arg_type;
  typedef void arg1_type;
  typedef void arg2_type;
};

template <typename Ret>
struct function_traits<Ret (*)()> : public function_traits<Ret()> {};

template <typename Ret>
struct function_traits<Ret (&)()> : public function_traits<Ret()> {};

//-----------------------------------------------------------------------

template <typename Ret, typename Arg>
struct function_traits<Ret(Arg)> {
  enum {
    has_result     = true,
    has_argument   = true,
    has_first_arg  = false,
    has_second_arg = false
  };

  typedef Ret ret_type;
  typedef Arg arg_type;
  typedef void arg1_type;
  typedef void arg2_type;
};

template <typename Ret, typename Arg>
struct function_traits<Ret (*)(Arg)> : public function_traits<Ret(Arg)> {};

template <typename Ret, typename Arg>
struct function_traits<Ret (&)(Arg)> : public function_traits<Ret(Arg)> {};

//-----------------------------------------------------------------------

template <typename Ret, typename Arg1, typename Arg2>
struct function_traits<Ret(Arg1, Arg2)> {
  enum { has_result = true, has_first_arg = true, has_second_arg = true };

  typedef Ret ret_type;
  typedef Arg1 arg1_type;
  typedef Arg2 arg2_type;
};

template <typename Ret, typename Arg1, typename Arg2>
struct function_traits<Ret (*)(Arg1, Arg2)>
    : public function_traits<Ret(Arg1, Arg2)> {};

template <typename Ret, typename Arg1, typename Arg2>
struct function_traits<Ret (&)(Arg1, Arg2)>
    : public function_traits<Ret(Arg1, Arg2)> {};

//******************************************************************************
//    TCG traits for output container readers
//******************************************************************************

template <typename Reader, typename OutputData = typename Reader::value_type>
struct container_reader_traits {
  typedef Reader reader_type;
  typedef OutputData value_type;

  static void openContainer(reader_type &reader) { reader.openContainer(); }
  static void addElement(reader_type &reader, const value_type &data) {
    reader.addElement(data);
  }
  static void closeContainer(reader_type &reader) { reader.closeContainer(); }
};

//************************************************************************************
//    Notable Test  traits
//************************************************************************************

template <typename T>
struct is_floating_point {
  enum { value = false };
};

template <>
struct is_floating_point<float> {
  enum { value = true };
};

template <>
struct is_floating_point<double> {
  enum { value = true };
};

template <>
struct is_floating_point<long double> {
  enum { value = true };
};

//-----------------------------------------------------------------------

template <typename T>
struct is_function {
  enum { value = function_traits<T>::has_result };
};

template <typename T>
struct is_functor {
  template <typename Q>
  static typename enable_if_exists<typename Q::result_type, char>::type result(
      Q *);

  static double result(...);

  enum {
    value = (sizeof(result(typename tcg::traits<T>::pointer_type())) ==
             sizeof(char))
  };
};

}  // namespace tcg

#endif  // TCG_TRAITS_H