// 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 QFUTUREINTERFACE_H
#define QFUTUREINTERFACE_H

#include <QtCore/qmutex.h>
#include <QtCore/qresultstore.h>
#include <QtCore/qtcoreexports.h>
#ifndef QT_NO_EXCEPTIONS
#include <exception>
#endif

#include <utility>

QT_REQUIRE_CONFIG(future);

QT_FORWARD_DECLARE_CLASS(QRunnable)
QT_FORWARD_DECLARE_CLASS(QException)
QT_BEGIN_NAMESPACE


template <typename T> class QFuture;
class QThreadPool;
class QFutureInterfaceBase;
class QFutureInterfaceBasePrivate;
class QFutureWatcherBase;
class QFutureWatcherBasePrivate;

namespace QtPrivate {
template<typename Function, typename ResultType, typename ParentResultType>
class CompactContinuation;

class ExceptionStore;

template<class Function, class ResultType>
class CanceledHandler;

#ifndef QT_NO_EXCEPTIONS
template<class Function, class ResultType>
class FailureHandler;
#endif

struct UnwrapHandler;

#if QT_CORE_REMOVED_SINCE(6, 10)
void Q_CORE_EXPORT watchContinuationImpl(const QObject *context,
                                         QtPrivate::QSlotObjectBase *slotObj,
                                         QFutureInterfaceBase &fi);
#endif // QT_CORE_REMOVED_SINCE(6, 10)
}

class Q_CORE_EXPORT QFutureInterfaceBase
{
public:
    enum State {
        NoState    = 0x00,
        Running    = 0x01,
        Started    = 0x02,
        Finished   = 0x04,
        Canceled   = 0x08,
        Suspending = 0x10,
        Suspended  = 0x20,
        Throttled  = 0x40,
        // Pending means that the future depends on another one, which is not finished yet
        Pending    = 0x80,
    };

    QFutureInterfaceBase(State initialState = NoState);
    QFutureInterfaceBase(const QFutureInterfaceBase &other);
    QFutureInterfaceBase(QFutureInterfaceBase &&other) noexcept
        : d(std::exchange(other.d, nullptr)) {}
    QFutureInterfaceBase &operator=(const QFutureInterfaceBase &other);
    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QFutureInterfaceBase)
    virtual ~QFutureInterfaceBase();

    // reporting functions available to the engine author:
    void reportStarted();
    void reportFinished();
    void reportCanceled();
#ifndef QT_NO_EXCEPTIONS
    void reportException(const QException &e);
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
    void reportException(std::exception_ptr e);
#else
    void reportException(const std::exception_ptr &e);
#endif
#endif
    void reportResultsReady(int beginIndex, int endIndex);

    void setRunnable(QRunnable *runnable);
    void setThreadPool(QThreadPool *pool);
    QThreadPool *threadPool() const;
    void setFilterMode(bool enable);
    void setProgressRange(int minimum, int maximum);
    int progressMinimum() const;
    int progressMaximum() const;
    bool isProgressUpdateNeeded() const;
    void setProgressValue(int progressValue);
    int progressValue() const;
    void setProgressValueAndText(int progressValue, const QString &progressText);
    QString progressText() const;

    void setExpectedResultCount(int resultCount);
    int expectedResultCount();
    int resultCount() const;

    bool queryState(State state) const;
    bool isRunning() const;
    bool isStarted() const;
    bool isCanceled() const;
    bool isFinished() const;
#if QT_DEPRECATED_SINCE(6, 0)
    QT_DEPRECATED_VERSION_X_6_0("Use isSuspending() or isSuspended() instead.")
    bool isPaused() const;

    QT_DEPRECATED_VERSION_X_6_0("Use setSuspended() instead.")
    void setPaused(bool paused) { setSuspended(paused); }

    QT_DEPRECATED_VERSION_X_6_0("Use toggleSuspended() instead.")
    void togglePaused() { toggleSuspended(); }
