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

**

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

** All rights reserved.

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

**

** This file is part of the tools applications 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 "rcc.h"

#include <QtCore/QByteArray>

#include <QtCore/QDateTime>

#include <QtCore/QDebug>

#include <QtCore/QDir>

#include <QtCore/QDirIterator>

#include <QtCore/QFile>

#include <QtCore/QIODevice>

#include <QtCore/QLocale>

#include <QtCore/QStack>

#include <QtXml/QDomDocument>

QT_BEGIN_NAMESPACE

enum {

    CONSTANT_USENAMESPACE = 1,

    CONSTANT_COMPRESSLEVEL_DEFAULT = -1,

    CONSTANT_COMPRESSTHRESHOLD_DEFAULT = 70

};

#define writeString(s) write(s, sizeof(s))

void RCCResourceLibrary::write(const char *str, int len)

{

    --len; // trailing \0 on string literals...

    int n = m_out.size();

    m_out.resize(n + len);

    memcpy(m_out.data() + n, str, len);

}

void RCCResourceLibrary::writeByteArray(const QByteArray &other)

{

    m_out.append(other);

}

static inline QString msgOpenReadFailed(const QString &fname, const QString &why)

{

    return QString::fromUtf8("Unable to open %1 for reading: %2\n").arg(fname).arg(why);

}

///////////////////////////////////////////////////////////

//

// RCCFileInfo

//

///////////////////////////////////////////////////////////

class RCCFileInfo

{

public:

    enum Flags

    {

        NoFlags = 0x00,

        Compressed = 0x01,

        Directory = 0x02

    };

    RCCFileInfo(const QString &name = QString(), const QFileInfo &fileInfo = QFileInfo(),

                QLocale::Language language = QLocale::C,

                QLocale::Country country = QLocale::AnyCountry,

                uint flags = NoFlags,

                int compressLevel = CONSTANT_COMPRESSLEVEL_DEFAULT,

                int compressThreshold = CONSTANT_COMPRESSTHRESHOLD_DEFAULT);

    ~RCCFileInfo();

    QString resourceName() const;

public:

    qint64 writeDataBlob(RCCResourceLibrary &lib, qint64 offset, QString *errorMessage);

    qint64 writeDataName(RCCResourceLibrary &, qint64 offset);

    void writeDataInfo(RCCResourceLibrary &lib);

    int m_flags;

    QString m_name;

    QLocale::Language m_language;

    QLocale::Country m_country;

    QFileInfo m_fileInfo;

    RCCFileInfo *m_parent;

    QHash<QString, RCCFileInfo*> m_children;

    int m_compressLevel;

    int m_compressThreshold;

    qint64 m_nameOffset;

    qint64 m_dataOffset;

    qint64 m_childOffset;

};

RCCFileInfo::RCCFileInfo(const QString &name, const QFileInfo &fileInfo,

    QLocale::Language language, QLocale::Country country, uint flags,

    int compressLevel, int compressThreshold)

{

    m_name = name;

    m_fileInfo = fileInfo;

    m_language = language;

    m_country = country;

    m_flags = flags;

    m_parent = 0;

    m_nameOffset = 0;

    m_dataOffset = 0;

    m_childOffset = 0;

    m_compressLevel = compressLevel;

    m_compressThreshold = compressThreshold;

}

RCCFileInfo::~RCCFileInfo()

{

    qDeleteAll(m_children);

}

QString RCCFileInfo::resourceName() const

{

    QString resource = m_name;

    for (RCCFileInfo *p = m_parent; p; p = p->m_parent)

        resource = resource.prepend(p->m_name + QLatin1Char('/'));

    return QLatin1Char(':') + resource;

}

void RCCFileInfo::writeDataInfo(RCCResourceLibrary &lib)

