// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default

#ifndef QFUTURE_H
#error Do not include qfuture_impl.h directly
#endif

#if 0
#pragma qt_sync_skip_header_check
#pragma qt_sync_stop_processing
#endif

#include <QtCore/qglobal.h>
#include <QtCore/qfunctionaltools_impl.h>
#include <QtCore/qfutureinterface.h>
#include <QtCore/qthreadpool.h>
#include <QtCore/qexception.h>
#include <QtCore/qpromise.h>

#include <memory>

QT_BEGIN_NAMESPACE

//
// forward declarations
//
template<class T>
class QFuture;
template<class T>
class QFutureInterface;
template<class T>
class QPromise;

namespace QtFuture {

enum class Launch { Sync, Async, Inherit };

template<class T>
struct WhenAnyResult
{
    qsizetype index = -1;
    QFuture<T> future;
};

// Deduction guide
template<class T>
WhenAnyResult(qsizetype, const QFuture<T> &) -> WhenAnyResult<T>;
}

namespace QtPrivate {

template<class T>
using EnableForVoid = std::enable_if_t<std::is_same_v<T, void>>;

template<class T>
using EnableForNonVoid = std::enable_if_t<!std::is_same_v<T, void>>;

template<typename F, typename Arg, typename Enable = void>
struct ResultTypeHelper
{
};

// The callable takes an argument of type Arg
template<typename F, typename Arg>
struct ResultTypeHelper<
        F, Arg, typename std::enable_if_t<!std::is_invocable_v<std::decay_t<F>, QFuture<Arg>>>>
{
    using ResultType = std::invoke_result_t<std::decay_t<F>, std::decay_t<Arg>>;
};

// The callable takes an argument of type QFuture<Arg>
template<class F, class Arg>
struct ResultTypeHelper<
        F, Arg, typename std::enable_if_t<std::is_invocable_v<std::decay_t<F>, QFuture<Arg>>>>
{
    using ResultType = std::invoke_result_t<std::decay_t<F>, QFuture<Arg>>;
};

// The callable takes an argument of type QFuture<void>
template<class F>
struct ResultTypeHelper<
        F, void, typename std::enable_if_t<std::is_invocable_v<std::decay_t<F>, QFuture<void>>>>
{
    using ResultType = std::invoke_result_t<std::decay_t<F>, QFuture<void>>;
};

// The callable doesn't take argument
template<class F>
struct ResultTypeHelper<
        F, void, typename std::enable_if_t<!std::is_invocable_v<std::decay_t<F>, QFuture<void>>>>
{
    using ResultType = std::invoke_result_t<std::decay_t<F>>;
};

// Helpers to remove QPrivateSignal argument from the list of arguments

template<class T, class Enable = void>
inline constexpr bool IsPrivateSignalArg = false;

template<class T>
inline constexpr bool IsPrivateSignalArg<T, typename std::enable_if_t<
        // finds injected-class-name, the 'class' avoids falling into the rules of [class.qual]/2:
        std::is_class_v<class T::QPrivateSignal>
    >> = true;

template<class Tuple, std::size_t... I>
auto cutTuple(Tuple &&t, std::index_sequence<I...>)
{
    return std::make_tuple(std::get<I>(t)...);
}

template<class Arg, class... Args>
auto createTuple(Arg &&arg, Args &&... args)
{
    using TupleType = std::tuple<std::decay_t<Arg>, std::decay_t<Args>...>;
    constexpr auto Size = sizeof...(Args); // One less than the size of all arguments
    if constexpr (QtPrivate::IsPrivateSignalArg<std::tuple_element_t<Size, TupleType>>) {
        if constexpr (Size == 1) {
            return std::forward<Arg>(arg);
        } else {
            return cutTuple(std::make_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...),
                            std::make_index_sequence<Size>());
        }
    } else {
        return std::make_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...);
    }
}

// Helpers to resolve argument types of callables.

template<class Arg, class... Args>
using FilterLastPrivateSignalArg =
        std::conditional_t<(sizeof...(Args) > 0),
                           std::invoke_result_t<decltype(createTuple<Arg, Args...>), Arg, Args...>,
                           std::conditional_t<IsPrivateSignalArg<Arg>, void, Arg>>;

template<typename...>
struct ArgsType;

template<typename Arg, typename... Args>
struct ArgsType<Arg, Args...>
{
    using First = Arg;
    using PromiseType = void;
    using IsPromise = std::false_type;
    static const bool HasExtraArgs = (sizeof...(Args) > 0);
    using AllArgs = FilterLastPrivateSignalArg<std::decay_t<Arg>, std::decay_t<Args>...>;

    template<class Class, class Callable>
    static const bool CanInvokeWithArgs = std::is_invocable_v<Callable, Class, Arg, Args...>;
};

