/****************************************************************************************************************************
  Function.h

  This library provides function templates to better support C++ functional programming across platforms.
  Based on Vlpp library (https://github.com/vczh-libraries/Vlpp)
  and Marcus Rugger functional-vlpp library (https://github.com/marcusrugger/functional-vlpp)
  Built by Khoi Hoang (https://github.com/khoih-prog/functional-vlpp)
  Licensed under MIT license

  Original author
  Vczh Library++ 3.0
  Developer: Zihan Chen(vczh)
  Framework::Basic

  Classes:
  Func<function-type>           ：Function object

  Functions:
  Curry   :: (A->B) -> A -> B   ：Currying
  Combine :: (A->B) -> (A->C) -> (B->C->D) -> (A->D)  ：Combine multiple functors using an operator

  Version: 1.0.2

  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
  1.0.0   K Hoang      13/02/2019 Initial coding, testing and supporting AVR architecture
  1.0.1   K Hoang      01/03/2020 Add support for STM32 and all other architectures.
  1.0.2   K Hoang      21/02/2021 Clear compiler warnings
 *****************************************************************************************************************************/

#pragma once

#ifndef VCZH_FUNCTION
#define VCZH_FUNCTION

#include <stdlib.h>
#include "Basic.h"
#include "Pointer.h"

namespace vl
{

/***********************************************************************
  vl::Func<R(TArgs...)>
***********************************************************************/

template<typename T>
class Func
{
};

namespace internal_invokers
{
template<typename R, typename ...TArgs>
class Invoker : public Object
{
  public:
    virtual R Invoke(TArgs&& ...args) = 0;
};

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

template<typename R, typename ...TArgs>
class StaticInvoker : public Invoker<R, TArgs...>
{
  protected:
    R(*function)(TArgs ...args);

  public:
    StaticInvoker(R(*_function)(TArgs...))
      : function(_function)
    {
    }

    R Invoke(TArgs&& ...args)override
    {
      return function(ForwardValue<TArgs>(args)...);
    }
};

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

template<typename C, typename R, typename ...TArgs>
class MemberInvoker : public Invoker<R, TArgs...>
{
  protected:
    C*  sender;
    R(C::*function)(TArgs ...args);

  public:
    MemberInvoker(C* _sender, R(C::*_function)(TArgs ...args))
      : sender(_sender)
      , function(_function)
    {
    }

    R Invoke(TArgs&& ...args)override
    {
      return (sender->*function)(ForwardValue<TArgs>(args)...);
    }
};

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

template<typename C, typename R, typename ...TArgs>
class ObjectInvoker : public Invoker<R, TArgs...>
{
  protected:
    C   function;

  public:
    ObjectInvoker(const C& _function)
      : function(_function)
    {
    }

    R Invoke(TArgs&& ...args)override
    {
      return function(ForwardValue<TArgs>(args)...);
    }
};

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

template<typename C, typename ...TArgs>
class ObjectInvoker<C, void, TArgs...> : public Invoker<void, TArgs...>
{
  protected:
    C   function;

  public:
    ObjectInvoker(const C& _function)
      : function(_function)
    {
    }

    void Invoke(TArgs&& ...args)override
    {
      function(ForwardValue<TArgs>(args)...);
    }
};
}

/// <summary>A type representing a function reference.</summary>
/// <typeparam name="R">The return type.</typeparam>
/// <typeparam name="TArgs">Types of parameters.</typeparam>
template<typename R, typename ...TArgs>
class Func<R(TArgs...)> : public Object
{
  protected:
    Ptr<internal_invokers::Invoker<R, TArgs...>> invoker;
  public:
    typedef R FunctionType(TArgs...);
    typedef R ResultType;

    /// <summary>Create a null function reference.</summary>
    Func()
    {
    }

    /// <summary>Copy a function reference.</summary>
    /// <param name="function">The function reference to copy.</param>
    Func(const Func<R(TArgs...)>& function)
      : invoker(function.invoker)
    {
    }

    /// <summary>Create a reference using a function pointer.</summary>
    /// <param name="function">The function pointer.</param>
    Func(R(*function)(TArgs...))
    {
      invoker = new internal_invokers::StaticInvoker<R, TArgs...>(function);
    }

    /// <summary>Create a reference using a method.</summary>
    /// <typeparam name="C">Type of the class that has the method.</typeparam>
    /// <param name="sender">The object that has the method.</param>
    /// <param name="function">The function pointer.</param>
    template<typename C>
    Func(C* sender, R(C::*function)(TArgs...))
    {
      invoker = new internal_invokers::MemberInvoker<C, R, TArgs...>(sender, function);
    }

    /// <summary>Create a reference using a function object.</summary>
    /// <typeparam name="C">Type of the function object.</typeparam>
    /// <param name="function">The function object. It could be a lambda expression.</param>
    template<typename C>
    Func(const C& function)
    {
      invoker = new internal_invokers::ObjectInvoker<C, R, TArgs...>(function);
    }

