/*
Gwenview: an image viewer
Copyright 2007 Aurélien Gâteau <agateau@kde.org>

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 2
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.

*/
#include "documentfactory.h"

// Qt
#include <QByteArray>
#include <QDateTime>
#include <QMap>
#include <QUndoGroup>
#include <QUrl>

// KF

// Local
#include "gwenview_lib_debug.h"
#include <gvdebug.h>

namespace Gwenview
{
#undef ENABLE_LOG
#undef LOG
// #define ENABLE_LOG
#ifdef ENABLE_LOG
#define LOG(x) qCDebug(GWENVIEW_LIB_LOG) << x
#else
#define LOG(x) ;
#endif

inline int getMaxUnreferencedImages()
{
    int defaultValue = 3;
    QByteArray ba = qgetenv("GV_MAX_UNREFERENCED_IMAGES");
    if (ba.isEmpty()) {
        return defaultValue;
    }
    LOG("Custom value for max unreferenced images:" << ba);
    bool ok;
    const int value = ba.toInt(&ok);
    return ok ? value : defaultValue;
}

static const int MAX_UNREFERENCED_IMAGES = getMaxUnreferencedImages();

/**
 * This internal structure holds the document and the last time it has been
 * accessed. This access time is used to "garbage collect" the loaded
 * documents.
 */
struct DocumentInfo {
    Document::Ptr mDocument;
    QDateTime mLastAccess;
};

/**
 * Our collection of DocumentInfo instances. We keep them as pointers to avoid
 * altering DocumentInfo::mDocument refcount, since we rely on it to garbage
 * collect documents.
 */
using DocumentMap = QMap<QUrl, DocumentInfo *>;

struct DocumentFactoryPrivate {
    DocumentMap mDocumentMap;
    QUndoGroup mUndoGroup;

    /**
     * Removes items in a map if they are no longer referenced elsewhere
     */
    void garbageCollect(DocumentMap &map)
    {
        // Build a map of all unreferenced images. We use a MultiMap because in
        // rare cases documents may get accessed at the same millisecond.
        // See https://bugs.kde.org/show_bug.cgi?id=296401
        using UnreferencedImages = QMultiMap<QDateTime, QUrl>;
        UnreferencedImages unreferencedImages;

        DocumentMap::Iterator it = map.begin(), end = map.end();
        for (; it != end; ++it) {
            DocumentInfo *info = it.value();
            if (info->mDocument->ref == 1 && !info->mDocument->isModified()) {
                unreferencedImages.insert(info->mLastAccess, it.key());
            }
        }

        // Remove oldest unreferenced images. Since the map is sorted by key,
        // the oldest one is always unreferencedImages.begin().
        for (UnreferencedImages::Iterator unreferencedIt = unreferencedImages.begin(); unreferencedImages.count() > MAX_UNREFERENCED_IMAGES;
             unreferencedIt = unreferencedImages.erase(unreferencedIt)) {
            const QUrl url = unreferencedIt.value();
            LOG("Collecting" << url);
            it = map.find(url);
            Q_ASSERT(it != map.end());
            delete it.value();
            map.erase(it);
        }

#ifdef ENABLE_LOG
        logDocumentMap(map);
#endif
    }

    void logDocumentMap(const DocumentMap &map)
    {
        LOG("map:");
        DocumentMap::ConstIterator it = map.constBegin(), end = map.constEnd();
        for (; it != end; ++it) {
            LOG("-" << it.key() << "refCount=" << it.value()->mDocument.count() << "lastAccess=" << it.value()->mLastAccess);
        }
    }