#endif
    bool isSuspending() const;
    bool isSuspended() const;
    bool isThrottled() const;
    bool isResultReadyAt(int index) const;
    bool isValid() const;
    int loadState() const;

    void cancel();
    void cancelAndFinish() { cancel(CancelMode::CancelAndFinish); }
    void cancelChain();
    void setAddResultsIfCanceledEnabled(bool enable);
    bool isAddResultsIfCanceledEnabled() const;

    void setSuspended(bool suspend);
    void toggleSuspended();
    void reportSuspended() const;
    void setThrottled(bool enable);

    void waitForFinished();
    bool waitForNextResult();
    void waitForResult(int resultIndex);
    void waitForResume();
    void suspendIfRequested();

    QMutex &mutex() const;
    bool hasException() const;
    QtPrivate::ExceptionStore &exceptionStore();
    QtPrivate::ResultStoreBase &resultStoreBase();
    const QtPrivate::ResultStoreBase &resultStoreBase() const;

    inline bool operator==(const QFutureInterfaceBase &other) const { return d == other.d; }
    inline bool operator!=(const QFutureInterfaceBase &other) const { return d != other.d; }

    // ### Qt 7: inline
    void swap(QFutureInterfaceBase &other) noexcept;

    template<typename T>
    static QFutureInterfaceBase get(const QFuture<T> &future);  // implemented in qfuture.h

    bool isChainCanceled() const;

protected:
    // ### Qt 7: remove const from refT/derefT
    bool refT() const noexcept;
    bool derefT() const noexcept;
    void reset();
    void rethrowPossibleException();
public:

#ifndef QFUTURE_TEST
private:
#endif
    friend class QFutureInterfaceBasePrivate;
    QFutureInterfaceBasePrivate *d;

private:
    friend class QFutureWatcherBase;
    friend class QFutureWatcherBasePrivate;

    template<typename Function, typename ResultType, typename ParentResultType>
    friend class QtPrivate::CompactContinuation;

    template<class Function, class ResultType>
    friend class QtPrivate::CanceledHandler;

#ifndef QT_NO_EXCEPTIONS
    template<class Function, class ResultType>
    friend class QtPrivate::FailureHandler;
#endif

    friend struct QtPrivate::UnwrapHandler;

#if QT_CORE_REMOVED_SINCE(6, 10)
    friend Q_CORE_EXPORT void QtPrivate::watchContinuationImpl(
            const QObject *context, QtPrivate::QSlotObjectBase *slotObj, QFutureInterfaceBase &fi);
#endif // QT_CORE_REMOVED_SINCE(6, 10)

    template<class T>
    friend class QPromise;

protected:
    enum class ContinuationType : quint8
    {
        Unknown,
        Then,
        OnFailed,
        OnCanceled,
    };

#if QT_CORE_REMOVED_SINCE(6, 10)
    void setContinuation(std::function<void(const QFutureInterfaceBase &)> func);
    void setContinuation(std::function<void(const QFutureInterfaceBase &)> func,
                         QFutureInterfaceBasePrivate *continuationFutureData);
#endif // QT_CORE_REMOVED_SINCE(6, 10)
    void setContinuation(std::function<void(const QFutureInterfaceBase &)> func,
                         void *continuationFutureData, ContinuationType type);
    void setContinuation(const QObject *context, std::function<void()> func,
                         const QVariant &continuationFuture, ContinuationType type);
    void cleanContinuation();
    void runContinuation() const;

    void setLaunchAsync(bool value);
    bool launchAsync() const;

    bool isRunningOrPending() const;

    enum class CancelMode { CancelOnly, CancelAndFinish };
    void cancel(CancelMode mode);
    void cancelChain(CancelMode mode);
};

inline void swap(QFutureInterfaceBase &lhs, QFutureInterfaceBase &rhs) noexcept
{
    lhs.swap(rhs);
}

