/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Designer of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qtresourcemodel_p.h"

#include <rcc.h>

#include <QtCore/QStringList>

#include <QtCore/QMap>

#include <QtCore/QResource>

#include <QtCore/QFileInfo>

#include <QtCore/QIODevice>

#include <QtCore/QDir>

#include <QtCore/QDebug>

#include <QtCore/QBuffer>

#include <QtCore/QFileSystemWatcher>

QT_BEGIN_NAMESPACE

enum { debugResourceModel = 0 };

// ------------------- QtResourceSetPrivate

class QtResourceSetPrivate

{

    QtResourceSet *q_ptr;

    Q_DECLARE_PUBLIC(QtResourceSet)

public:

    QtResourceSetPrivate(QtResourceModel *model = 0);

    QtResourceModel *m_resourceModel;

};

QtResourceSetPrivate::QtResourceSetPrivate(QtResourceModel *model) :

   q_ptr(0),

   m_resourceModel(model)

{

}

// -------------------- QtResourceModelPrivate

class QtResourceModelPrivate

{

    QtResourceModel *q_ptr;

    Q_DECLARE_PUBLIC(QtResourceModel)

    Q_DISABLE_COPY(QtResourceModelPrivate)

public:

    QtResourceModelPrivate();

    void activate(QtResourceSet *resourceSet, const QStringList &newPaths, int *errorCount = 0, QString *errorMessages = 0);

    void removeOldPaths(QtResourceSet *resourceSet, const QStringList &newPaths);

    QMap<QString, bool>                     m_pathToModified;

    QMap<QtResourceSet *, QStringList>      m_resourceSetToPaths;

    QMap<QtResourceSet *, bool>             m_resourceSetToReload; // while path is recreated it needs to be reregistered

                                                                   // (it is - in the new current resource set, but when the path was used in

                                                                   // other resource set

                                                                   // then later when that resource set is activated it needs to be reregistered)

    QMap<QtResourceSet *, bool>             m_newlyCreated; // all created but not activated yet

                                                            // (if was active at some point and it's not now it will not be on that map)

    QMap<QString, QList<QtResourceSet *> >  m_pathToResourceSet;

    QtResourceSet                          *m_currentResourceSet;

    typedef QMap<QString, const QByteArray *> PathDataMap;

    PathDataMap m_pathToData;

    QMap<QString, QStringList> m_pathToContents; // qrc path to its contents.

    QMap<QString, QString>     m_fileToQrc; // this map contains the content of active resource set only.

                                            // Activating different resource set changes the contents.

    QFileSystemWatcher *m_fileWatcher;

    bool m_fileWatcherEnabled;

    QMap<QString, bool> m_fileWatchedMap;

private:

    void registerResourceSet(QtResourceSet *resourceSet);

    void unregisterResourceSet(QtResourceSet *resourceSet);

    void setWatcherEnabled(const QString &path, bool enable);

    void addWatcher(const QString &path);

    void removeWatcher(const QString &path);

    void slotFileChanged(const QString &);

    const QByteArray *createResource(const QString &path, QStringList *contents, int *errorCount, QIODevice &errorDevice) const;

    void deleteResource(const QByteArray *data) const;

};

QtResourceModelPrivate::QtResourceModelPrivate() :

    q_ptr(0),

    m_currentResourceSet(0),

    m_fileWatcher(0),

    m_fileWatcherEnabled(true)

{

}

// --------------------- QtResourceSet

QtResourceSet::QtResourceSet() :

    d_ptr(new QtResourceSetPrivate)

{

    d_ptr->q_ptr = this;

}

QtResourceSet::QtResourceSet(QtResourceModel *model) :

     d_ptr(new QtResourceSetPrivate(model))

{

    d_ptr->q_ptr = this;

}

QtResourceSet::~QtResourceSet()

{

}

QStringList QtResourceSet::activeQrcPaths() const

{

    QtResourceSet *that = const_cast<QtResourceSet *>(this);

    return d_ptr->m_resourceModel->d_ptr->m_resourceSetToPaths.value(that);

}

void QtResourceSet::activateQrcPaths(const QStringList &paths, int *errorCount, QString *errorMessages)

{

    d_ptr->m_resourceModel->d_ptr->activate(this, paths, errorCount, errorMessages);

}

bool QtResourceSet::isModified(const QString &path) const

{

    return d_ptr->m_resourceModel->isModified(path);

}