    /// <summary>Invoke the function.</summary>
    /// <returns>Returns the function result.</returns>
    /// <param name="args">Arguments to invoke the function.</param>
    R operator()(TArgs ...args)const
    {
      return invoker->Invoke(ForwardValue<TArgs>(args)...);
    }

    Func<R(TArgs...)>& operator=(const Func<R(TArgs...)>& function)
    {
      invoker = function.invoker;
      return *this;
    }

    Func<R(TArgs...)>& operator=(const Func<R(TArgs...)>&& function)
    {
      invoker = MoveValue(function.invoker);
      return *this;
    }

    bool operator==(const Func<R(TArgs...)>& function)const
    {
      return invoker == function.invoker;
    }

    bool operator!=(const Func<R(TArgs...)>& function)const
    {
      return invoker != function.invoker;
    }

    /// <summary>Test is the reference a null reference.</summary>
    /// <returns>Returns true if it is not a null reference.</returns>
    operator bool()const
    {
      return invoker;
    }
};

/***********************************************************************
  vl::function_lambda::LambdaRetriveType<R(TArgs...)>
***********************************************************************/

namespace function_lambda
{
template<typename T>
struct LambdaRetriveType
{
  typedef vint Type;
  typedef vint FunctionType;
  typedef vint ResultType;
};

template<typename T>
struct FunctionObjectRetriveType
{
  typedef typename LambdaRetriveType<decltype(&T::operator())>::Type Type;
  typedef typename LambdaRetriveType<decltype(&T::operator())>::FunctionType FunctionType;
  typedef typename LambdaRetriveType<decltype(&T::operator())>::ResultType ResultType;
  typedef typename LambdaRetriveType<decltype(&T::operator())>::ParameterTypes ParameterTypes;
};

template<typename TObject, typename R, typename ...TArgs>
struct LambdaRetriveType<R (__thiscall TObject::*)(TArgs...)const>
{
  typedef Func<R(TArgs...)> Type;
  typedef R(FunctionType)(TArgs...);
  typedef R ResultType;
};

template<typename TObject, typename R, typename ...TArgs>
struct LambdaRetriveType<R (__thiscall TObject::*)(TArgs...)>
{
  typedef Func<R(TArgs...)> Type;
  typedef R(FunctionType)(TArgs...);
  typedef R ResultType;
};

template<typename R, typename ...TArgs>
struct FunctionObjectRetriveType<R(*)(TArgs...)>
{
  typedef Func<R(TArgs...)> Type;
  typedef R(FunctionType)(TArgs...);
  typedef R ResultType;
};

/// <summary>Create a function reference to a function object or a lambda expression, with all type information
/// automatically inferred. You can use the macro called "LAMBDA" to refer to this function.</summary>
/// <typeparam name="T">Type of the function object or the lambda expression.</typeparam>
/// <returns>The function reference.</returns>
/// <param name="functionObject">The function object or the lambda expression.</param>
template<typename T>
typename LambdaRetriveType<decltype(&T::operator())>::Type Lambda(T functionObject)
{
  return functionObject;
}

/// <summary>Create a function reference to a function pointer, with all type information
/// automatically inferred. You can use the macro called "FUNCTION" to refer to this function.</summary>
/// <typeparam name="T">Type of the function pointer.</typeparam>
/// <returns>The function reference.</returns>
/// <param name="functionObject">The function pointer.</param>
template<typename T>
typename FunctionObjectRetriveType<T>::Type ConvertToFunction(T functionObject)
{
  return functionObject;
}

#define LAMBDA vl::function_lambda::Lambda
#define FUNCTION vl::function_lambda::ConvertToFunction
#define FUNCTION_TYPE(T) typename vl::function_lambda::FunctionObjectRetriveType<T>::Type
#define FUNCTION_RESULT_TYPE(T) typename vl::function_lambda::FunctionObjectRetriveType<T>::ResultType
}   // namespace function_lambda

/***********************************************************************
  vl::function_binding::Binding<R(TArgs...)>
***********************************************************************/

namespace function_binding
{
template<typename T>
struct Binding
{
};

template<typename T>
struct CR
{
  typedef const T& Type;
};

template<typename T>
struct CR<T&>
{
  typedef T& Type;
};

template<typename T>
struct CR<const T>
{
  typedef const T& Type;
};

template<typename T>
struct CR<const T&>
{
  typedef const T& Type;
};

template<typename R, typename T0, typename ...TArgs>
struct Binding<R(T0, TArgs...)>
{
  typedef R FunctionType(T0, TArgs...);
  typedef R CurriedType(TArgs...);
  typedef T0 FirstParameterType;

