// SPDX-FileCopyrightText: Nheko Contributors
//
// SPDX-License-Identifier: GPL-3.0-or-later

#include <QBuffer>
#include <QPixmapCache>
#include <QPointer>
#include <memory>

#include "AvatarProvider.h"
#include "Cache.h"
#include "MxcImageProvider.h"

static QPixmapCache avatar_cache;

namespace AvatarProvider {
void
resolve(QString avatarUrl, int size, QObject *receiver, AvatarCallback callback)
{
    const auto cacheKey = QStringLiteral("%1_size_%2").arg(avatarUrl).arg(size);

    QPixmap pixmap;
    if (avatarUrl.isEmpty()) {
        callback(pixmap);
        return;
    }

    if (avatar_cache.find(cacheKey, &pixmap)) {
        callback(pixmap);
        return;
    }

    MxcImageProvider::download(avatarUrl.remove(QStringLiteral("mxc://")),
                               QSize(size, size),
                               [callback, cacheKey, recv = QPointer<QObject>(receiver)](
                                 QString, QSize, QImage img, QString) {
                                   if (!recv)
                                       return;

                                   auto proxy = std::make_shared<AvatarProxy>();
                                   QObject::connect(proxy.get(),
                                                    &AvatarProxy::avatarDownloaded,
                                                    recv,
                                                    [callback, cacheKey](QPixmap pm) {
                                                        if (!pm.isNull())
                                                            avatar_cache.insert(cacheKey, pm);
                                                        callback(pm);
                                                    });

                                   if (img.isNull()) {
                                       emit proxy->avatarDownloaded(QPixmap{});
                                       return;
                                   }

                                   auto pm = QPixmap::fromImage(std::move(img));
                                   emit proxy->avatarDownloaded(pm);
                               });
}

void
resolve(const QString &room_id,
        const QString &user_id,
        int size,
        QObject *receiver,
        AvatarCallback callback)
{
    auto avatarUrl = cache::avatarUrl(room_id, user_id);

    resolve(std::move(avatarUrl), size, receiver, callback);
}
}

#include "moc_AvatarProvider.cpp"