validatorresult.h

/*
 * SPDX-FileCopyrightText: (C) 2017-2025 Matthias Fehring <mf@huessenbergnetz.de>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYSTVALIDATORRESULT_H
#define CUTELYSTVALIDATORRESULT_H

#include <Cutelyst/Plugins/Utils/validator_export.h>
#include <Cutelyst/context.h>
#include <coroutine>
#include <functional>

#include <QJsonObject>
#include <QPointer>
#include <QSharedDataPointer>
#include <QString>
#include <QStringList>
#include <QVariantHash>

namespace Cutelyst {

class ValidatorResultPrivate;

class CUTELYST_PLUGIN_UTILS_VALIDATOR_EXPORT ValidatorResult
{
public:
    ValidatorResult();

    ValidatorResult(const ValidatorResult &other) noexcept;

    ValidatorResult(ValidatorResult &&other) noexcept;

    ValidatorResult &operator=(const ValidatorResult &other) noexcept;

    ValidatorResult &operator=(ValidatorResult &&other) noexcept;

    ~ValidatorResult() noexcept;

    [[nodiscard]] bool isValid() const noexcept;

    void addError(const QString &field, const QString &message);

    [[nodiscard]] QStringList errorStrings() const;

    [[nodiscard]] QHash<QString, QStringList> errors() const noexcept;

    [[nodiscard]] QStringList errors(const QString &field) const noexcept;

    [[nodiscard]] bool hasErrors(const QString &field) const noexcept;

    [[nodiscard]] QJsonObject errorsJsonObject() const;

    [[nodiscard]] QStringList failedFields() const;

    explicit operator bool() const noexcept { return isValid(); }

    [[nodiscard]] QVariantHash values() const noexcept;

    [[nodiscard]] QVariant value(const QString &field) const noexcept;

    void addValue(const QString &field, const QVariant &value);

    [[nodiscard]] QVariantHash extras() const noexcept;

    [[nodiscard]] QVariant extra(const QString &field) const noexcept;

    void addExtra(const QString &field, const QVariant &extra);

private:
    QSharedDataPointer<ValidatorResultPrivate> d;
};

class CUTELYST_PLUGIN_UTILS_VALIDATOR_EXPORT AwaitedValidatorResult
{
public:
    bool await_ready() const noexcept { return m_hasResult; }

    bool await_suspend(std::coroutine_handle<> h) noexcept
    {
        m_handle = h;
        if (m_receiver) {
            m_destroyConn = QObject::connect(m_receiver, &QObject::destroyed, [h, this] {
                m_result.addError(
                    QString(), QStringLiteral("Internal Server Error: the context was destroyed."));
                m_hasResult = true;
                h.resume();
            });
        }

        return !await_ready();
    }

    ValidatorResult await_resume() { return m_result; }

    explicit AwaitedValidatorResult(Context *c)
        : m_receiver{c}
    {
        callback = [this](const ValidatorResult &result) {
            m_result    = result; // cppcheck-suppress useInitializationList
            m_hasResult = true;

            if (m_handle) {
                m_handle.resume();
            }
        };
    }

    ~AwaitedValidatorResult() { QObject::disconnect(m_destroyConn); }

protected:
    friend class Validator;
    std::function<void(const ValidatorResult &result)> callback;

private:
    QMetaObject::Connection m_destroyConn;
    QPointer<Context> m_receiver;
    ValidatorResult m_result;
    std::coroutine_handle<> m_handle;
    bool m_hasResult{false};
};

} // namespace Cutelyst

#endif // CUTELYSTVALIDATORRESULT_H