  class Binder : public Object
  {
    protected:
      Func<FunctionType>        target;
      T0                firstArgument;
    public:
      Binder(const Func<FunctionType>& _target, T0 _firstArgument)
        : target(_target), firstArgument(ForwardValue<T0>(_firstArgument))
      {
      }

      R operator()(TArgs ...args)const
      {
        return target(firstArgument, args...);
      }
  };

  class Currier : public Object
  {
    protected:
      Func<FunctionType>    target;
    public:
      Currier(const Func<FunctionType>& _target)
        : target(_target)
      {
      }

      Func<CurriedType> operator()(T0 firstArgument)const
      {
        return Binder(target, firstArgument);
      }
  };
};
}   // namespace function_binding

/// <summary>Currize a function. Currizing means to create a new function whose argument is the first argument
/// of the original function. Calling this function will return another function reference whose arguments is all
/// remain arguments of the original function. Calling the returned function will call the original function.</summary>
/// <typeparam name="T">Type of the function.</typeparam>
/// <returns>The currized function.</returns>
/// <param name="function">The function pointer to currize.</param>
template<typename T>
Func<Func<typename function_binding::Binding<T>::CurriedType>(typename function_binding::Binding<T>::FirstParameterType)>
Curry(T* function)
{
  return typename function_binding::Binding<T>::Currier(function);
}

/// <summary>Currize a function. Currizing means to create a new function whose argument is the first argument
/// of the original function. Calling this function will return another function reference whose arguments is all
/// remain arguments of the original function. Calling the returned function will call the original function.</summary>
/// <typeparam name="T">Type of the function.</typeparam>
/// <returns>The currized function.</returns>
/// <param name="function">The function reference to currize.</param>
template<typename T>
Func<Func<typename function_binding::Binding<T>::CurriedType>(typename function_binding::Binding<T>::FirstParameterType)>
Curry(const Func<T>& function)
{
  return typename function_binding::Binding<T>::Currier(function);
}

/***********************************************************************
  vl::function_combining::Combining<R1(TArgs...), R2(TArgs...), R(R1,R2)>
***********************************************************************/

namespace function_combining
{
template<typename A, typename B, typename C>
class Combining
{
};

template<typename R1, typename R2, typename R, typename ...TArgs>
class Combining<R1(TArgs...), R2(TArgs...), R(R1, R2)> : public Object
{
  protected:
    Func<R1(TArgs...)>    function1;
    Func<R2(TArgs...)>    function2;
    Func<R(R1, R2)>       converter;
  public:
    typedef R1 FirstFunctionType(TArgs...);
    typedef R2 SecondFunctionType(TArgs...);
    typedef R ConverterFunctionType(R1, R2);
    typedef R FinalFunctionType(TArgs...);

    Combining(const Func<R1(TArgs...)>& _function1, const Func<R2(TArgs...)>& _function2, const Func<R(R1, R2)>& _converter)
      : function1(_function1), function2(_function2), converter(_converter)
    {
    }

    R operator()(TArgs&& ...args)const
    {
      return converter(function1(ForwardValue<TArgs>(args)...), function2(ForwardValue<TArgs>(args)...));
    }
};
}   // namespace function_combining

/// <summary>Combine two functions with a converter function. The two functions to combine should have the same argument types.
/// The converter function will use the return values of the two function to calculate the final value.</summary>
/// <typeparam name="F1">Type of the first function.</typeparam>
/// <typeparam name="F2">Type of the second function.</typeparam>
/// <typeparam name="C">Type of the converter function.</typeparam>
/// <returns>A new function whose argument list are the same of the two functions to provide. Calling this function
/// will call function1, function2 and converter in order to calculate the final value.</returns>
/// <param name="converter">The converter function.</param>
/// <param name="function1">The first function.</param>
/// <param name="function2">The second function.</param>
template<typename F1, typename F2, typename C>
Func<typename function_combining::Combining<F1, F2, C>::FinalFunctionType>
Combine(Func<C> converter, Func<F1> function1, Func<F2> function2)
{
  return function_combining::Combining<F1, F2, C>(function1, function2, converter);
}

/// <summary>Use the converter function to create a combiner, who will receive two function and use <see cref="Combine"/> to create
/// a combined function. This function assumes the result types of the two provided function in the future are the same,
/// and the converter function will not change the result type.</summary>
/// <typeparam name="T">Type of the two functions to combine.</typeparam>
/// <returns>The combiner.</returns>
/// <param name="converter">The converter function.</param>
template<typename T>
Func<Func<T>(Func<T>, Func<T>)> Combiner(const
                                         Func<typename Func<T>::ResultType(typename Func<T>::ResultType, typename Func<T>::ResultType)>& converter)
{
  typedef typename Func<T>::ResultType R;
  return Curry<Func<T>(Func<R(R, R)>, Func<T>, Func<T>)>(Combine)(converter);
}
}         // namespace vl

#endif    // VCZH_FUNCTION