template<typename Arg, typename... Args>
struct ArgsType<QPromise<Arg> &, Args...>
{
    using First = QPromise<Arg> &;
    using PromiseType = Arg;
    using IsPromise = std::true_type;
    static const bool HasExtraArgs = (sizeof...(Args) > 0);
    using AllArgs = FilterLastPrivateSignalArg<QPromise<Arg>, std::decay_t<Args>...>;

    template<class Class, class Callable>
    static const bool CanInvokeWithArgs = std::is_invocable_v<Callable, Class, QPromise<Arg> &, Args...>;
};

template<>
struct ArgsType<>
{
    using First = void;
    using PromiseType = void;
    using IsPromise = std::false_type;
    static const bool HasExtraArgs = false;
    using AllArgs = void;

    template<class Class, class Callable>
    static const bool CanInvokeWithArgs = std::is_invocable_v<Callable, Class>;
};

template<typename F>
struct ArgResolver : ArgResolver<decltype(&std::decay_t<F>::operator())>
{
};

template<typename F>
struct ArgResolver<std::reference_wrapper<F>> : ArgResolver<decltype(&std::decay_t<F>::operator())>
{
};

template<typename R, typename... Args>
struct ArgResolver<R(Args...)> : public ArgsType<Args...>
{
};

template<typename R, typename... Args>
struct ArgResolver<R (*)(Args...)> : public ArgsType<Args...>
{
};

template<typename R, typename... Args>
struct ArgResolver<R (*&)(Args...)> : public ArgsType<Args...>
{
};

template<typename R, typename... Args>
struct ArgResolver<R (* const)(Args...)> : public ArgsType<Args...>
{
};

template<typename R, typename... Args>
struct ArgResolver<R (&)(Args...)> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::*)(Args...)> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::*)(Args...) noexcept> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::*)(Args...) const> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::*)(Args...) const noexcept> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::* const)(Args...) const> : public ArgsType<Args...>
{
};

template<typename Class, typename R, typename... Args>
struct ArgResolver<R (Class::* const)(Args...) const noexcept> : public ArgsType<Args...>
{
};

template<class Class, class Callable>
using EnableIfInvocable = std::enable_if_t<
        QtPrivate::ArgResolver<Callable>::template CanInvokeWithArgs<Class, Callable>>;

template<class T>
inline constexpr bool isQFutureV = false;

template<class T>
inline constexpr bool isQFutureV<QFuture<T>> = true;

template<class T>
using isQFuture = std::bool_constant<isQFutureV<T>>;

template<class T>
struct Future
{
};

template<class T>
struct Future<QFuture<T>>
{
    using type = T;
};

template<class... Args>
using NotEmpty = std::bool_constant<(sizeof...(Args) > 0)>;

template<class Sequence>
using IsRandomAccessible =
        std::is_convertible<typename std::iterator_traits<std::decay_t<decltype(
                                    std::begin(std::declval<Sequence>()))>>::iterator_category,
                            std::random_access_iterator_tag>;

template<class Sequence>
using HasInputIterator =
        std::is_convertible<typename std::iterator_traits<std::decay_t<decltype(
                                    std::begin(std::declval<Sequence>()))>>::iterator_category,
                            std::input_iterator_tag>;

template<class Iterator>
using IsForwardIterable =
        std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category,
                            std::forward_iterator_tag>;

template<typename Function, typename ResultType, typename ParentResultType>
class CompactContinuation : private CompactStorage<Function>
{
    Q_DISABLE_COPY_MOVE(CompactContinuation)
public:
    using Storage = CompactStorage<Function>;

    template<typename F = Function>
    CompactContinuation(F &&func, const QFuture<ParentResultType> &f, QPromise<ResultType> &&p)
        : Storage{std::forward<F>(func)}, promise(std::move(p)), parentFuture(f), type(Type::Sync)
    {
    }

    template<typename F = Function>
    CompactContinuation(F &&func, const QFuture<ParentResultType> &f, QPromise<ResultType> &&p,
                 QThreadPool *pool)
        : Storage{std::forward<F>(func)}, promise(std::move(p)), parentFuture(f),
          threadPool(pool), type(Type::Async)
    {
        runObj = QRunnable::create([continuation = this] {
            continuation->runFunction();
            delete continuation;
        });
        runObj->setAutoDelete(false);
    }

    ~CompactContinuation() { delete runObj; }

    bool execute();

    QRunnable *runnable() const { return runObj; }

    template<typename F = Function>
    static void create(F &&func, QFuture<ParentResultType> *f, QFutureInterface<ResultType> &fi,
                       QtFuture::Launch policy);

    template<typename F = Function>
    static void create(F &&func, QFuture<ParentResultType> *f, QFutureInterface<ResultType> &fi,
                       QThreadPool *pool);

    template<typename F = Function>
    static void create(F &&func, QFuture<ParentResultType> *f, QFutureInterface<ResultType> &fi,
                       QObject *context);

private:
    void fulfillPromiseWithResult();
    void fulfillVoidPromise();
    void fulfillPromiseWithVoidResult();

