#pragma once

#include <type_traits>

#include <dune/functions/common/functionconcepts.hh>

#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/TypeTraits.hpp>

namespace AMDiS
{
  /**
    * \defgroup Concepts Concepts
    * \brief Concept definitions
    * @{
    **/

  namespace Traits
  {
    template <class A, class B>
    struct IsSimilar
      : std::is_same<std::decay_t<A>, std::decay_t<B>> {};

    template <class A, class B>
    struct IsSimilar<Types<A>, Types<B>>
      : IsSimilar<A,B> {};

    template <>
    struct IsSimilar<Types<>, Types<>> : std::true_type {};

    template <class A0, class... As, class B0, class... Bs>
    struct IsSimilar<Types<A0,As...>, Types<B0,Bs...>>
      : and_t<IsSimilar<A0, B0>::value, IsSimilar<Types<As...>, Types<Bs...>>::value> {};

    template <class T>
    struct IsReferenceWrapper
      : std::false_type {};

    template <class T>
    struct IsReferenceWrapper<std::reference_wrapper<T>>
      : std::true_type {};

  } // end namespace Traits

  namespace Concepts
  {
#ifndef DOXYGEN
    namespace Definition
    {
      // f(args...)
      struct Callable
      {
        template <class F, class... Args>
        auto requires_(F&& f, Args&&... args) -> decltype( f(FWD(args)...));
      };

      // idx[0]
      struct MultiIndex
      {
        template <class MI>
        auto requires_(MI&& idx) -> decltype(
          Concepts::valid_expr(
            idx[0],
            idx.size(),
            idx.max_size()
            /* ,idx.resize() */
          ));
      };

    } // end namespace Definition
#endif // DOXYGEN


    /// Types are the same, up to decay of qualifiers
    template <class A, class B>
    constexpr bool Similar = Traits::IsSimilar<A, B>::value;

    /// \brief A Collable is a function `F` that can be called with arguments of type `Args...`.
    /**
      * To be used as follows: `Concepts::Collable<F, Args...>`. Returns true, if
      * an instance of `F` can be called by `operator()` with arguments of type
      * `Args...`.
      **/
    template <class F, class... Args>
    constexpr bool Callable = models<Definition::Callable(F, Args...)>;


    /// \brief A Functor is a function `F` with signature `Signature`.
    /**
      * To be used as follows: `Concepts::Functor<F, R(Args...)>`. Returns true, if
      * an instance of `F` can be called by `operator()` with arguments of type
      * `Args...` and returns a value of type `R`, i.e. `Signature := R(Args...)`.
      **/
    template <class F, class Signature> // F, Signature=Return(Arg)
    constexpr bool Functor = Dune::Functions::Concept::isFunction<F, Signature>();

    /// A predicate is a function that returns a boolean.
    template <class F, class... Args>
    constexpr bool Predicate = Functor<F, bool(Args...)>;

    template <class MI>
    constexpr bool MultiIndex = models<Definition::MultiIndex(MI)>;

    /** @} **/

  } // end namespace Concepts

} // end namespace AMDiS