/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: TaskFrom.hpp
    Date: 2021-11-1
    Author: Reece
***/
 #pragma once

namespace Aurora::Async
{
    template<typename Info_t = AVoid, typename Out_t = AVoid, class ClazzImpl>
    FTask<Info_t, Out_t> TaskFromConsumerRefT(ClazzImpl &&func)
    {
        FTask<Info_t, Out_t> ret;
        ret.onFrame = [callable = func](const Info_t &in)  -> Out_t
        {
            if constexpr (std::is_same_v<Out_t, AVoid>)
            {
                callable(in);
                return {};
            }
            else
            {
                return callable(in);
            }
        };
        return ret;
    }

    template<typename Out_t = AVoid, typename ... Args, typename Functor>
    FTask<std::tuple<Args...>, Out_t> TaskFromTupleCallable(Functor &&func)
    {
        FTask<std::tuple<Args...>, Out_t> ret;
        static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>);
        ret.onFrame = [callable = func](const std::tuple<Args...> &in) -> Out_t
        {
            return std::apply(callable, in);
        };
        return ret;
    }
    
    template<typename Out_t = AVoid, typename Owner_t, typename ... Args>
    FTask<std::tuple<Args...>, Out_t> TaskFromTupleCallableWithOwnerArg(AuFunction<Out_t(Args...)> &&func, const Owner_t &ownerToPin)
    {
        FTask<std::tuple<Owner_t, Args...>, Out_t> ret;
        ret.onFrame = [callable = func](const std::tuple<Args...> &in)  -> Out_t
        {
            return std::apply(callable, std::tuple_cat(std::make_tuple<Owner_t>(ownerToPin), in));
        };
        return ret;
    }
    
    template<typename Task_t, typename ReturnValue_t, typename ... Args, typename Functor>
    Task_t TaskFromTupleCallableWithBindOwner(Functor &&func)
    {
        Task_t ret;
        ret.onFrame = [callable = func](const auto &in)  -> ReturnValue_t
        {
            return std::apply(callable, AuTuplePopFront(in));
        };
        return ret;
    }
    
    template<typename Task_t, typename ReturnValue_t, typename Functor>
    Task_t TaskFromTupleCallableWithBindOwner2(Functor func)
    {
        Task_t ret;
        ret.onFrame = [callable = func](const auto &in)  -> ReturnValue_t
        {
            return std::apply(callable, AuTuplePopFront(in));
        };
        return ret;
    }

    template<typename Info_t = AVoid, typename Out_t = AVoid>
    FTask<Info_t, Out_t> TaskFromVoidVoid(const AuVoidFunc &func)
    {
        FTask<Info_t, Out_t> ret;
        ret.onFrame = [callable = func](const Info_t &in)  -> Out_t
        {
            callable();
            return {};
        };
        return ret;
    }
}