    template<class... Args>
    void fulfillPromise(Args &&... args);

protected:
    void runImpl()
    {
        if (type == Type::Sync) {
            runFunction();
        } else {
            Q_ASSERT(runObj);
            QThreadPool *pool = threadPool ? threadPool : QThreadPool::globalInstance();
            pool->start(runObj);
        }
    }

    void runFunction();

protected:
    enum class Type : quint8 {
        Sync,
        Async
    };

    QPromise<ResultType> promise;
    QFuture<ParentResultType> parentFuture;
    QThreadPool *threadPool = nullptr;
    QRunnable *runObj = nullptr;
    const Type type;
};

#ifndef QT_NO_EXCEPTIONS

template<class Function, class ResultType>
class FailureHandler
{
public:
    template<typename F = Function>
    static void create(F &&function, QFuture<ResultType> *future,
                       const QFutureInterface<ResultType> &fi);

    template<typename F = Function>
    static void create(F &&function, QFuture<ResultType> *future, QFutureInterface<ResultType> &fi,
                       QObject *context);

    template<typename F = Function>
    FailureHandler(F &&func, const QFuture<ResultType> &f, QPromise<ResultType> &&p)
        : promise(std::move(p)), parentFuture(f), handler(std::forward<F>(func))
    {
    }

public:
    void run();

private:
    template<class ArgType>
    void handleException();
    void handleAllExceptions();

private:
    QPromise<ResultType> promise;
    QFuture<ResultType> parentFuture;
    Function handler;
};

#endif

template<typename Function, typename ResultType, typename ParentResultType>
void CompactContinuation<Function, ResultType, ParentResultType>::runFunction()
{
    promise.start();

    Q_ASSERT(parentFuture.isFinished());

#ifndef QT_NO_EXCEPTIONS
    try {
#endif
        if constexpr (!std::is_void_v<ResultType>) {
            if constexpr (std::is_void_v<ParentResultType>) {
                fulfillPromiseWithVoidResult();
            } else if constexpr (std::is_invocable_v<Function, ParentResultType>) {
                fulfillPromiseWithResult();
            } else {
                // This assert normally should never fail, this is to make sure
                // that nothing unexpected happened.
                static_assert(std::is_invocable_v<Function, QFuture<ParentResultType>>,
                              "The continuation is not invocable with the provided arguments");
                fulfillPromise(parentFuture);
            }
        } else {
            if constexpr (std::is_void_v<ParentResultType>) {
                if constexpr (std::is_invocable_v<Function, QFuture<void>>)
                    this->object()(parentFuture);
                else
                    this->object()();
            } else if constexpr (std::is_invocable_v<Function, ParentResultType>) {
                fulfillVoidPromise();
            } else {
                // This assert normally should never fail, this is to make sure
                // that nothing unexpected happened.
                static_assert(std::is_invocable_v<Function, QFuture<ParentResultType>>,
                              "The continuation is not invocable with the provided arguments");
                this->object()(parentFuture);
            }
        }
#ifndef QT_NO_EXCEPTIONS
    } catch (...) {
        promise.setException(std::current_exception());
    }
#endif
    promise.finish();
}

template<typename Function, typename ResultType, typename ParentResultType>
bool CompactContinuation<Function, ResultType, ParentResultType>::execute()
{
    Q_ASSERT(parentFuture.isFinished());

    if (parentFuture.d.isChainCanceled()) {
#ifndef QT_NO_EXCEPTIONS
        if (parentFuture.d.hasException()) {
            // If the continuation doesn't take a QFuture argument, propagate the exception
            // to the caller, by reporting it. If the continuation takes a QFuture argument,
            // the user may want to catch the exception inside the continuation, to not
            // interrupt the continuation chain, so don't report anything yet.
            if constexpr (!std::is_invocable_v<std::decay_t<Function>, QFuture<ParentResultType>>) {
                promise.start();
                promise.setException(parentFuture.d.exceptionStore().exception());
                promise.finish();
                return false;
            }
        } else
#endif
        {
            promise.start();
            promise.future().cancel();
            promise.finish();
            return false;
        }
    }

    runImpl();
    return true;
}

// Workaround for keeping move-only lambdas inside std::function
template<class Function>
struct ContinuationWrapper
{
    ContinuationWrapper(Function &&f) : function(std::move(f)) { }
    ContinuationWrapper(const ContinuationWrapper &other)
        : function(std::move(const_cast<ContinuationWrapper &>(other).function))
    {
        Q_ASSERT_X(false, "QFuture", "Continuation shouldn't be copied");
    }
    ContinuationWrapper(ContinuationWrapper &&other) = default;
    ContinuationWrapper &operator=(ContinuationWrapper &&) = default;

    void operator()(const QFutureInterfaceBase &parentData) { function(parentData); }

private:
    Function function;
};