template <typename T>
class QFutureInterface : public QFutureInterfaceBase
{
public:
    QFutureInterface(State initialState = NoState)
        : QFutureInterfaceBase(initialState)
    {
        refT();
    }
    QFutureInterface(const QFutureInterface &other)
        : QFutureInterfaceBase(other)
    {
        refT();
    }
    QFutureInterface(const QFutureInterfaceBase &dd) : QFutureInterfaceBase(dd) { refT(); }
    QFutureInterface(QFutureInterfaceBase &&dd) noexcept : QFutureInterfaceBase(std::move(dd)) { refT(); }
    QFutureInterface &operator=(const QFutureInterface &other)
    {
        QFutureInterface copy(other);
        swap(copy);
        return *this;
    }
    QFutureInterface(QFutureInterface &&other) = default;
    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QFutureInterface)

    ~QFutureInterface()
    {
        if (!derefT() && !hasException())
            resultStoreBase().template clear<T>();
    }

    static QFutureInterface canceledResult()
    { return QFutureInterface(State(Started | Finished | Canceled)); }

    inline QFuture<T> future(); // implemented in qfuture.h

    template <typename...Args, std::enable_if_t<std::is_constructible_v<T, Args...>, bool> = true>
    inline bool reportAndEmplaceResult(int index, Args&&...args);
    inline bool reportResult(const T *result, int index = -1);
    inline bool reportAndMoveResult(T &&result, int index = -1);
    inline bool reportResult(T &&result, int index = -1);
    inline bool reportResult(const T &result, int index = -1);
    inline bool reportResults(const QList<T> &results, int beginIndex = -1, int count = -1);
    inline bool reportFinished(const T *result);
    void reportFinished()
    {
        QFutureInterfaceBase::reportFinished();
        QFutureInterfaceBase::runContinuation();
    }

    inline const T &resultReference(int index) const;
    inline const T *resultPointer(int index) const;
    inline QList<T> results();

    T takeResult();
#if 0
    // TODO: Enable and make it return a QList, when QList is fixed to support move-only types
    std::vector<T> takeResults();
#endif

#ifndef QT_NO_EXCEPTIONS
    void reportException(const std::exception_ptr &e)
    {
        if (hasException())
            return;

        resultStoreBase().template clear<T>();
        QFutureInterfaceBase::reportException(e);
    }
    void reportException(const QException &e)
    {
        if (hasException())
            return;

        resultStoreBase().template clear<T>();
        QFutureInterfaceBase::reportException(e);
    }
#endif
};

template <typename T>
inline bool QFutureInterface<T>::reportResult(const T *result, int index)
{
    QMutexLocker<QMutex> locker{&mutex()};
    if ((this->queryState(Canceled) && !this->isAddResultsIfCanceledEnabled()) || this->queryState(Finished))
        return false;

    Q_ASSERT(!hasException());
    QtPrivate::ResultStoreBase &store = resultStoreBase();

    const int resultCountBefore = store.count();
    const int insertIndex = store.addResult<T>(index, result);
    if (insertIndex == -1)
        return false;
    if (store.filterMode()) {
        this->reportResultsReady(resultCountBefore, store.count());
    } else {
        this->reportResultsReady(insertIndex, insertIndex + 1);
    }
    return true;
}

template<typename T>
template<typename...Args, std::enable_if_t<std::is_constructible_v<T, Args...>, bool>>
bool QFutureInterface<T>::reportAndEmplaceResult(int index, Args&&...args)
{
    QMutexLocker<QMutex> locker{&mutex()};
    if ((queryState(Canceled) && !isAddResultsIfCanceledEnabled()) || queryState(Finished))
        return false;

    Q_ASSERT(!hasException());
    QtPrivate::ResultStoreBase &store = resultStoreBase();

    const int oldResultCount = store.count();
    const int insertIndex = store.emplaceResult<T>(index, std::forward<Args>(args)...);
    // Let's make sure it's not in pending results.
    if (insertIndex != -1 && (!store.filterMode() || oldResultCount < store.count()))
        reportResultsReady(insertIndex, store.count());
    return insertIndex != -1;
}

template<typename T>
bool QFutureInterface<T>::reportAndMoveResult(T &&result, int index)
{
    return reportAndEmplaceResult(index, std::move(result));
}

template<typename T>
bool QFutureInterface<T>::reportResult(T &&result, int index)
{
    return reportAndMoveResult(std::move(result), index);
}

template <typename T>
inline bool QFutureInterface<T>::reportResult(const T &result, int index)
{
    return reportResult(&result, index);
}