    QList<QUrl> mModifiedDocumentList;
};

DocumentFactory::DocumentFactory()
    : d(new DocumentFactoryPrivate)
{
}

DocumentFactory::~DocumentFactory()
{
    qDeleteAll(d->mDocumentMap);
    delete d;
}

DocumentFactory *DocumentFactory::instance()
{
    static DocumentFactory factory;
    return &factory;
}

Document::Ptr DocumentFactory::getCachedDocument(const QUrl &url) const
{
    const DocumentInfo *info = d->mDocumentMap.value(url);
    return info ? info->mDocument : Document::Ptr();
}

Document::Ptr DocumentFactory::load(const QUrl &url)
{
    GV_RETURN_VALUE_IF_FAIL(!url.isEmpty(), Document::Ptr());
    DocumentInfo *info = nullptr;

    DocumentMap::Iterator it = d->mDocumentMap.find(url);

    if (it != d->mDocumentMap.end()) {
        LOG(url.fileName() << "url in mDocumentMap");
        info = it.value();
        info->mLastAccess = QDateTime::currentDateTime();
        return info->mDocument;
    }

    // At this point we couldn't find the document in the map

    // Start loading the document
    LOG(url.fileName() << "loading");
    auto doc = new Document(url);
    connect(doc, &Document::loaded, this, &DocumentFactory::slotLoaded);
    connect(doc, &Document::saved, this, &DocumentFactory::slotSaved);
    connect(doc, &Document::modified, this, &DocumentFactory::slotModified);
    connect(doc, &Document::busyChanged, this, &DocumentFactory::slotBusyChanged);

    // Make sure that an url passed as command line argument is loaded
    // and shown before a possibly long running dirlister on a slow
    // network device is started. So start the dirlister after url is
    // loaded or failed to load.
    connect(doc, &Document::loaded, [this, url]() {
        Q_EMIT readyForDirListerStart(url);
    });
    connect(doc, &Document::loadingFailed, [this, url]() {
        Q_EMIT readyForDirListerStart(url);
    });
    connect(doc, &Document::downSampledImageReady, [this, url]() {
        Q_EMIT readyForDirListerStart(url);
    });

    doc->reload();

    // Create DocumentInfo instance
    info = new DocumentInfo;
    Document::Ptr docPtr(doc);
    info->mDocument = docPtr;
    info->mLastAccess = QDateTime::currentDateTime();

    // Place DocumentInfo in the map
    d->mDocumentMap[url] = info;

    d->garbageCollect(d->mDocumentMap);

    return docPtr;
}

QList<QUrl> DocumentFactory::modifiedDocumentList() const
{
    return d->mModifiedDocumentList;
}

bool DocumentFactory::hasUrl(const QUrl &url) const
{
    return d->mDocumentMap.contains(url);
}

void DocumentFactory::clearCache()
{
    qDeleteAll(d->mDocumentMap);
    d->mDocumentMap.clear();
    d->mModifiedDocumentList.clear();
}

void DocumentFactory::slotLoaded(const QUrl &url)
{
    if (d->mModifiedDocumentList.contains(url)) {
        d->mModifiedDocumentList.removeAll(url);
        Q_EMIT modifiedDocumentListChanged();
        Q_EMIT documentChanged(url);
    }
}

void DocumentFactory::slotSaved(const QUrl &oldUrl, const QUrl &newUrl)
{
    const bool oldIsNew = oldUrl == newUrl;
    const bool oldUrlWasModified = d->mModifiedDocumentList.removeOne(oldUrl);
    bool newUrlWasModified = false;
    if (!oldIsNew) {
        newUrlWasModified = d->mModifiedDocumentList.removeOne(newUrl);
        DocumentInfo *info = d->mDocumentMap.take(oldUrl);
        d->mDocumentMap.insert(newUrl, info);
    }
    d->garbageCollect(d->mDocumentMap);
    if (oldUrlWasModified || newUrlWasModified) {
        Q_EMIT modifiedDocumentListChanged();
    }
    if (oldUrlWasModified) {
        Q_EMIT documentChanged(oldUrl);
    }
    if (!oldIsNew) {
        Q_EMIT documentChanged(newUrl);
    }
}

void DocumentFactory::slotModified(const QUrl &url)
{
    if (!d->mModifiedDocumentList.contains(url)) {
        d->mModifiedDocumentList << url;
        Q_EMIT modifiedDocumentListChanged();
    }
    Q_EMIT documentChanged(url);
}

void DocumentFactory::slotBusyChanged(const QUrl &url, bool busy)
{
    Q_EMIT documentBusyStateChanged(url, busy);
}

QUndoGroup *DocumentFactory::undoGroup()
{
    return &d->mUndoGroup;
}

void DocumentFactory::forget(const QUrl &url)
{
    DocumentInfo *info = d->mDocumentMap.take(url);
    if (!info) {
        return;
    }
    delete info;

    if (d->mModifiedDocumentList.contains(url)) {
        d->mModifiedDocumentList.removeAll(url);
        Q_EMIT modifiedDocumentListChanged();
    }
}

} // namespace

#include "moc_documentfactory.cpp"