template<typename Function, typename ResultType, typename ParentResultType>
template<typename F>
void CompactContinuation<Function, ResultType, ParentResultType>::create(F &&func,
                                                                  QFuture<ParentResultType> *f,
                                                                  QFutureInterface<ResultType> &fi,
                                                                  QtFuture::Launch policy)
{
    Q_ASSERT(f);

    QThreadPool *pool = nullptr;

    bool launchAsync = (policy == QtFuture::Launch::Async);
    if (policy == QtFuture::Launch::Inherit) {
        launchAsync = f->d.launchAsync();

        // If the parent future was using a custom thread pool, inherit it as well.
        if (launchAsync && f->d.threadPool()) {
            pool = f->d.threadPool();
            fi.setThreadPool(pool);
        }
    }

    fi.setLaunchAsync(launchAsync);

    auto continuation = [func = std::forward<F>(func), fi, promise_ = QPromise(fi), pool,
                         launchAsync](const QFutureInterfaceBase &parentData) mutable {
        const auto parent = QFutureInterface<ParentResultType>(parentData).future();
        CompactContinuation<Function, ResultType, ParentResultType> *continuationJob = nullptr;
        if (launchAsync) {
            auto asyncJob = new CompactContinuation<Function, ResultType, ParentResultType>(
                    std::forward<Function>(func), parent, std::move(promise_), pool);
            fi.setRunnable(asyncJob->runnable());
            continuationJob = asyncJob;
        } else {
            continuationJob = new CompactContinuation<Function, ResultType, ParentResultType>(
                    std::forward<Function>(func), parent, std::move(promise_));
        }

        bool isLaunched = continuationJob->execute();
        // If continuation is successfully launched, AsyncContinuation will be deleted
        // from the QRunnable's lambda. Synchronous continuation will be
        // executed immediately, so it's safe to always delete it here.
        if (!(launchAsync && isLaunched)) {
            delete continuationJob;
            continuationJob = nullptr;
        }
    };
    f->d.setContinuation(ContinuationWrapper(std::move(continuation)), fi.d);
}

template<typename Function, typename ResultType, typename ParentResultType>
template<typename F>
void CompactContinuation<Function, ResultType, ParentResultType>::create(F &&func,
                                                                  QFuture<ParentResultType> *f,
                                                                  QFutureInterface<ResultType> &fi,
                                                                  QThreadPool *pool)
{
    Q_ASSERT(f);

    fi.setLaunchAsync(true);
    fi.setThreadPool(pool);

    auto continuation = [func = std::forward<F>(func), promise_ = QPromise(fi),
                         pool](const QFutureInterfaceBase &parentData) mutable {
        const auto parent = QFutureInterface<ParentResultType>(parentData).future();
        auto continuationJob = new CompactContinuation<Function, ResultType, ParentResultType>(
                std::forward<Function>(func), parent, std::move(promise_), pool);
        bool isLaunched = continuationJob->execute();
        // If continuation is successfully launched, AsyncContinuation will be deleted
        // from the QRunnable's lambda.
        if (!isLaunched) {
            delete continuationJob;
            continuationJob = nullptr;
        }
    };
    f->d.setContinuation(ContinuationWrapper(std::move(continuation)), fi.d);
}

template <typename Continuation>
void watchContinuation(const QObject *context, Continuation &&c, QFutureInterfaceBase &fi)
{
    using Prototype = typename QtPrivate::Callable<Continuation>::Function;
    watchContinuationImpl(context,
                          QtPrivate::makeCallableObject<Prototype>(std::forward<Continuation>(c)),
                          fi);
}

template<typename Function, typename ResultType, typename ParentResultType>
template<typename F>
void CompactContinuation<Function, ResultType, ParentResultType>::create(F &&func,
                                                                  QFuture<ParentResultType> *f,
                                                                  QFutureInterface<ResultType> &fi,
                                                                  QObject *context)
{
    Q_ASSERT(f);
    Q_ASSERT(context);

    // When the context object is destroyed, the signal-slot connection is broken and the
    // continuation callback is destroyed. The promise that is created in the capture list is
    // destroyed and, if it is not yet finished, cancelled.
    auto continuation = [func = std::forward<F>(func), parent = *f,
                         promise_ = QPromise(fi)]() mutable {
        CompactContinuation<Function, ResultType, ParentResultType> continuationJob(
                std::forward<Function>(func), parent, std::move(promise_));
        continuationJob.execute();
    };

    QtPrivate::watchContinuation(context, std::move(continuation), f->d);
}

template<typename Function, typename ResultType, typename ParentResultType>
void CompactContinuation<Function, ResultType, ParentResultType>::fulfillPromiseWithResult()
{
    if constexpr (std::is_copy_constructible_v<ParentResultType>)
        fulfillPromise(parentFuture.result());
    else
        fulfillPromise(parentFuture.takeResult());
}