{

    const bool text = (lib.m_format == RCCResourceLibrary::C_Code);

    //some info

    if (text) {

        if (m_language != QLocale::C) {

            lib.writeString("  // ");

            lib.writeByteArray(resourceName().toLocal8Bit());

            lib.writeString(" [");

            lib.writeByteArray(QByteArray::number(m_country));

            lib.writeString("::");

            lib.writeByteArray(QByteArray::number(m_language));

            lib.writeString("[\n  ");

        } else {

            lib.writeString("  // ");

            lib.writeByteArray(resourceName().toLocal8Bit());

            lib.writeString("\n  ");

        }

    }

    //pointer data

    if (m_flags & RCCFileInfo::Directory) {

        // name offset

        lib.writeNumber4(m_nameOffset);

        // flags

        lib.writeNumber2(m_flags);

        // child count

        lib.writeNumber4(m_children.size());

        // first child offset

        lib.writeNumber4(m_childOffset);

    } else {

        // name offset

        lib.writeNumber4(m_nameOffset);

        // flags

        lib.writeNumber2(m_flags);

        // locale

        lib.writeNumber2(m_country);

        lib.writeNumber2(m_language);

        //data offset

        lib.writeNumber4(m_dataOffset);

    }

    if (text)

        lib.writeChar('\n');

}

qint64 RCCFileInfo::writeDataBlob(RCCResourceLibrary &lib, qint64 offset,

    QString *errorMessage)

{

    const bool text = (lib.m_format == RCCResourceLibrary::C_Code);

    //capture the offset

    m_dataOffset = offset;

    //find the data to be written

    QFile file(m_fileInfo.absoluteFilePath());

    if (!file.open(QFile::ReadOnly)) {

        *errorMessage = msgOpenReadFailed(m_fileInfo.absoluteFilePath(), file.errorString());

        return 0;

    }

    QByteArray data = file.readAll();

#ifndef QT_NO_COMPRESS

    // Check if compression is useful for this file

    if (m_compressLevel != 0 && data.size() != 0) {

        QByteArray compressed =

            qCompress(reinterpret_cast<uchar *>(data.data()), data.size(), m_compressLevel);

        int compressRatio = int(100.0 * (data.size() - compressed.size()) / data.size());

        if (compressRatio >= m_compressThreshold) {

            data = compressed;

            m_flags |= Compressed;

        }

    }

#endif // QT_NO_COMPRESS

    // some info

    if (text) {

        lib.writeString("  // ");

        lib.writeByteArray(m_fileInfo.absoluteFilePath().toLocal8Bit());

        lib.writeString("\n  ");

    }

    // write the length

    lib.writeNumber4(data.size());

    if (text)

        lib.writeString("\n  ");

    offset += 4;

    // write the payload

    const char *p = data.constData();

    if (text) {

        for (int i = data.size(), j = 0; --i >= 0; --j) {

            lib.writeHex(*p++);

            if (j == 0) {

                lib.writeString("\n  ");

                j = 16;

            }

        }

    } else {

        for (int i = data.size(); --i >= 0; )

           lib.writeChar(*p++);

    }

    offset += data.size();

    // done

    if (text)

        lib.writeString("\n  ");

    return offset;

}

qint64 RCCFileInfo::writeDataName(RCCResourceLibrary &lib, qint64 offset)

{

    const bool text = (lib.m_format == RCCResourceLibrary::C_Code);

    // capture the offset

    m_nameOffset = offset;

    // some info

    if (text) {

        lib.writeString("  // ");

        lib.writeByteArray(m_name.toLocal8Bit());

        lib.writeString("\n  ");

    }

    // write the length

    lib.writeNumber2(m_name.length());

    if (text)

        lib.writeString("\n  ");

    offset += 2;

    // write the hash

    lib.writeNumber4(qHash(m_name));

    if (text)

        lib.writeString("\n  ");

    offset += 4;

    // write the m_name

    const QChar *unicode = m_name.unicode();

    for (int i = 0; i < m_name.length(); ++i) {

        lib.writeNumber2(unicode[i].unicode());

        if (text && i % 16 == 0)

            lib.writeString("\n  ");

    }

    offset += m_name.length()*2;

    // done

    if (text)

        lib.writeString("\n  ");

    return offset;

}

///////////////////////////////////////////////////////////

//

// RCCResourceLibrary

//

///////////////////////////////////////////////////////////

