pagerouter.h

/*
 *  SPDX-FileCopyrightText: 2020 Carson Black <[email protected]>
 *
 *  SPDX-License-Identifier: LGPL-2.0-or-later
 */

#pragma once

#include <QCache>
#include <QQuickItem>
#include <QRandomGenerator>
#include <QQmlPropertyMap>
#include "columnview.h"

static std::map<quint32,QVariant> s_knownVariants;
class PageRouter;

class ParsedRoute : public QObject {
    Q_OBJECT

public:
    QString name;
    QVariant data;
    QVariantMap properties;
    bool cache;
    QQuickItem* item = nullptr;
    void itemDestroyed() {
        item = nullptr;
    }
    QQuickItem* setItem(QQuickItem *newItem) {
        auto ret = item;
        if (ret != nullptr) {
            disconnect(ret, &QObject::destroyed, this, &ParsedRoute::itemDestroyed);
        }
        item = newItem;
        if (newItem != nullptr) {
            connect(newItem, &QObject::destroyed, this, &ParsedRoute::itemDestroyed);
        }
        return ret;
    }
    explicit ParsedRoute(const QString& name = QString(), QVariant data = QVariant(), QVariantMap properties = QVariantMap(), bool cache = false, QQuickItem *item = nullptr)
        : name(name), data(data), properties(properties), cache(cache) {
        setItem(item);
    }
    virtual ~ParsedRoute() {
        if (item) {
            item->deleteLater();
        }
    }
    quint32 hash() {
        for (auto i = s_knownVariants.begin(); i != s_knownVariants.end(); i++) {
            if (i->second == data) {
                return i->first;
            }
        }
        auto number = QRandomGenerator::system()->generate();
        while (s_knownVariants.count(number) > 0) {
            number = QRandomGenerator::system()->generate();
        }
        s_knownVariants[number] = data;
        return number;
    }
    bool equals(const ParsedRoute* rhs, bool countItem = false)
    {
        return name == rhs->name &&
               data == rhs->data &&
               (!countItem || item == rhs->item) &&
               cache == rhs->cache;
    }
};

struct LRU {
    int size = 10;
    QList<QPair<QString,quint32>> evictionList;
    QMap<QPair<QString,quint32>,int> costs;
    QMap<QPair<QString,quint32>,ParsedRoute*> items;

    ParsedRoute* take(QPair<QString,quint32> key) {
        auto ret = items.take(key);
        evictionList.removeAll(key);
        return ret;
    }
    int totalCosts() {
        int ret = 0;
        for (auto cost : qAsConst(costs)) {
            ret += cost;
        }
        return ret;
    }
    void setSize(int size = 10) {
        this->size = size;
        prune();
    }
    void prune() {
        while (size < totalCosts()) {
            auto key = evictionList.last();
            auto item = items.take(key);
            delete item;
            costs.take(key);
            evictionList.takeLast();
        }
    }
    void insert(QPair<QString,quint32> key, ParsedRoute *newItem, int cost) {
        if (items.contains(key)) {
            auto item = items.take(key);
            evictionList.removeAll(key);
            if (item != newItem) {
                delete item;
            }
        }
        costs[key] = cost;
        items[key] = newItem;
        evictionList.prepend(key);
        prune();
    }
};

class PageRouterAttached;

class PreloadRouteGroup : public QObject
{
    Q_OBJECT

    Q_PROPERTY(QJSValue route MEMBER m_route WRITE setRoute NOTIFY changed)
    QJSValue m_route;

    Q_PROPERTY(bool when MEMBER m_when NOTIFY changed)
    bool m_when;

    void handleChange();
    PageRouterAttached* m_parent;

public:
    ~PreloadRouteGroup();
    void setRoute(QJSValue route) {
        m_route = route;
        Q_EMIT changed();
    }
    PreloadRouteGroup(QObject *parent) : QObject(parent) {
        m_parent = qobject_cast<PageRouterAttached*>(parent);
        Q_ASSERT(m_parent);
        connect(this, &PreloadRouteGroup::changed, this, &PreloadRouteGroup::handleChange);
    }
    Q_SIGNAL void changed();
};

class PageRoute : public QObject
{
    Q_OBJECT

    Q_PROPERTY(QString name MEMBER m_name READ name)

    
    Q_PROPERTY(QQmlComponent* component MEMBER m_component READ component)

    Q_PROPERTY(bool cache MEMBER m_cache READ cache)

    Q_PROPERTY(int cost MEMBER m_cost)

    Q_CLASSINFO("DefaultProperty", "component")

Q_SIGNALS:
    void preloadDataChanged();
    void preloadChanged();

private:
    QString m_name;
    QQmlComponent* m_component = nullptr;
    bool m_cache = false;
    int m_cost = 1;

public:
    QQmlComponent* component() { return m_component; };
    QString name() { return m_name; };
    bool cache() { return m_cache; };
    int cost() { return m_cost; };
};

class PageRouter : public QObject, public QQmlParserStatus
{
    Q_OBJECT
    Q_INTERFACES(QQmlParserStatus)

    
    Q_PROPERTY(QQmlListProperty<PageRoute> routes READ routes)

    Q_CLASSINFO("DefaultProperty", "routes")

    Q_PROPERTY(QJSValue initialRoute READ initialRoute WRITE setInitialRoute NOTIFY initialRouteChanged)