template<typename Function, typename ResultType, typename ParentResultType>
void CompactContinuation<Function, ResultType, ParentResultType>::fulfillVoidPromise()
{
    if constexpr (std::is_copy_constructible_v<ParentResultType>)
        this->object()(parentFuture.result());
    else
        this->object()(parentFuture.takeResult());
}

template<typename Function, typename ResultType, typename ParentResultType>
void CompactContinuation<Function, ResultType, ParentResultType>::fulfillPromiseWithVoidResult()
{
    if constexpr (std::is_invocable_v<Function, QFuture<void>>)
        fulfillPromise(parentFuture);
    else
        fulfillPromise();
}

template<typename Function, typename ResultType, typename ParentResultType>
template<class... Args>
void CompactContinuation<Function, ResultType, ParentResultType>::fulfillPromise(Args &&... args)
{
    promise.addResult(std::invoke(this->object(), std::forward<Args>(args)...));
}

template<class T>
void fulfillPromise(QPromise<T> &promise, QFuture<T> &future)
{
    if constexpr (!std::is_void_v<T>) {
        if constexpr (std::is_copy_constructible_v<T>)
            promise.addResult(future.result());
        else
            promise.addResult(future.takeResult());
    }
}

template<class T, class Function>
void fulfillPromise(QPromise<T> &promise, Function &&handler)
{
    if constexpr (std::is_void_v<T>)
        handler();
    else
        promise.addResult(handler());
}

#ifndef QT_NO_EXCEPTIONS

template<class Function, class ResultType>
template<class F>
void FailureHandler<Function, ResultType>::create(F &&function, QFuture<ResultType> *future,
                                                  const QFutureInterface<ResultType> &fi)
{
    Q_ASSERT(future);

    auto failureContinuation = [function = std::forward<F>(function), promise_ = QPromise(fi)](
                                       const QFutureInterfaceBase &parentData) mutable {
        const auto parent = QFutureInterface<ResultType>(parentData).future();
        FailureHandler<Function, ResultType> failureHandler(std::forward<Function>(function),
                                                            parent, std::move(promise_));
        failureHandler.run();
    };

    future->d.setContinuation(ContinuationWrapper(std::move(failureContinuation)));
}

template<class Function, class ResultType>
template<class F>
void FailureHandler<Function, ResultType>::create(F &&function, QFuture<ResultType> *future,
                                                  QFutureInterface<ResultType> &fi,
                                                  QObject *context)
{
    Q_ASSERT(future);
    Q_ASSERT(context);
    auto failureContinuation = [function = std::forward<F>(function),
                                parent = *future, promise_ = QPromise(fi)]() mutable {
        FailureHandler<Function, ResultType> failureHandler(
                std::forward<Function>(function), parent, std::move(promise_));
        failureHandler.run();
    };

    QtPrivate::watchContinuation(context, std::move(failureContinuation), future->d);
}

template<class Function, class ResultType>
void FailureHandler<Function, ResultType>::run()
{
    Q_ASSERT(parentFuture.isFinished());

    promise.start();

    if (parentFuture.d.hasException()) {
        using ArgType = typename QtPrivate::ArgResolver<Function>::First;
        if constexpr (std::is_void_v<ArgType>) {
            handleAllExceptions();
        } else {
            handleException<ArgType>();
        }
    } else if (parentFuture.d.isChainCanceled()) {
        promise.future().cancel();
    } else {
        QtPrivate::fulfillPromise(promise, parentFuture);
    }
    promise.finish();
}

template<class Function, class ResultType>
template<class ArgType>
void FailureHandler<Function, ResultType>::handleException()
{
    try {
        Q_ASSERT(parentFuture.d.hasException());
        parentFuture.d.exceptionStore().rethrowException();
    } catch (const ArgType &e) {
        try {
            // Handle exceptions matching with the handler's argument type
            if constexpr (std::is_void_v<ResultType>)
                handler(e);
            else
                promise.addResult(handler(e));
        } catch (...) {
            promise.setException(std::current_exception());
        }
    } catch (...) {
        // Exception doesn't match with handler's argument type, propagate
        // the exception to be handled later.
        promise.setException(std::current_exception());
    }
}

template<class Function, class ResultType>
void FailureHandler<Function, ResultType>::handleAllExceptions()
{
    try {
        Q_ASSERT(parentFuture.d.hasException());
        parentFuture.d.exceptionStore().rethrowException();
    } catch (...) {
        try {
            QtPrivate::fulfillPromise(promise, std::forward<Function>(handler));
        } catch (...) {
            promise.setException(std::current_exception());
        }
    }
}

#endif // QT_NO_EXCEPTIONS