template<typename T>
inline bool QFutureInterface<T>::reportResults(const QList<T> &_results, int beginIndex, int count)
{
    QMutexLocker<QMutex> locker{&mutex()};
    if ((this->queryState(Canceled) && !this->isAddResultsIfCanceledEnabled()) || this->queryState(Finished))
        return false;

    Q_ASSERT(!hasException());
    auto &store = resultStoreBase();

    const int resultCountBefore = store.count();
    const int insertIndex = store.addResults(beginIndex, &_results, count);
    if (insertIndex == -1)
        return false;
    if (store.filterMode()) {
        this->reportResultsReady(resultCountBefore, store.count());
    } else {
        this->reportResultsReady(insertIndex, insertIndex + _results.size());
    }
    return true;
}

template <typename T>
inline bool QFutureInterface<T>::reportFinished(const T *result)
{
    bool resultReported = false;
    if (result)
        resultReported = reportResult(result);
    reportFinished();
    return resultReported;
}

template <typename T>
inline const T &QFutureInterface<T>::resultReference(int index) const
{
    Q_ASSERT(!hasException());

    QMutexLocker<QMutex> locker{&mutex()};
    return resultStoreBase().resultAt(index).template value<T>();
}

template <typename T>
inline const T *QFutureInterface<T>::resultPointer(int index) const
{
    Q_ASSERT(!hasException());

    QMutexLocker<QMutex> locker{&mutex()};
    return resultStoreBase().resultAt(index).template pointer<T>();
}

template <typename T>
inline QList<T> QFutureInterface<T>::results()
{
    if (this->isCanceled()) {
        rethrowPossibleException();
        return QList<T>();
    }

    QFutureInterfaceBase::waitForResult(-1);

    QList<T> res;
    QMutexLocker<QMutex> locker{&mutex()};

    QtPrivate::ResultIteratorBase it = resultStoreBase().begin();
    while (it != resultStoreBase().end()) {
        res.append(it.value<T>());
        ++it;
    }

    return res;
}

template<typename T>
T QFutureInterface<T>::takeResult()
{
    // Note: we wait for all, this is intentional,
    // not to mess with other unready results.
    waitForResult(-1);

    Q_ASSERT(isValid());
    Q_ASSERT(!hasException());

    const QMutexLocker<QMutex> locker{&mutex()};
    QtPrivate::ResultIteratorBase position = resultStoreBase().resultAt(0);
    T ret(std::move_if_noexcept(position.value<T>()));
    reset();
    resultStoreBase().template clear<T>();

    return ret;
}

#if 0
template<typename T>
std::vector<T> QFutureInterface<T>::takeResults()
{
    waitForResult(-1);

    Q_ASSERT(isValid());
    Q_ASSERT(!hasException());

    std::vector<T> res;
    res.reserve(resultCount());

    const QMutexLocker<QMutex> locker{&mutex()};

    QtPrivate::ResultIteratorBase it = resultStoreBase().begin();
    for (auto endIt = resultStoreBase().end(); it != endIt; ++it)
        res.push_back(std::move_if_noexcept(it.value<T>()));

    reset();
    resultStoreBase().template clear<T>();

    return res;
}
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_CLANG("-Wweak-vtables") // QTBUG-125115

template <>
class QFutureInterface<void> : public QFutureInterfaceBase
{
public:
    explicit QFutureInterface(State initialState = NoState)
        : QFutureInterfaceBase(initialState)
    { }

    QFutureInterface(const QFutureInterfaceBase &dd) : QFutureInterfaceBase(dd) { }

    static QFutureInterface<void> canceledResult()
    { return QFutureInterface(State(Started | Finished | Canceled)); }


    inline QFuture<void> future(); // implemented in qfuture.h

    bool reportResult(const void *, int) { return false; }
    bool reportResults(const QList<void> &, int) { return false; }
    bool reportFinished(const void *)
    {
        reportFinished();
        return false;
    }
    void reportFinished()
    {
        QFutureInterfaceBase::reportFinished();
        QFutureInterfaceBase::runContinuation();
    }
};

QT_WARNING_POP // Clang -Wweak-vtables

template<typename T>
inline void swap(QFutureInterface<T> &a, QFutureInterface<T> &b) noexcept
{
    a.swap(b);
}

QT_END_NAMESPACE

#endif // QFUTUREINTERFACE_H
