card_picture_loader_worker.h

Go to the documentation of this file.

#ifndef PICTURE_LOADER_WORKER_H
#define PICTURE_LOADER_WORKER_H
 
#include <QHash>
#include <QLoggingCategory>
#include <QObject>
#include <QPair>
#include <QQueue>
#include <QSet>
#include <QString>
#include <QTimer>
#include <QUrl>
#include <qtmetamacros.h>
 
class CardPictureLoaderLocal;
class ExactCard;
class QDateTime;
class QImage;
class QNetworkAccessManager;
class QNetworkDiskCache;
class QNetworkReply;
class QThread;
 
#define REDIRECT_HEADER_NAME "redirects"
#define REDIRECT_ORIGINAL_URL "original"
#define REDIRECT_URL "redirect"
#define REDIRECT_TIMESTAMP "timestamp"
#define REDIRECT_CACHE_FILENAME "cache.ini"
 
inline Q_LOGGING_CATEGORY(CardPictureLoaderWorkerLog, "card_picture_loader.worker")
 
    class CardPictureLoaderWorkerWork;

class CardPictureLoaderWorker : public QObject
{
    Q_OBJECT
 
public:
    explicit CardPictureLoaderWorker();
 
    ~CardPictureLoaderWorker() override;

    void enqueueImageLoad(const ExactCard &card);

    void queueRequest(const QUrl &url, CardPictureLoaderWorkerWork *worker);

    void onHostRateLimited(const QString &host);

    [[nodiscard]] bool shutdownThread();

    QThread *workerThread() const;
 
public slots:
    void clearNetworkCache();
    QNetworkReply *makeRequest(const QUrl &url, CardPictureLoaderWorkerWork *workThread);

    void processQueuedRequests();

    void dispatchQueuedRequest();

    bool processSingleRequest();

    void handleImageLoaded(const ExactCard &card, const QImage &image);

    void cacheRedirect(const QUrl &originalUrl, const QUrl &redirectUrl);

    void removedCachedUrl(const QUrl &url);
 
private:
    QThread *pictureLoaderThread;                      
    QNetworkAccessManager *networkManager;             
    QNetworkDiskCache *cache;                          
    QHash<QUrl, QPair<QUrl, QDateTime>> redirectCache; 
    QString cacheFilePath;                             
    static constexpr int CacheTTLInDays = 30;          
    bool picDownload;                                  
    QQueue<QPair<QUrl, CardPictureLoaderWorkerWork *>> requestLoadQueue; 
 
    QTimer requestTimer;                    
    QTimer dispatchTimer;                   
    QHash<QString, int> hostRequestQuota;   
    QHash<QString, int> hostRequestLimits;  
    QHash<QString, int> hostQuotaRemaining; 
    QHash<QString, QDateTime> hostLast429;  
    QHash<QString, int> hostInFlight;       

    static constexpr int MAX_IN_FLIGHT_PER_HOST = 6;

    static constexpr int MAX_REDIRECT_CHAIN_DEPTH = 10;
 
    CardPictureLoaderLocal *localLoader; 
    QSet<QString> currentlyLoading;      

    [[nodiscard]] int hostAllowanceCeiling(const QString &host) const;

    [[nodiscard]] bool isUnlockedHost(const QString &host) const;

    [[nodiscard]] QUrl getCachedRedirect(const QUrl &originalUrl) const;

    [[nodiscard]] bool requestTouchesNetwork(const QUrl &url) const;

    [[nodiscard]] QUrl resolveCachedRedirect(const QUrl &url) const;

    void loadRedirectCache();

    void saveRedirectCache() const;

    void cleanStaleEntries();

    void updateTimerState();
 
private slots:
    void resetRequestQuota();

    void handleImageLoadEnqueued(const ExactCard &card);
 
signals:
    void imageLoadEnqueued(const ExactCard &card);

    void imageLoaded(const ExactCard &card, const QImage &image);

    void imageRequestQueued(const QUrl &url, const ExactCard &card, const QString &setName);

    void imageRequestSucceeded(const QUrl &url);

    void networkCacheCleared();
};
 
#endif // PICTURE_LOADER_WORKER_H