    Q_PROPERTY(ColumnView* pageStack MEMBER m_pageStack NOTIFY pageStackChanged)

    Q_PROPERTY(int cacheCapacity READ cacheCapacity WRITE setCacheCapacity)

    Q_PROPERTY(int preloadedPoolCapacity READ preloadedPoolCapacity WRITE setPreloadedPoolCapacity)

    Q_PROPERTY(QQmlPropertyMap* params READ params CONSTANT)

private:
    QSharedPointer<QQmlPropertyMap> m_paramMap;

    void reevaluateParamMapProperties();

    QList<PageRoute*> m_routes;

    ColumnView* m_pageStack = nullptr;

    QJSValue m_initialRoute;

    QList<ParsedRoute*> m_currentRoutes;

    LRU m_cache;

    LRU m_preload;

    void push(ParsedRoute* route);

    bool routesContainsKey(const QString &key) const;

    QQmlComponent *routesValueForKey(const QString &key) const;

    bool routesCacheForKey(const QString &key) const;

    int routesCostForKey(const QString &key) const;

    void preload(ParsedRoute *route);
    void unpreload(ParsedRoute *route);

    void placeInCache(ParsedRoute *route);

    static void appendRoute(QQmlListProperty<PageRoute>* list, PageRoute*);
    static int routeCount(QQmlListProperty<PageRoute>* list);
    static PageRoute* route(QQmlListProperty<PageRoute>* list, int);
    static void clearRoutes(QQmlListProperty<PageRoute>* list);

    QVariant dataFor(QObject* object);
    bool isActive(QObject* object);
    void pushFromObject(QObject *object, QJSValue route, bool replace = false);

    friend class PageRouterAttached;
    friend class PreloadRouteGroup;
    friend class ParsedRoute;

protected:
    void classBegin() override;
    void componentComplete() override;

public:
    PageRouter(QQuickItem *parent = nullptr);
    ~PageRouter();

    QQmlListProperty<PageRoute> routes();

    QQmlPropertyMap* params() { return m_paramMap.data(); }

    QJSValue initialRoute() const;
    void setInitialRoute(QJSValue initialRoute);

    int cacheCapacity() const { return m_cache.size; };
    void setCacheCapacity(int size) { m_cache.setSize(size); };

    int preloadedPoolCapacity() const { return m_preload.size; };
    void setPreloadedPoolCapacity(int size) { m_preload.setSize(size); };

    Q_INVOKABLE void navigateToRoute(QJSValue route);

    Q_INVOKABLE bool routeActive(QJSValue route);

    Q_INVOKABLE void pushRoute(QJSValue route);

    Q_INVOKABLE void popRoute();

    Q_INVOKABLE void bringToView(QJSValue route);

    Q_INVOKABLE QJSValue currentRoutes() const;

    static PageRouterAttached *qmlAttachedProperties(QObject *object);

Q_SIGNALS:
    void routesChanged();
    void initialRouteChanged();
    void pageStackChanged();
    void currentIndexChanged();
    void navigationChanged();
};

class PageRouterAttached : public QObject
{
    Q_OBJECT

    Q_PROPERTY(PageRouter *router READ router WRITE setRouter NOTIFY routerChanged)
    Q_PROPERTY(QVariant data READ data MEMBER m_data NOTIFY dataChanged)

    Q_PROPERTY(bool isCurrent READ isCurrent NOTIFY isCurrentChanged)
    
    Q_PROPERTY(QJSValue watchedRoute READ watchedRoute WRITE setWatchedRoute NOTIFY watchedRouteChanged)

    Q_PROPERTY(PreloadRouteGroup* preload READ preload)

    Q_PROPERTY(bool watchedRouteActive READ watchedRouteActive NOTIFY navigationChanged)

private:
    explicit PageRouterAttached(QObject *parent = nullptr);

    QPointer<PageRouter> m_router;
    PreloadRouteGroup* m_preload;
    QVariant m_data;
    QJSValue m_watchedRoute;

    void findParent();

    friend class PageRouter;
    friend class PreloadRouteGroup;
    friend class ParsedRoute;

public:
    PreloadRouteGroup* preload() const { return m_preload; };
    PageRouter* router() const { return m_router; };
    void setRouter(PageRouter* router) {
        m_router = router;
        Q_EMIT routerChanged();
    }
    QVariant data() const;
    bool isCurrent() const;
    Q_INVOKABLE void navigateToRoute(QJSValue route);
    Q_INVOKABLE bool routeActive(QJSValue route);
    Q_INVOKABLE void pushRoute(QJSValue route);
    Q_INVOKABLE void popRoute();
    // @see PageRouter::bringToView()
    Q_INVOKABLE void bringToView(QJSValue route);
    Q_INVOKABLE void pushFromHere(QJSValue route);
    Q_INVOKABLE void popFromHere();
    Q_INVOKABLE void replaceFromHere(QJSValue route);
    bool watchedRouteActive();
    void setWatchedRoute(QJSValue route);
    QJSValue watchedRoute();

Q_SIGNALS:
    void routerChanged();
    void dataChanged();
    void isCurrentChanged();
    void navigationChanged();
    void watchedRouteChanged();
};

QML_DECLARE_TYPEINFO(PageRouter, QML_HAS_ATTACHED_PROPERTIES)