void QtResourceSet::setModified(const QString &path)

{

    d_ptr->m_resourceModel->setModified(path);

}

// ------------------- QtResourceModelPrivate

const QByteArray *QtResourceModelPrivate::createResource(const QString &path, QStringList *contents, int *errorCount, QIODevice &errorDevice) const

{

    typedef RCCResourceLibrary::ResourceDataFileMap ResourceDataFileMap;

    const QByteArray *rc = 0;

    *errorCount = -1;

    contents->clear();

    do {

        // run RCC

        RCCResourceLibrary library;

        library.setVerbose(true);

        library.setInputFiles(QStringList(path));

        library.setFormat(RCCResourceLibrary::Binary);

        QBuffer buffer;

        buffer.open(QIODevice::WriteOnly);

        if (!library.readFiles(/* ignore errors*/ true, errorDevice))

            break;

        // return code cannot be fully trusted, might still be empty

        const ResourceDataFileMap resMap = library.resourceDataFileMap();

        if (resMap.empty())

            break;

        if (!library.output(buffer, errorDevice))

            break;

        *errorCount = library.failedResources().size();

        *contents = resMap.keys();

        buffer.close();

        rc = new QByteArray(buffer.data());

    } while (false);

    if (debugResourceModel)

        qDebug() << "createResource" << path << "returns data=" << rc << " hasWarnings=" << *errorCount;

    return rc;

}

void QtResourceModelPrivate::deleteResource(const QByteArray *data) const

{

    if (data) {

        if (debugResourceModel)

            qDebug() << "deleteResource";

        delete data;

    }

}

void QtResourceModelPrivate::registerResourceSet(QtResourceSet *resourceSet)

{

    if (!resourceSet)

        return;

    // unregister old paths (all because the order of registration is important), later it can be optimized a bit

    QStringList toRegister = resourceSet->activeQrcPaths();

    QStringListIterator itRegister(toRegister);

    while (itRegister.hasNext()) {

        const QString path = itRegister.next();

        if (debugResourceModel)

            qDebug() << "registerResourceSet " << path;

        const PathDataMap::const_iterator itRcc = m_pathToData.constFind(path);

        if (itRcc != m_pathToData.constEnd()) { // otherwise data was not created yet

            if (!QResource::registerResource(reinterpret_cast<const uchar *>(itRcc.value()->constData()))) {

                qDebug() << "** WARNING: Failed to register " << path << " (QResource failure).";

            } else {

                QStringList contents = m_pathToContents.value(path);

                QStringListIterator itContents(contents);

                while (itContents.hasNext()) {

                    const QString filePath = itContents.next();

                    if (!m_fileToQrc.contains(filePath)) // the first loaded resource has higher priority in qt resource system

                        m_fileToQrc.insert(filePath, path);

                }

            }

        }

    }

}

void QtResourceModelPrivate::unregisterResourceSet(QtResourceSet *resourceSet)

{

    if (!resourceSet)

        return;

    // unregister old paths (all because the order of registration is importans), later it can be optimized a bit

    QStringList toUnregister = resourceSet->activeQrcPaths();

    QStringListIterator itUnregister(toUnregister);

    while (itUnregister.hasNext()) {

        const QString path = itUnregister.next();

        if (debugResourceModel)

            qDebug() << "unregisterResourceSet " << path;

        const PathDataMap::const_iterator itRcc = m_pathToData.constFind(path);

        if (itRcc != m_pathToData.constEnd()) { // otherwise data was not created yet

            if (!QResource::unregisterResource(reinterpret_cast<const uchar *>(itRcc.value()->constData())))

                qDebug() << "** WARNING: Failed to unregister " << path << " (QResource failure).";

        }

    }

    m_fileToQrc.clear();

}

void QtResourceModelPrivate::activate(QtResourceSet *resourceSet, const QStringList &newPaths, int *errorCountPtr, QString *errorMessages)

