//          Copyright Sebastian Jeckel 2014.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef REACT_COMMON_UTIL_H_INCLUDED
#define REACT_COMMON_UTIL_H_INCLUDED

#pragma once

#include "react/detail/Defs.h"

#include <tuple>
#include <type_traits>
#include <utility>

/***************************************/ REACT_IMPL_BEGIN /**************************************/

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Unpack tuple - see
/// http://stackoverflow.com/questions/687490/how-do-i-expand-a-tuple-into-variadic-template-functions-arguments
///////////////////////////////////////////////////////////////////////////////////////////////////

template<size_t N>
struct Apply {
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T && t, A &&... a)
        -> decltype(Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...))
    {
        return Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
    }
};

template<>
struct Apply<0>
{
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T &&, A &&... a)
        -> decltype(std::forward<F>(f)(std::forward<A>(a)...))
    {
        return std::forward<F>(f)(std::forward<A>(a)...);
    }
};

template<typename F, typename T>
inline auto apply(F && f, T && t)
    -> decltype(Apply<std::tuple_size<typename std::decay<T>::type>::value>::apply(std::forward<F>(f), std::forward<T>(t)))
{
    return Apply<std::tuple_size<typename std::decay<T>::type>::value>
        ::apply(std::forward<F>(f), std::forward<T>(t));
}

template<size_t N>
struct ApplyMemberFn {
    template <typename O, typename F, typename T, typename... A>
    static inline auto apply(O obj, F f, T && t, A &&... a)
        -> decltype(ApplyMemberFn<N-1>::apply(obj, f, std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...))
    {
        return ApplyMemberFn<N-1>::apply(obj, f, std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
    }
};

template<>
struct ApplyMemberFn<0>
{
    template<typename O, typename F, typename T, typename... A>
    static inline auto apply(O obj, F f, T &&, A &&... a)
        -> decltype((obj->*f)(std::forward<A>(a)...))
    {
        return (obj->*f)(std::forward<A>(a)...);
    }
};

template <typename O, typename F, typename T>
inline auto applyMemberFn(O obj, F f, T&& t)
    -> decltype(ApplyMemberFn<std::tuple_size<typename std::decay<T>::type>::value>::apply(obj, f, std::forward<T>(t)))
{
    return ApplyMemberFn<std::tuple_size<typename std::decay<T>::type>::value>
        ::apply(obj, f, std::forward<T>(t));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Helper to enable calling a function on each element of an argument pack.
/// We can't do f(args) ...; because ... expands with a comma.
/// But we can do nop_func(f(args) ...);
///////////////////////////////////////////////////////////////////////////////////////////////////
template <typename... TArgs>
inline void pass(TArgs&& ...) {}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Identity (workaround to enable enable decltype()::X)
///////////////////////////////////////////////////////////////////////////////////////////////////
template <typename T>
struct Identity
{
    using Type = T;
};

///////////////////////////////////////////////////////////////////////////////////////////////////
/// DontMove!
///////////////////////////////////////////////////////////////////////////////////////////////////
struct DontMove {};

///////////////////////////////////////////////////////////////////////////////////////////////////
/// AddDummyArgWrapper
///////////////////////////////////////////////////////////////////////////////////////////////////
template <typename TArg, typename F, typename TRet, typename ... TDepValues>
struct AddDummyArgWrapper
{
    // Dummy int to make sure it calls the right ctor
    template <typename FIn>
    AddDummyArgWrapper(int, FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}

    AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
    AddDummyArgWrapper(AddDummyArgWrapper&& other) : MyFunc( std::move(other.MyFunc) ) {}

    TRet operator()(TArg, TDepValues& ... args)
    {
        return MyFunc(args ...);
    }

    F MyFunc;
};

template <typename TArg, typename F, typename ... TDepValues>
struct AddDummyArgWrapper<TArg,F,void,TDepValues...>
{
    // Dummy int to make sure it calls the right ctor
    template <typename FIn>
    AddDummyArgWrapper(int, FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}

    AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
    AddDummyArgWrapper(AddDummyArgWrapper&& other) : MyFunc( std::move(other.MyFunc) ) {}

    void operator()(TArg, TDepValues& ... args)
    {
        MyFunc(args ...);
    }

    F MyFunc;
};

///////////////////////////////////////////////////////////////////////////////////////////////////
/// AddDefaultReturnValueWrapper
///////////////////////////////////////////////////////////////////////////////////////////////////
template 
<
    typename F,
    typename TRet,
    TRet return_value
>
struct AddDefaultReturnValueWrapper
{
    template <typename FIn>
    AddDefaultReturnValueWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}

    template <typename ... TArgs>
    TRet operator()(TArgs&& ... args)
    {
        MyFunc(std::forward<TArgs>(args) ...);
        return return_value;
    }

    F MyFunc;
};

/****************************************/ REACT_IMPL_END /***************************************/

// Expand args by wrapping them in a dummy function
// Use comma operator to replace potential void return value with 0
#define REACT_EXPAND_PACK(...) REACT_IMPL::pass((__VA_ARGS__ , 0) ...)

#endif // REACT_COMMON_UTIL_H_INCLUDED