context.h

/*
 * Copyright (C) 2013-2020 Daniel Nicoletti <dantti12@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
#ifndef CUTELYST_CONTEXT_H
#define CUTELYST_CONTEXT_H

#include <QtCore/QObject>
#include <QtCore/QVariant>
#include <QtCore/QUrl>
#include <QtCore/QStringList>
#include <QtCore/QStack>

#include <Cutelyst/async.h>
#include <Cutelyst/request.h>
#include <Cutelyst/cutelyst_global.h>

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;

    void error(const QString &error);

    QStringList errors() const;

    bool state() const;

    void setState(bool state);

    Engine *engine() const;

    Application *app() const;

    Response *response() const;

    Response *res() const;

    Action *action() const;

    QString actionName() const;

    QString ns() const;

    Request *request() const;

    Request *req() const;

    Dispatcher *dispatcher() const;

    QString controllerName() const;

    Controller *controller() const;

    Controller *controller(const QString &name) const;

    View *view(const QString &name = QString()) const;

    View *customView() const;

    bool setCustomView(const QString &name);

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

    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;

    void detach(Action *action = nullptr);

    void detachAsync();

    void attachAsync();

    bool forward(Component *component);

    bool forward(const QString &action);

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

    QVector<Action *> getActions(const QString &action, const QString &ns = QString()) 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;

    void setLocale(const QLocale &locale);

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

    QVariantMap config() const;

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

    Q_DECL_DEPRECATED bool wait(uint count = 1);

public Q_SLOTS:
    void next(bool force = false);

    void finalize();

protected:
    Context(ContextPrivate *priv);

    friend class Application;
    friend class Action;
    friend class DispatchType;
    friend class Plugin;
    friend class Engine;
    friend class Controller;
    friend class Async;
    ContextPrivate *d_ptr;

private:
    Q_DECLARE_PRIVATE(Context)
};

inline void Context::stash(const QVariantHash &unite)
{ stash().unite(unite); }

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

}

Q_DECLARE_METATYPE(Cutelyst::Context *)

#endif // CUTELYST_CONTEXT_H