template<class Function, class ResultType>
class CanceledHandler
{
public:
    template<class F = Function>
    static void create(F &&handler, QFuture<ResultType> *future, QFutureInterface<ResultType> &fi)
    {
        Q_ASSERT(future);

        auto canceledContinuation = [promise = QPromise(fi), handler = std::forward<F>(handler)](
                                            const QFutureInterfaceBase &parentData) mutable {
            auto parentFuture = QFutureInterface<ResultType>(parentData).future();
            run(std::forward<F>(handler), parentFuture, std::move(promise));
        };
        future->d.setContinuation(ContinuationWrapper(std::move(canceledContinuation)));
    }

    template<class F = Function>
    static void create(F &&handler, QFuture<ResultType> *future, QFutureInterface<ResultType> &fi,
                       QObject *context)
    {
        Q_ASSERT(future);
        Q_ASSERT(context);
        auto canceledContinuation = [handler = std::forward<F>(handler),
                                     parentFuture = *future, promise = QPromise(fi)]() mutable {
            run(std::forward<F>(handler), parentFuture, std::move(promise));
        };

        QtPrivate::watchContinuation(context, std::move(canceledContinuation), future->d);
    }

    template<class F = Function>
    static void run(F &&handler, QFuture<ResultType> &parentFuture, QPromise<ResultType> &&promise)
    {
        promise.start();

        if (parentFuture.isCanceled()) {
#ifndef QT_NO_EXCEPTIONS
            if (parentFuture.d.hasException()) {
                // Propagate the exception to the result future
                promise.setException(parentFuture.d.exceptionStore().exception());
            } else {
                try {
#endif
                    QtPrivate::fulfillPromise(promise, std::forward<F>(handler));
#ifndef QT_NO_EXCEPTIONS
                } catch (...) {
                    promise.setException(std::current_exception());
                }
            }
#endif
        } else {
            QtPrivate::fulfillPromise(promise, parentFuture);
        }

        promise.finish();
    }
};

struct UnwrapHandler
{
    template<class T>
    static auto unwrapImpl(T *outer)
    {
        Q_ASSERT(outer);

        using ResultType = typename QtPrivate::Future<std::decay_t<T>>::type;
        using NestedType = typename QtPrivate::Future<ResultType>::type;
        QFutureInterface<NestedType> promise(QFutureInterfaceBase::State::Pending);

        outer->then([promise](const QFuture<ResultType> &outerFuture) mutable {
            // We use the .then([](QFuture<ResultType> outerFuture) {...}) version
            // (where outerFuture == *outer), to propagate the exception if the
            // outer future has failed.
            Q_ASSERT(outerFuture.isFinished());
#ifndef QT_NO_EXCEPTIONS
            if (outerFuture.d.hasException()) {
                promise.reportStarted();
                promise.reportException(outerFuture.d.exceptionStore().exception());
                promise.reportFinished();
                return;
            }
#endif

            promise.reportStarted();
            ResultType nestedFuture = outerFuture.result();

            nestedFuture.then([promise] (const QFuture<NestedType> &nested) mutable {
#ifndef QT_NO_EXCEPTIONS
                if (nested.d.hasException()) {
                    promise.reportException(nested.d.exceptionStore().exception());
                } else
#endif
                {
                    if constexpr (!std::is_void_v<NestedType>)
                        promise.reportResults(nested.results());
                }
                promise.reportFinished();
            }).onCanceled([promise] () mutable {
                promise.reportCanceled();
                promise.reportFinished();
            });
        }).onCanceled([promise]() mutable {
            // propagate the cancellation of the outer future
            promise.reportStarted();
            promise.reportCanceled();
            promise.reportFinished();
        });
        return promise.future();
    }
};

template<typename ValueType>
QFuture<ValueType> makeReadyRangeFutureImpl(const QList<ValueType> &values)
{
    QFutureInterface<ValueType> promise;
    promise.reportStarted();
    promise.reportResults(values);
    promise.reportFinished();
    return promise.future();
}

} // namespace QtPrivate