RCCResourceLibrary::Strings::Strings() :

   TAG_RCC(QLatin1String("RCC")),

   TAG_RESOURCE(QLatin1String("qresource")),

   TAG_FILE(QLatin1String("file")),

   ATTRIBUTE_LANG(QLatin1String("lang")),

   ATTRIBUTE_PREFIX(QLatin1String("prefix")),

   ATTRIBUTE_ALIAS(QLatin1String("alias")),

   ATTRIBUTE_THRESHOLD(QLatin1String("threshold")),

   ATTRIBUTE_COMPRESS(QLatin1String("compress"))

{

}

RCCResourceLibrary::RCCResourceLibrary()

  : m_root(0),

    m_format(C_Code),

    m_verbose(false),

    m_compressLevel(CONSTANT_COMPRESSLEVEL_DEFAULT),

    m_compressThreshold(CONSTANT_COMPRESSTHRESHOLD_DEFAULT),

    m_treeOffset(0),

    m_namesOffset(0),

    m_dataOffset(0),

    m_useNameSpace(CONSTANT_USENAMESPACE),

    m_errorDevice(0)

{

    m_out.reserve(30 * 1000 * 1000);

}

RCCResourceLibrary::~RCCResourceLibrary()

{

    delete m_root;

}

bool RCCResourceLibrary::interpretResourceFile(QIODevice *inputDevice,

    const QString &fname, QString currentPath, bool ignoreErrors)

