context.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYST_CONTEXT_H
#define CUTELYST_CONTEXT_H

#include <Cutelyst/async.h>
#include <Cutelyst/cutelyst_global.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_LIBRARY 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:
    Context(Application *app);
    virtual ~Context();

    bool error() const noexcept;

    void error(const QString &error);

    QStringList errors() const noexcept;

    bool state() const noexcept;

    void setState(bool state) noexcept;

    Engine *engine() const noexcept;

    Application *app() const noexcept;

    Response *response() const noexcept;

    Response *res() const noexcept;

    Action *action() const noexcept;

    QString actionName() const noexcept;

    QString ns() const noexcept;

    Request *request() const noexcept;

    Request *req() const noexcept;

    Dispatcher *dispatcher() const noexcept;

    QString controllerName() const;

    Controller *controller() const noexcept;

    Controller *controller(const QString &name) const;

    View *view(const QString &name) const;

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

    View *customView() const noexcept;

    bool setCustomView(const QString &name);

    void stash(const QVariantHash &unite);

    QVariantHash &stash();

    QVariant stash(const QString &key) const;

    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);

    QStack<Component *> stack() const noexcept;

    QUrl uriFor(const QString &path               = QString(),
                const QStringList &args           = QStringList(),
                const ParamsMultiMap &queryValues = ParamsMultiMap()) const;

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

    QUrl uriFor(Action *action,
                const QStringList &captures       = QStringList(),
                const QStringList &args           = QStringList(),
                const ParamsMultiMap &queryValues = ParamsMultiMap()) const;

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

    QUrl uriForAction(const QString &path,
                      const QStringList &captures       = QStringList(),
                      const QStringList &args           = QStringList(),
                      const ParamsMultiMap &queryValues = ParamsMultiMap()) const;

    inline QUrl uriForAction(const QString &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(const QString &action);

    Action *getAction(const QString &action, const QString &ns = {}) const;

    QVector<Action *> getActions(const QString &action, const QString &ns = {}) const;

    QVector<Plugin *> plugins() const;

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

    bool execute(Component *code);

    QLocale locale() const noexcept;

    void setLocale(const QLocale &locale);

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

    QVariantMap config() const noexcept;

    QString translate(const char *context,
                      const char *sourceText,
                      const char *disambiguation = nullptr,
                      int n                      = -1) const;
    inline QString qtTrId(const char *id, int n = -1) const;

public Q_SLOTS:
    void finalize();

protected:
    Context(ContextPrivate *priv);

    friend class Application;
    friend class Action;
    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(const QString &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 *)

#endif // CUTELYST_CONTEXT_H