application.h

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

#include <QtCore/QObject>
#include <QtCore/QVariant>
#include <QtCore/QLocale>
#include <QtCore/QVector>

#include <Cutelyst/cutelyst_global.h>

class QTranslator;

namespace Cutelyst {

#define CUTELYST_APPLICATION(x) \
    Q_PLUGIN_METADATA(x) \
    Q_INTERFACES(Cutelyst::Application)

class Context;
class Controller;
class Component;
class View;
class Dispatcher;
class DispatchType;
class Request;
class Response;
class Engine;
class EngineRequest;
class Plugin;
class Headers;
class ApplicationPrivate;

class CUTELYST_LIBRARY Application : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Application)
public:
    explicit Application(QObject *parent = nullptr);
    virtual ~Application();

    QVector<Controller *> controllers() const noexcept;

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

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

    Dispatcher *dispatcher() const noexcept;

    QVector<DispatchType *> dispatchers() const noexcept;

    QVector<Plugin *> plugins() const noexcept;

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

    QVariantMap config() const noexcept;

    QString pathTo(const QString &path) const;

    QString pathTo(const QStringList &path) const;

    bool inited() const noexcept;

    Engine *engine() const noexcept;

    Component *createComponentPlugin(const QString &name, QObject *parent = nullptr);

    static const char *cutelystVersion() noexcept;

    void addTranslator(const QLocale &locale, QTranslator *translator);

    void addTranslator(const QString &locale, QTranslator *translator);

    void addTranslators(const QLocale &locale, const QVector<QTranslator *> &translators);

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

    void loadTranslations(const QString &filename, const QString &directory = QString(), const QString &prefix = QString(), const QString &suffix = QString());

    QVector<QLocale> loadTranslationsFromDir(const QString &filename, const QString &directory = QString(), const QString &prefix = QStringLiteral("."), const QString &suffix = QStringLiteral(".qm"));

    QVector<QLocale> loadTranslationsFromDirs(const QString &directory, const QString &filename);

protected:
    virtual bool init();

    virtual bool postFork();

    Headers &defaultHeaders() noexcept;

    void addXCutelystVersionHeader();

    bool registerPlugin(Plugin *plugin);

    bool registerController(Controller *controller);

    bool registerView(View *view);

    bool registerDispatcher(DispatchType *dispatcher);

Q_SIGNALS:
    void beforePrepareAction(Cutelyst::Context *c, bool *skipMethod);

    void beforeDispatch(Cutelyst::Context *c);

    void afterDispatch(Cutelyst::Context *c);

    void preForked(Cutelyst::Application *app);

    void postForked(Cutelyst::Application *app);

    void shuttingDown(Cutelyst::Application *app);

protected:
    void setConfig(const QString &key, const QVariant &value);

    friend class Engine;
    friend class Context;

    bool setup(Engine *engine);

    void handleRequest(Cutelyst::EngineRequest *request);

    bool enginePostFork();

    ApplicationPrivate *d_ptr;
};

}

#define CutelystApplicationInterface_iid "org.cutelyst.CutelystApplicationInterface"

Q_DECLARE_INTERFACE(Cutelyst::Application, CutelystApplicationInterface_iid)

#endif // CUTELYST_APPLICATION_H