ImageCache.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * Copyright (C) 2025 Marco Craveiro <marco.craveiro@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program 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 General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */
#ifndef ORES_QT_IMAGE_CACHE_HPP
#define ORES_QT_IMAGE_CACHE_HPP
 
#include <unordered_map>
#include <unordered_set>
#include <QObject>
#include <QIcon>
#include <QFutureWatcher>
#include "ores.qt/ClientManager.hpp"
#include "ores.logging/make_logger.hpp"
#include "ores.assets/domain/image.hpp"
#include "ores.assets/messaging/assets_protocol.hpp"
 
namespace ores::qt {
 
class ImageCache final : public QObject {
    Q_OBJECT
 
private:
    inline static std::string_view logger_name = "ores.qt.image_cache";
 
    [[nodiscard]] static auto& lg() {
        using namespace ores::logging;
        static auto instance = make_logger(logger_name);
        return instance;
    }
 
public:
    explicit ImageCache(ClientManager* clientManager, QObject* parent = nullptr);
    ~ImageCache() override = default;
 
    void loadAll();
 
    void reload();
 
    QIcon getIcon(const std::string& image_id);
 
    bool hasIcon(const std::string& image_id) const;
 
    std::size_t cachedIconCount() const { return image_icons_.size(); }
 
    bool isLoading() const { return is_loading_images_; }
 
    void loadImageList();
 
    const std::vector<assets::messaging::image_info>& availableImages() const {
        return available_images_;
    }
 
    bool hasImageList() const { return !available_images_.empty(); }
 
    void loadAllAvailableImages();
 
    void setCurrencyImage(const std::string& iso_code, const std::string& image_id,
        const std::string& assigned_by);
 
    void setCountryImage(const std::string& alpha2_code, const std::string& image_id,
        const std::string& assigned_by);
 
    std::string getNoFlagImageId() const;
 
    QIcon getNoFlagIcon() const;
 
signals:
    void imagesLoaded();
 
    void allLoaded();
 
    void loadError(const QString& error_message);
 
    void imageListLoaded();
 
    void imageLoaded(const QString& image_id);
 
    void allAvailableImagesLoaded();
 
    void currencyImageSet(const QString& iso_code, bool success, const QString& message);
 
    void countryImageSet(const QString& alpha2_code, bool success, const QString& message);
 
private slots:
    void onCurrencyImageIdsLoaded();
    void onCountryImageIdsLoaded();
    void onImagesLoaded();
    void onImageListLoaded();
    void onSingleImageLoaded();
    void onCurrencyImageSet();
    void onCountryImageSet();
    void onAllAvailableImagesLoaded();
    void onIncrementalChangesLoaded();
 
private:
    static QIcon svgToIcon(const std::string& svg_data);
 
    void loadImageById(const std::string& image_id);
 
    void loadCurrencyImageIds();
 
    void loadCountryImageIds();
 
    void loadImagesByIds(const std::vector<std::string>& image_ids);
 
    void loadIncrementalChanges();
 
    struct ImageIdsResult {
        bool success;
        std::vector<std::string> image_ids;
    };
 
    struct ImagesResult {
        bool success;
        std::vector<assets::domain::image> images;
        int failed_batches{0};  
    };
 
    static ImagesResult fetchImagesInBatches(
        ClientManager* clientManager,
        const std::vector<std::string>& image_ids);
 
    struct ImageListResult {
        bool success;
        std::vector<assets::messaging::image_info> images;
    };
 
    struct SingleImageResult {
        bool success;
        std::string image_id;
        assets::domain::image image;
    };
 
    struct SetCurrencyImageResult {
        bool success;
        std::string iso_code;
        std::string message;
    };
 
    struct SetCountryImageResult {
        bool success;
        std::string alpha2_code;
        std::string message;
    };
 
    ClientManager* clientManager_;
 
    // image_id -> cached SVG data
    std::unordered_map<std::string, std::string> image_svg_cache_;
 
    // image_id -> QIcon (rendered from SVG)
    std::unordered_map<std::string, QIcon> image_icons_;
 
    // Loading state
    bool is_loading_images_{false};
    bool is_loading_all_available_{false};
    bool load_all_in_progress_{false};
 
    // Image IDs collected during loadAll() for preloading
    std::vector<std::string> pending_image_ids_;
 
    QFutureWatcher<ImageIdsResult>* currency_ids_watcher_;
    QFutureWatcher<ImageIdsResult>* country_ids_watcher_;
    QFutureWatcher<ImageIdsResult>* incremental_changes_watcher_;
    QFutureWatcher<ImagesResult>* images_watcher_;
    QFutureWatcher<ImageListResult>* image_list_watcher_;
    QFutureWatcher<SingleImageResult>* single_image_watcher_;
    QFutureWatcher<SetCurrencyImageResult>* set_currency_image_watcher_;
    QFutureWatcher<SetCountryImageResult>* set_country_image_watcher_;
    QFutureWatcher<ImagesResult>* all_available_watcher_;
 
    // List of all available images (metadata only)
    std::vector<assets::messaging::image_info> available_images_;
 
    // Track image IDs currently being loaded to prevent duplicate requests
    std::unordered_set<std::string> pending_image_requests_;
 
    // Timestamp of last successful load (for incremental loading)
    std::optional<std::chrono::system_clock::time_point> last_load_time_;
};
 
}
 
#endif