context.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2023 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once
 
#include <Cutelyst/async.h>
#include <Cutelyst/cutelyst_export.h>
#include <Cutelyst/request.h>
 
#include <QtCore/QObject>
#include <QtCore/QStack>
#include <QtCore/QStringList>
#include <QtCore/QUrl>
#include <QtCore/QVariant>
 
namespace Cutelyst {
 
class Action;
class Application;
class Component;
class Engine;
class Response;
class Dispatcher;
class Controller;
class View;
class Stats;
class Plugin;
class ContextPrivate;

class CUTELYST_EXPORT Context : public QObject
{
    Q_OBJECT
    Q_PROPERTY(Action *action READ action CONSTANT)
    Q_PROPERTY(QString actionName READ actionName CONSTANT)
    Q_PROPERTY(QString ns READ ns CONSTANT)
    Q_PROPERTY(QString namespace READ ns CONSTANT)
    Q_PROPERTY(Request *req READ request CONSTANT)
    Q_PROPERTY(Request *request READ request CONSTANT)
    Q_PROPERTY(Controller *controller READ controller CONSTANT)
    Q_PROPERTY(QString controllerName READ controllerName CONSTANT)
    Q_PROPERTY(QVariantMap config READ config CONSTANT)
    Q_PROPERTY(bool state READ state CONSTANT)
public:
    explicit Context(Application *app);

    virtual ~Context();

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

    void appendError(const QString &error);

    [[nodiscard]] QStringList errors() const noexcept;

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

    void setState(bool state) noexcept;

    [[nodiscard]] Engine *engine() const noexcept;

    [[nodiscard]] Application *app() const noexcept;

    [[nodiscard]] Response *response() const noexcept;

    [[nodiscard]] Response *res() const noexcept;

    [[nodiscard]] Action *action() const noexcept;

    [[nodiscard]] QString actionName() const noexcept;

    [[nodiscard]] QString ns() const noexcept;

    [[nodiscard]] Request *request() const noexcept;

    [[nodiscard]] Request *req() const noexcept;

    [[nodiscard]] Dispatcher *dispatcher() const noexcept;

    [[nodiscard]] QString controllerName() const noexcept;

    [[nodiscard]] Controller *controller() const noexcept;

    [[nodiscard]] Controller *controller(QStringView name) const;

    [[nodiscard]] View *view(QStringView name = {}) const;

    [[nodiscard]] View *customView() const noexcept;

    bool setCustomView(QStringView name);

    void stash(const QVariantHash &unite);

    [[nodiscard]] QVariantHash &stash();

    [[nodiscard]] QVariant stash(const QString &key) const;

    [[nodiscard]] QVariant stash(const QString &key, const QVariant &defaultValue) const;

    QVariant stashTake(const QString &key);

    bool stashRemove(const QString &key);

    void setStash(const QString &key, const QVariant &value);

    void setStash(const QString &key, const ParamsMultiMap &map);

    [[nodiscard]] QStack<Component *> stack() const noexcept;

    [[nodiscard]] QUrl uriFor(const QString &path               = {},
                              const QStringList &args           = {},
                              const ParamsMultiMap &queryValues = {}) const;

    [[nodiscard]] inline QUrl uriFor(const QString &path, const ParamsMultiMap &queryValues) const;

    [[nodiscard]] QUrl uriFor(Action *action,
                              const QStringList &captures       = {},
                              const QStringList &args           = {},
                              const ParamsMultiMap &queryValues = {}) const;

    [[nodiscard]] inline QUrl uriFor(Action *action, const ParamsMultiMap &queryValues) const;

    [[nodiscard]] QUrl uriForAction(QStringView path,
                                    const QStringList &captures       = {},
                                    const QStringList &args           = {},
                                    const ParamsMultiMap &queryValues = {}) const;

    [[nodiscard]] inline QUrl uriForAction(QStringView path,
                                           const ParamsMultiMap &queryValues) const;

    bool detached() const noexcept;

    void detach(Action *action = nullptr);

    void detachAsync() noexcept;

    void attachAsync();

    bool forward(Component *component);

    bool forward(QStringView action);

    [[nodiscard]] Action *getAction(QStringView action, QStringView ns = {}) const;

    [[nodiscard]] QVector<Action *> getActions(QStringView action, QStringView ns = {}) const;

    [[nodiscard]] QVector<Plugin *> plugins() const;

    template <typename T>
    T plugin()
    {
        const auto pluginsConst = plugins();
        for (Plugin *pluginPtr : pluginsConst) {
            auto p = qobject_cast<T>(pluginPtr);
            if (p) {
                return p;
            }
        }
        return nullptr;
    }

    bool execute(Component *code);

    [[nodiscard]] QLocale locale() const noexcept;

    void setLocale(const QLocale &locale);

    [[nodiscard]] QVariant config(const QString &key, const QVariant &defaultValue = {}) const;

    [[nodiscard]] QVariantMap config() const noexcept;

    [[nodiscard]] QString translate(const char *context,
                                    const char *sourceText,
                                    const char *disambiguation = nullptr,
                                    int n                      = -1) const;
    [[nodiscard]] inline QString qtTrId(const char *id, int n = -1) const;
 
public Q_SLOTS:
    void finalize();
 
protected:
    explicit Context(ContextPrivate *priv);
 
    friend class Application;
    friend class Action;
    friend class ActionREST;
    friend class ActionChain;
    friend class DispatchType;
    friend class Plugin;
    friend class Engine;
    friend class Controller;
    friend class Async;
    ContextPrivate *d_ptr;
 
private:
    Q_DECLARE_PRIVATE(Context)
};
 
inline QUrl Context::uriFor(const QString &path, const ParamsMultiMap &queryValues) const
{
    return uriFor(path, QStringList(), queryValues);
}
 
inline QUrl Context::uriFor(Action *action, const ParamsMultiMap &queryValues) const
{
    return uriFor(action, QStringList(), QStringList(), queryValues);
}
 
inline QUrl Context::uriForAction(QStringView path, const ParamsMultiMap &queryValues) const
{
    return uriForAction(path, QStringList(), QStringList(), queryValues);
}
 
inline QString Context::qtTrId(const char *id, int n) const
{
    return translate(nullptr, id, nullptr, n);
}
 
} // namespace Cutelyst
 
Q_DECLARE_METATYPE(Cutelyst::Context *)