namespace QtFuture {

template<class Signal>
using ArgsType = typename QtPrivate::ArgResolver<Signal>::AllArgs;

template<class Sender, class Signal, typename = QtPrivate::EnableIfInvocable<Sender, Signal>>
static QFuture<ArgsType<Signal>> connect(Sender *sender, Signal signal)
{
    using ArgsType = ArgsType<Signal>;
    QFutureInterface<ArgsType> promise;
    promise.reportStarted();
    if (!sender) {
        promise.reportCanceled();
        promise.reportFinished();
        return promise.future();
    }

    using Connections = std::pair<QMetaObject::Connection, QMetaObject::Connection>;
    auto connections = std::make_shared<Connections>();

    if constexpr (std::is_void_v<ArgsType>) {
        connections->first =
                QObject::connect(sender, signal, sender, [promise, connections]() mutable {
                    QObject::disconnect(connections->first);
                    QObject::disconnect(connections->second);
                    promise.reportFinished();
                });
    } else if constexpr (QtPrivate::ArgResolver<Signal>::HasExtraArgs) {
        connections->first = QObject::connect(sender, signal, sender,
                                              [promise, connections](auto... values) mutable {
                                                  QObject::disconnect(connections->first);
                                                  QObject::disconnect(connections->second);
                                                  promise.reportResult(QtPrivate::createTuple(
                                                          std::move(values)...));
                                                  promise.reportFinished();
                                              });
    } else {
        connections->first = QObject::connect(sender, signal, sender,
                                              [promise, connections](ArgsType value) mutable {
                                                  QObject::disconnect(connections->first);
                                                  QObject::disconnect(connections->second);
                                                  promise.reportResult(value);
                                                  promise.reportFinished();
                                              });
    }

    if (!connections->first) {
        promise.reportCanceled();
        promise.reportFinished();
        return promise.future();
    }

    connections->second =
            QObject::connect(sender, &QObject::destroyed, sender, [promise, connections]() mutable {
                QObject::disconnect(connections->first);
                QObject::disconnect(connections->second);
                promise.reportCanceled();
                promise.reportFinished();
            });

    return promise.future();
}

template<typename Container>
using if_container_with_input_iterators =
        std::enable_if_t<QtPrivate::HasInputIterator<Container>::value, bool>;

template<typename Container>
using ContainedType =
        typename std::iterator_traits<decltype(
                    std::cbegin(std::declval<Container&>()))>::value_type;

template<typename Container, if_container_with_input_iterators<Container> = true>
static QFuture<ContainedType<Container>> makeReadyRangeFuture(Container &&container)
{
    // handle QList<T> separately, because reportResults() takes a QList
    // as an input
    using ValueType = ContainedType<Container>;
    if constexpr (std::is_convertible_v<q20::remove_cvref_t<Container>, QList<ValueType>>) {
        return QtPrivate::makeReadyRangeFutureImpl(container);
    } else {
        return QtPrivate::makeReadyRangeFutureImpl(QList<ValueType>{std::cbegin(container),
                                                                    std::cend(container)});
    }
}

template<typename ValueType>
static QFuture<ValueType> makeReadyRangeFuture(std::initializer_list<ValueType> values)
{
    return QtPrivate::makeReadyRangeFutureImpl(QList<ValueType>{values});
}

template<typename T>
static QFuture<std::decay_t<T>> makeReadyValueFuture(T &&value)
{
    QFutureInterface<std::decay_t<T>> promise;
    promise.reportStarted();
    promise.reportResult(std::forward<T>(value));
    promise.reportFinished();

    return promise.future();
}

Q_CORE_EXPORT QFuture<void> makeReadyVoidFuture(); // implemented in qfutureinterface.cpp

#if QT_DEPRECATED_SINCE(6, 10)
template<typename T, typename = QtPrivate::EnableForNonVoid<T>>
QT_DEPRECATED_VERSION_X(6, 10, "Use makeReadyValueFuture() instead.")
static QFuture<std::decay_t<T>> makeReadyFuture(T &&value)
{
    return makeReadyValueFuture(std::forward<T>(value));
}

// the void specialization is moved to the end of qfuture.h, because it now
// uses makeReadyVoidFuture() and required QFuture<void> to be defined.

template<typename T>
QT_DEPRECATED_VERSION_X(6, 10, "Use makeReadyRangeFuture() instead.")
static QFuture<T> makeReadyFuture(const QList<T> &values)
{
    return makeReadyRangeFuture(values);
}
#endif // QT_DEPRECATED_SINCE(6, 10)

#ifndef QT_NO_EXCEPTIONS

template<typename T = void>
static QFuture<T> makeExceptionalFuture(std::exception_ptr exception)
{
    QFutureInterface<T> promise;
    promise.reportStarted();
    promise.reportException(exception);
    promise.reportFinished();

    return promise.future();
}

template<typename T = void>
static QFuture<T> makeExceptionalFuture(const QException &exception)
{
    try {
        exception.raise();
    } catch (...) {
        return makeExceptionalFuture<T>(std::current_exception());
    }
    Q_UNREACHABLE();
}

#endif // QT_NO_EXCEPTIONS

} // namespace QtFuture

namespace QtPrivate {

template<typename ResultFutures>
struct WhenAllContext
{
    using ValueType = typename ResultFutures::value_type;

    explicit WhenAllContext(qsizetype size) : remaining(size) {}

    template<typename T = ValueType>
    void checkForCompletion(qsizetype index, T &&future)
    {
        futures[index] = std::forward<T>(future);
        const auto oldRemaining = remaining.fetchAndSubRelaxed(1);
        Q_ASSERT(oldRemaining > 0);
        if (oldRemaining <= 1) { // that was the last one
            promise.addResult(futures);
            promise.finish();
        }
    }

    QAtomicInteger<qsizetype> remaining;
    QPromise<ResultFutures> promise;
    ResultFutures futures;
};

template<typename ResultType>
struct WhenAnyContext
{
    using ValueType = ResultType;