{

    if (debugResourceModel)

        qDebug() << "activate " << resourceSet;

    if (errorCountPtr)

        *errorCountPtr = 0;

    if (errorMessages)

        errorMessages->clear();

    QBuffer errorStream;

    errorStream.open(QIODevice::WriteOnly);

    int errorCount = 0;

    int generatedCount = 0;

    bool newResourceSetChanged = false;

    if (resourceSet && resourceSet->activeQrcPaths() != newPaths && !m_newlyCreated.contains(resourceSet))

        newResourceSetChanged = true;

    PathDataMap newPathToData = m_pathToData;

    QStringListIterator itPath(newPaths);

    while (itPath.hasNext()) {

        const QString path = itPath.next();

        if (resourceSet && !m_pathToResourceSet[path].contains(resourceSet))

            m_pathToResourceSet[path].append(resourceSet);

        const QMap<QString, bool>::iterator itMod = m_pathToModified.find(path);

        if (itMod == m_pathToModified.end() || itMod.value()) { // new path or path is already created, but needs to be recreated

            QStringList contents;

            int qrcErrorCount;

            generatedCount++;

            if (const QByteArray *data = createResource(path, &contents, &qrcErrorCount, errorStream)) {

                newPathToData.insert(path, data);

                if (qrcErrorCount) // Count single failed files as sort of 1/2 error

                    errorCount++;

                addWatcher(path);

            } else {

                newPathToData.remove(path);

                errorCount++;

            }

            m_pathToModified.insert(path, false);

            m_pathToContents.insert(path, contents);

            newResourceSetChanged = true;

            const QMap<QString, QList<QtResourceSet *> >::iterator itReload = m_pathToResourceSet.find(path);

            if (itReload != m_pathToResourceSet.end()) {

                QList<QtResourceSet *> resources = itReload.value();

                QListIterator<QtResourceSet *> itRes(resources);

                while (itRes.hasNext()) {

                    QtResourceSet *res = itRes.next();

                    if (res != resourceSet) {

                        m_resourceSetToReload[res] = true;

                    }

                }

            }

        } else { // path is already created, don't need to recreate

        }

    }

    QList<const QByteArray *> oldData = m_pathToData.values();

    QList<const QByteArray *> newData = newPathToData.values();

    QList<const QByteArray *> toDelete;

    QListIterator<const QByteArray *> itOld(oldData);

    if (itOld.hasNext()) {

        const QByteArray *array = itOld.next();

        if (!newData.contains(array))

            toDelete.append(array);

    }

    // Nothing can fail below here?

    if (generatedCount) {

        if (errorCountPtr)

            *errorCountPtr = errorCount;

        errorStream.close();

        const QString stderrOutput = QString::fromUtf8(errorStream.data());

        if (debugResourceModel)

            qDebug() << "Output: (" << errorCount << ")\n" << stderrOutput;

        if (errorMessages)

            *errorMessages = stderrOutput;

    }

    // register

    const QMap<QtResourceSet *, bool>::iterator itReload = m_resourceSetToReload.find(resourceSet);

    if (itReload != m_resourceSetToReload.end()) {

        if (itReload.value()) {

            newResourceSetChanged = true;

            m_resourceSetToReload.insert(resourceSet, false);

        }

    }

    QStringList oldActivePaths;

    if (m_currentResourceSet)

        oldActivePaths = m_currentResourceSet->activeQrcPaths();

    const bool needReregister = (oldActivePaths != newPaths) || newResourceSetChanged;

    QMap<QtResourceSet *, bool>::iterator itNew = m_newlyCreated.find(resourceSet);

    if (itNew != m_newlyCreated.end()) {

        m_newlyCreated.remove(resourceSet);

        if (needReregister)

            newResourceSetChanged = true;

    }

    if (!newResourceSetChanged && !needReregister && (m_currentResourceSet == resourceSet)) {

        foreach (const QByteArray *data, toDelete)

            deleteResource(data);

        return; // nothing changed

    }

    if (needReregister)

        unregisterResourceSet(m_currentResourceSet);

    foreach (const QByteArray *data, toDelete)

        deleteResource(data);

    m_pathToData = newPathToData;

    m_currentResourceSet = resourceSet;

    if (resourceSet)

        removeOldPaths(resourceSet, newPaths);

    if (needReregister)

        registerResourceSet(m_currentResourceSet);

    emit q_ptr->resourceSetActivated(m_currentResourceSet, newResourceSetChanged);

    // deactivates the paths from old current resource set

    // add new paths to the new current resource set

    // reloads all paths which are marked as modified from the current resource set;

    // activates the paths from current resource set

    // emits resourceSetActivated() (don't emit only in case when old resource set is the same as new one

    // AND no path was reloaded AND the list of paths is exactly the same)

}

void QtResourceModelPrivate::removeOldPaths(QtResourceSet *resourceSet, const QStringList &newPaths)