{

    Q_ASSERT(m_errorDevice);

    const QChar slash = QLatin1Char('/');

    if (!currentPath.isEmpty() && !currentPath.endsWith(slash))

        currentPath += slash;

    QDomDocument document;

    {

        QString errorMsg;

        int errorLine = 0;

        int errorColumn = 0;

        if (!document.setContent(inputDevice, &errorMsg, &errorLine, &errorColumn)) {

            if (ignoreErrors)

                return true;

            const QString msg = QString::fromUtf8("RCC Parse Error: '%1' Line: %2 Column: %3 [%4]\n").arg(fname).arg(errorLine).arg(errorColumn).arg(errorMsg);

            m_errorDevice->write(msg.toUtf8());

            return false;

        }

    }

    QDomElement domRoot = document.firstChildElement(m_strings.TAG_RCC).toElement();

    if (!domRoot.isNull() && domRoot.tagName() == m_strings.TAG_RCC) {

        for (QDomNode node = domRoot.firstChild(); !node.isNull(); node = node.nextSibling()) {

            if (!node.isElement())

                continue;

            QDomElement child = node.toElement();

            if (!child.isNull() && child.tagName() == m_strings.TAG_RESOURCE) {

                QLocale::Language language = QLocale::c().language();

                QLocale::Country country = QLocale::c().country();

                if (child.hasAttribute(m_strings.ATTRIBUTE_LANG)) {

                    QString attribute = child.attribute(m_strings.ATTRIBUTE_LANG);

                    QLocale lang = QLocale(attribute);

                    language = lang.language();

                    if (2 == attribute.length()) {

                        // Language only

                        country = QLocale::AnyCountry;

                    } else {

                        country = lang.country();

                    }

                }

                QString prefix;

                if (child.hasAttribute(m_strings.ATTRIBUTE_PREFIX))

                    prefix = child.attribute(m_strings.ATTRIBUTE_PREFIX);

                if (!prefix.startsWith(slash))

                    prefix.prepend(slash);

                if (!prefix.endsWith(slash))

                    prefix += slash;

                for (QDomNode res = child.firstChild(); !res.isNull(); res = res.nextSibling()) {

                    if (res.isElement() && res.toElement().tagName() == m_strings.TAG_FILE) {

                        QString fileName(res.firstChild().toText().data());

                        if (fileName.isEmpty()) {

                            const QString msg = QString::fromUtf8("RCC: Warning: Null node in XML of '%1'\n").arg(fname);

                            m_errorDevice->write(msg.toUtf8());

                        }

                        QString alias;

                        if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_ALIAS))

                            alias = res.toElement().attribute(m_strings.ATTRIBUTE_ALIAS);

                        else

                            alias = fileName;

                        int compressLevel = m_compressLevel;

                        if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_COMPRESS))

                            compressLevel = res.toElement().attribute(m_strings.ATTRIBUTE_COMPRESS).toInt();

                        int compressThreshold = m_compressThreshold;

                        if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_THRESHOLD))

                            compressThreshold = res.toElement().attribute(m_strings.ATTRIBUTE_THRESHOLD).toInt();

                        // Special case for -no-compress. Overrides all other settings.

                        if (m_compressLevel == -2)

                            compressLevel = 0;

                        alias = QDir::cleanPath(alias);

                        while (alias.startsWith(QLatin1String("../")))

                            alias.remove(0, 3);

                        alias = QDir::cleanPath(m_resourceRoot) + prefix + alias;

                        QString absFileName = fileName;

                        if (QDir::isRelativePath(absFileName))

                            absFileName.prepend(currentPath);

                        QFileInfo file(absFileName);

                        if (!file.exists()) {

                            m_failedResources.push_back(absFileName);

                            const QString msg = QString::fromUtf8("RCC: Error in '%1': Cannot find file '%2'\n").arg(fname).arg(fileName);

                            m_errorDevice->write(msg.toUtf8());

                            if (ignoreErrors)

                                continue;

                            else

                                return false;

                        } else if (file.isFile()) {

                            const bool arc = addFile(alias, RCCFileInfo(alias.section(slash, -1), file, language, country,

                                                                        RCCFileInfo::NoFlags, compressLevel, compressThreshold));

                            if (!arc)

                                m_failedResources.push_back(absFileName);

                        } else {

                            QDir dir;

                            if (file.isDir()) {

                                dir.setPath(file.filePath());

                            } else {

                                dir.setPath(file.path());

                                dir.setNameFilters(QStringList(file.fileName()));

                                if (alias.endsWith(file.fileName()))

                                    alias = alias.left(alias.length()-file.fileName().length());

                            }

                            if (!alias.endsWith(slash))

                                alias += slash;

                            QDirIterator it(dir, QDirIterator::FollowSymlinks|QDirIterator::Subdirectories);

                            while (it.hasNext()) {

                                it.next();

                                QFileInfo child(it.fileInfo());

                                if (child.fileName() != QLatin1String(".") && child.fileName() != QLatin1String("..")) {

                                    const bool arc = addFile(alias + child.fileName(),

                                                             RCCFileInfo(child.fileName(), child, language, country,

                                                             RCCFileInfo::NoFlags, compressLevel, compressThreshold));

                                    if (!arc)

                                        m_failedResources.push_back(child.fileName());

                                }

                            }

                        }

                    }

                }

            }

        }

    }

    if (m_root == 0) {

        const QString msg = QString::fromUtf8("RCC: Warning: No resources in '%1'.\n").arg(fname);

        m_errorDevice->write(msg.toUtf8());

        if (!ignoreErrors && m_format == Binary) {

            // create dummy entry, otherwise loading qith QResource will crash

            m_root = new RCCFileInfo(QString(), QFileInfo(),

                    QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);

        }

    }

    return true;

}

bool RCCResourceLibrary::addFile(const QString &alias, const RCCFileInfo &file)

{

    Q_ASSERT(m_errorDevice);

    if (file.m_fileInfo.size() > 0xffffffff) {

        const QString msg = QString::fromUtf8("File too big: %1\n").arg(file.m_fileInfo.absoluteFilePath());

        m_errorDevice->write(msg.toUtf8());

        return false;

    }

    if (!m_root)

        m_root = new RCCFileInfo(QString(), QFileInfo(), QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);

    RCCFileInfo *parent = m_root;

    const QStringList nodes = alias.split(QLatin1Char('/'));

    for (int i = 1; i < nodes.size()-1; ++i) {

        const QString node = nodes.at(i);

        if (node.isEmpty())

            continue;

        if (!parent->m_children.contains(node)) {

            RCCFileInfo *s = new RCCFileInfo(node, QFileInfo(), QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);

            s->m_parent = parent;

            parent->m_children.insert(node, s);

            parent = s;

        } else {

            parent = parent->m_children[node];

        }

    }