#pragma once

namespace Aurora::Async
{
#pragma region EASE_OF_READING
    struct BasicWorkStdFunc : IWorkItemHandler
    {
        AuFunction<void()> callback;
        AuFunction<void()> shutdown; // error

        BasicWorkStdFunc(AuFunction<void()> &&callback, AuFunction<void()> &&shutdown) : callback(std::move(callback)), shutdown(std::move(shutdown))
        {}

        BasicWorkStdFunc(AuFunction<void()> &&callback) : callback(std::move(callback))
        {}

        BasicWorkStdFunc(const AuFunction<void()> &callback) : callback(callback)
        {}

        BasicWorkStdFunc(const AuFunction<void()> &callback, const AuFunction<void()> &shutdown) : callback(callback), shutdown(shutdown)
        {}

    private:
    #if !defined(_CPPSHARP)
        void DispatchFrame(ProcessInfo &info) override
        {
            try
            {
                callback();
            }
            catch (...)
            {
                Debug::PrintError();
            }
        }

        void Shutdown() override
        {
            try
            {
                if (shutdown)
                {
                    shutdown();
                }
            }
            catch (...)
            {
                Debug::PrintError();
            }
        }
    #endif
    };


    /// @hideinitializer
    template<typename Frame_t = AuFunction<void()>, typename Cleanup_t = AuFunction<void()>>
    struct WorkItemCallable : IWorkItemHandler
    {
        Frame_t frame;
        Cleanup_t cleanup;

    private:
        void DispatchFrame(ProcessInfo &info) override
        {
            if constexpr (AuIsBaseOfTemplate<AuFunction, Frame_t>::value)
            {
                if (!frame)
                {
                    info.type = IWorkItemHandler::EProcessNext::eFinished;
                    return;
                }
            }
            frame();
            info.type = IWorkItemHandler::EProcessNext::eFinished;
        }

        void Shutdown() override
        {
            if constexpr (AuIsBaseOfTemplate<AuFunction, Cleanup_t>::value)
            {
                if (!cleanup)
                {
                    return;
                }
            }
            cleanup();
        }
    };


    #define ASYNC_ERROR(exp) { if constexpr (AuIsSame_v<T, bool>) { SysPushErrorGen(exp); return {}; } else { throw AuString(exp); } }
    #define ASYNC_FINISH { if constexpr (AuIsSame_v<T, bool>) { return true; } }

    template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
    static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<void(Args...)> func)
    {
        if (!func) return {};
        return [=](Args&&... in) -> T
        {
            auto work = AuMakeShared<BasicWorkStdFunc>([=]() -> void {
                func(in...);
            });
            if (!work)  ASYNC_ERROR("can't dispatch async call. out of memory");
            auto workItem = NewWorkItem(id, work);
            if (!workItem)  ASYNC_ERROR("can't dispatch async call. out of memory");
            workItem->Dispatch();
            ASYNC_FINISH;
        };
    }
    
    /// Async app only
    template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
    static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcher(AuFunction<void(Args...)> func)
    {
        return TranslateAsyncFunctionToDispatcherWithThread(GetAsyncApp()->GetCurrentThread(), func);
    }
    
    /// Async app only
    template<typename B = void, typename T, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
    static AuFunction<T(AuFunction<void(const B&)>, Args...)> TranslateAsyncReturnableFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<B(Args...)> func)
    {
        return [=](AuFunction<T(const B&)> callback, Args... in) -> T
        {
            auto work = AuMakeShared<WorkPairImpl<AVoid, B>>();
            if (!work)  ASYNC_ERROR("can't dispatch async call; out of memory");
            work.task.onProcess = [=](const AVoid &) -> B
            {
                if (!func) return B{};
                return func(in...);
            };
            work.callback.onSuccess = [=](const AVoid &, const B &ret)
            {
                callback(ret);
            };
            auto workItem = NewWorkItem(id, work);
            if (!workItem)  ASYNC_ERROR("can't dispatch async call; out of memory");
            workItem->Dispatch();
            ASYNC_FINISH;
        };
    }
    
    #undef ASYNC_ERROR
    #undef ASYNC_FINISH

#pragma endregion EASE_OF_READING
}