{

    QStringList oldPaths = m_resourceSetToPaths.value(resourceSet);

    if (oldPaths != newPaths) {

        // remove old

        QStringListIterator itOldPaths(oldPaths);

        while (itOldPaths.hasNext()) {

            QString oldPath = itOldPaths.next();

            if (!newPaths.contains(oldPath)) {

                const QMap<QString, QList<QtResourceSet *> >::iterator itRemove = m_pathToResourceSet.find(oldPath);

                if (itRemove != m_pathToResourceSet.end()) {

                    const int idx = itRemove.value().indexOf(resourceSet);

                    if (idx >= 0)

                        itRemove.value().removeAt(idx);

                    if (itRemove.value().count() == 0) {

                        PathDataMap::iterator it = m_pathToData.find(oldPath);

                        if (it != m_pathToData.end())

                            deleteResource(it.value());

                        m_pathToResourceSet.erase(itRemove);

                        m_pathToModified.remove(oldPath);

                        m_pathToContents.remove(oldPath);

                        m_pathToData.remove(oldPath);

                        removeWatcher(oldPath);

                    }

                }

            }

        }

        m_resourceSetToPaths[resourceSet] = newPaths;

    }

}

void QtResourceModelPrivate::setWatcherEnabled(const QString &path, bool enable)

{

    m_fileWatcher->removePath(path);

    if (!enable)

        return;

    QFileInfo fi(path);

    if (fi.exists())

        m_fileWatcher->addPath(path);

}

void QtResourceModelPrivate::addWatcher(const QString &path)

{

    QMap<QString, bool>::ConstIterator it = m_fileWatchedMap.constFind(path);

    if (it != m_fileWatchedMap.constEnd() && it.value() == false)

        return;

    m_fileWatchedMap.insert(path, true);

    if (!m_fileWatcherEnabled)

        return;

    setWatcherEnabled(path, true);

}

void QtResourceModelPrivate::removeWatcher(const QString &path)

{

    if (!m_fileWatchedMap.contains(path))

        return;

    m_fileWatchedMap.remove(path);

    if (!m_fileWatcherEnabled)

        return;

    setWatcherEnabled(path, false);

}

void QtResourceModelPrivate::slotFileChanged(const QString &path)

{

    setWatcherEnabled(path, false);

    emit q_ptr->qrcFileModifiedExternally(path);

    setWatcherEnabled(path, true); //readd

}

// ----------------------- QtResourceModel

QtResourceModel::QtResourceModel(QObject *parent) :

    QObject(parent),

    d_ptr(new QtResourceModelPrivate)

{

    d_ptr->q_ptr = this;

    d_ptr->m_fileWatcher = new QFileSystemWatcher(this);

    connect(d_ptr->m_fileWatcher, SIGNAL(fileChanged(QString)),

            this, SLOT(slotFileChanged(QString)));

}

QtResourceModel::~QtResourceModel()

{

    blockSignals(true);

    QList<QtResourceSet *> resourceList = resourceSets();

    QListIterator<QtResourceSet *> it(resourceList);

    while (it.hasNext())

        removeResourceSet(it.next());

    blockSignals(false);

}

QStringList QtResourceModel::loadedQrcFiles() const

{

    return d_ptr->m_pathToModified.keys();

}

bool QtResourceModel::isModified(const QString &path) const

{

    QMap<QString, bool>::const_iterator it = d_ptr->m_pathToModified.find(path);

    if (it != d_ptr->m_pathToModified.constEnd())

        return it.value();

    return true;

}

void QtResourceModel::setModified(const QString &path)

{

    QMap<QString, bool>::const_iterator itMod = d_ptr->m_pathToModified.find(path);

    if (itMod == d_ptr->m_pathToModified.constEnd())

        return;

    d_ptr->m_pathToModified[path] = true;

    QMap<QString, QList<QtResourceSet *> >::const_iterator it = d_ptr->m_pathToResourceSet.constFind(path);

    if (it == d_ptr->m_pathToResourceSet.constEnd())

        return;

    QList<QtResourceSet *> resourceList = it.value();

    QListIterator<QtResourceSet *> itReload(resourceList);

    while (itReload.hasNext())

        d_ptr->m_resourceSetToReload.insert(itReload.next(), true);

}

QList<QtResourceSet *> QtResourceModel::resourceSets() const

{

    return d_ptr->m_resourceSetToPaths.keys();

}

QtResourceSet *QtResourceModel::currentResourceSet() const