    template<typename T = ResultType, typename = EnableForNonVoid<T>>
    void checkForCompletion(qsizetype, T &&result)
    {
        if (!ready.fetchAndStoreRelaxed(true)) {
            promise.addResult(std::forward<T>(result));
            promise.finish();
        }
    }

    QAtomicInt ready = false;
    QPromise<ResultType> promise;
};

template<qsizetype Index, typename ContextType, typename... Ts>
void addCompletionHandlersImpl(const std::shared_ptr<ContextType> &context,
                               const std::tuple<Ts...> &t)
{
    auto future = std::get<Index>(t);
    using ResultType = typename ContextType::ValueType;
    // Need context=context so that the compiler does not infer the captured variable's type as 'const'
    future.then([context=context](const std::tuple_element_t<Index, std::tuple<Ts...>> &f) {
        context->checkForCompletion(Index, ResultType { std::in_place_index<Index>, f });
    }).onCanceled([context=context, future]() {
        context->checkForCompletion(Index, ResultType { std::in_place_index<Index>, future });
    });

    if constexpr (Index != 0)
        addCompletionHandlersImpl<Index - 1, ContextType, Ts...>(context, t);
}

template<typename ContextType, typename... Ts>
void addCompletionHandlers(const std::shared_ptr<ContextType> &context, const std::tuple<Ts...> &t)
{
    constexpr qsizetype size = std::tuple_size<std::tuple<Ts...>>::value;
    addCompletionHandlersImpl<size - 1, ContextType, Ts...>(context, t);
}

template<typename OutputSequence, typename InputIt, typename ValueType,
         std::enable_if_t<std::conjunction_v<IsForwardIterable<InputIt>, isQFuture<ValueType>>,
                          bool> = true>
QFuture<OutputSequence> whenAllImpl(InputIt first, InputIt last)
{
    const qsizetype size = std::distance(first, last);
    if (size == 0)
        return QtFuture::makeReadyValueFuture(OutputSequence());

    const auto context = std::make_shared<QtPrivate::WhenAllContext<OutputSequence>>(size);
    context->futures.resize(size);
    context->promise.start();

    qsizetype idx = 0;
    for (auto it = first; it != last; ++it, ++idx) {
        // Need context=context so that the compiler does not infer the captured variable's type as 'const'
        it->then([context=context, idx](const ValueType &f) {
            context->checkForCompletion(idx, f);
        }).onCanceled([context=context, idx, f = *it] {
            context->checkForCompletion(idx, f);
        });
    }
    return context->promise.future();
}

template<typename OutputSequence, typename... Futures>
QFuture<OutputSequence> whenAllImpl(Futures &&... futures)
{
    constexpr qsizetype size = sizeof...(Futures);
    const auto context = std::make_shared<QtPrivate::WhenAllContext<OutputSequence>>(size);
    context->futures.resize(size);
    context->promise.start();

    QtPrivate::addCompletionHandlers(context, std::make_tuple(std::forward<Futures>(futures)...));

    return context->promise.future();
}

template<typename InputIt, typename ValueType,
         std::enable_if_t<std::conjunction_v<IsForwardIterable<InputIt>, isQFuture<ValueType>>,
                          bool> = true>
QFuture<QtFuture::WhenAnyResult<typename Future<ValueType>::type>> whenAnyImpl(InputIt first,
                                                                               InputIt last)
{
    using PackagedType = typename Future<ValueType>::type;
    using ResultType = QtFuture::WhenAnyResult<PackagedType>;

    const qsizetype size = std::distance(first, last);
    if (size == 0) {
        return QtFuture::makeReadyValueFuture(
                QtFuture::WhenAnyResult { qsizetype(-1), QFuture<PackagedType>() });
    }

    const auto context = std::make_shared<QtPrivate::WhenAnyContext<ResultType>>();
    context->promise.start();

    qsizetype idx = 0;
    for (auto it = first; it != last; ++it, ++idx) {
        // Need context=context so that the compiler does not infer the captured variable's type as 'const'
        it->then([context=context, idx](const ValueType &f) {
            context->checkForCompletion(idx, QtFuture::WhenAnyResult { idx, f });
        }).onCanceled([context=context, idx, f = *it] {
            context->checkForCompletion(idx, QtFuture::WhenAnyResult { idx, f });
        });
    }
    return context->promise.future();
}

template<typename... Futures>
QFuture<std::variant<std::decay_t<Futures>...>> whenAnyImpl(Futures &&... futures)
{
    using ResultType = std::variant<std::decay_t<Futures>...>;

    const auto context = std::make_shared<QtPrivate::WhenAnyContext<ResultType>>();
    context->promise.start();

    QtPrivate::addCompletionHandlers(context, std::make_tuple(std::forward<Futures>(futures)...));

    return context->promise.future();
}

} // namespace QtPrivate

QT_END_NAMESPACE
