/****************************************************************************
**
** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (developer.feedback@nokia.com)
**
** This file is part of the HbTools module of the UI Extensions for Mobile.
**
** GNU Lesser General Public License Usage
** 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 developer.feedback@nokia.com.
**
****************************************************************************/
#include <QCoreApplication>
#include <QFile>
#include <QDir>
#include <QDataStream>

#include <hbmemoryutils_p.h>
#include <hbcssparser_p.h>
#include <hbsharedmemorymanager_p.h>
#include <hbsharedcache_p.h>
#include <hbcssconverterutils_p.h>

// Global variables
QString AppName("hbbincssmaker");
static bool verboseOn = false;
QTextStream out(stdout);
QTextStream verboseOut(stderr);
QTextStream err(stderr);

#define VERBOSE(statement) if(verboseOn) { verboseOut << statement; }
#define VERBOSEIF(test, statement) if(verboseOn && test) { verboseOut << statement; }
#define VERBOSELN(statement) if(verboseOn) { verboseOut << statement << endl; }


void testDeclarations(const HbVector<HbCss::Declaration> &decls)
{
    VERBOSE("declarations count: ");
    VERBOSELN(decls.count());
    foreach(const HbCss::Declaration &decl, decls) {
        QString prop = decl.property;
        VERBOSELN(prop);
        VERBOSE("declarations values: ");
        VERBOSELN(decl.values.count());
        foreach(const HbCss::Value &value, decl.values) {
            QString declVal = value.variant.toString();
            VERBOSELN(declVal);
        }
    }
}

void testStyleRules(const HbVector<HbCss::StyleRule> &styleRules)
{
    foreach(const HbCss::StyleRule &rule,styleRules) {
        int sels = rule.selectors.count();
        VERBOSE("rule selectors count: ");
        VERBOSELN(sels);
        foreach(const HbCss::Selector &sel, rule.selectors) {
            int basicSel = sel.basicSelectors.count();
            VERBOSE("Basic Selectors: ");
            VERBOSELN(basicSel);
            foreach(const HbCss::BasicSelector &bSel, sel.basicSelectors) {
                QString name = bSel.elementName;
                VERBOSELN(name);
                int pseudos = bSel.pseudos.count();
                VERBOSE("Basic Selectors pseudos: ");
                VERBOSELN(pseudos);
                foreach(const HbCss::Pseudo &pseudo, bSel.pseudos) {
                    quint64 pseudoType = (quint64)pseudo.type; Q_UNUSED(pseudoType);
                    QString name = pseudo.name;
                    QString function = pseudo.function;
                    VERBOSE(name);
                    VERBOSELN(function);
                }
                int selectors = bSel.attributeSelectors.count();
                VERBOSE("Basic Selectors attribute selectors: ");
                VERBOSELN(selectors);
                foreach(const HbCss::AttributeSelector &aSel, bSel.attributeSelectors) {
                    QString sel = aSel.name;
                    VERBOSELN(sel);
                }
            }
        }
        testDeclarations(rule.declarations);
    }
}

void testStyleSheet(HbCss::StyleSheet *styleSheet)
{
    int ruleCount = styleSheet->variableRules.count();
    VERBOSE("rules count: ");
    VERBOSELN(ruleCount);
    foreach(const HbCss::VariableRule &rule, styleSheet->variableRules) {
        testDeclarations(rule.declarations);
    }
    int widgetRules = styleSheet->widgetRules.count();
    VERBOSE("widget rules count: ");
    VERBOSELN(widgetRules);
    foreach(const HbCss::WidgetStyleRules &rule, styleSheet->widgetRules) {
        testStyleRules(rule.styleRules);
        testStyleRules(rule.portraitRules);
        testStyleRules(rule.landscapeRules);
    }
}

class CssMap
{
public:
    CssMap() {}
    void add(const QString &cssName, unsigned int offset)
    {
        HbOffsetItem mapItem = _mapItems.value(cssName, HbOffsetItem());
        if (mapItem.nameOffset < 0) {
            mapItem.nameOffset = _cssNameBuffer.size();
            mapItem.offset = offset;
            _cssNameBuffer.append(cssName.toLatin1()).append('\0');
            _mapItems.insert(cssName, mapItem);
        } else {
            err << "warning: duplicate cache key for " << cssName << endl;
        }
    }

    void registerOffsetHolders() {
        foreach(const HbOffsetItem &mapItem, _mapItems) {
            HbCssConverterUtils::registerOffsetHolder(const_cast<int *>(&mapItem.offset));
        }
    }

    QByteArray data() const {
        QByteArray dataArray;
        int count = _mapItems.size();
        int adjustment = count * sizeof(HbOffsetItem);
        foreach(const HbOffsetItem &mapItem, _mapItems) {
            HbOffsetItem tmp(mapItem);
            // Fix offsets in the items to be based on the beginning of the css map instead of
            // the beginning of the css name buffer.
            tmp.nameOffset += adjustment;
            dataArray.append(reinterpret_cast<const char*>(&tmp), sizeof(HbOffsetItem));
        }
        dataArray.append(_cssNameBuffer);
        return dataArray;
    }
    int size() const { return _mapItems.count(); }

private:
    QMap<QString, HbOffsetItem> _mapItems;
    QByteArray _cssNameBuffer;
};

struct InputFile
{
    InputFile(const QString &cacheName, const QFileInfo &file) : cacheName(cacheName), file(file)
    {
    }

    QString cacheName;
    QFileInfo file;
};
typedef QList<InputFile> InputFileList;

struct InputFileInfo
{
    QString base;
    QString path;
    QString prefix;
};
typedef QList<InputFileInfo> InputFileInfoList;

bool operator < (const InputFile & if1, const InputFile & if2)
{
    return if1.file.size() > if2.file.size();
}

void printHelp()
{
    out << AppName << " usage:\n\n";
    out << AppName << " [-v] -i <css filename or directory> -o <target binary file>";
    out << "-v \t\tverbose output\n\n";
}

QFileInfoList collectFiles(const QFileInfoList &inputFiles, const QStringList &filters)
{
    QFileInfoList collected;
    Q_FOREACH(const QFileInfo &inputFile, inputFiles) {
        if (inputFile.isDir()) {
            QDir dir(inputFile.absoluteFilePath());
            QFileInfoList entries = dir.entryInfoList(filters,
                    QDir::AllDirs | QDir::Readable | QDir::Files | QDir::NoDotAndDotDot);
            collected += collectFiles(entries, filters);
        } else {
            collected << inputFile;
        }
    }
    return collected;
}

InputFileList collectCssFiles(const QStringList &inputFilePaths)
{
    QStringList filters;
    filters << "*.css";

    InputFileList inputFiles;
    QFileInfoList inputPath;
    inputPath.append(QFileInfo());
    Q_FOREACH(const QString &path, inputFilePaths) {
        inputPath[0].setFile(path);
        QFileInfoList allFiles = collectFiles(inputPath, filters);
        Q_FOREACH(const QFileInfo &info, allFiles) {
            inputFiles.append(InputFile(info.fileName(), info));
        }
    }
    return inputFiles;
}

bool writeCssBinary(const QStringList &inputFiles, const QString &targetFile)
{
    if (inputFiles.isEmpty()) return false;
    InputFileList cssFiles = collectCssFiles(inputFiles);
    if (cssFiles.isEmpty()) return false;
    qSort(cssFiles);

    HbCss::Parser parser;
    HbCss::StyleSheet *styleSheet = 0;
    bool success = false;
    CssMap cssMap;
    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
    Q_FOREACH(const InputFile &inputFile, cssFiles) {
        const QFileInfo &file = inputFile.file;
        VERBOSE("processing " << file.absoluteFilePath() << "...");
        success = false;
        int offset = manager->alloc(sizeof(HbCss::StyleSheet));
        if (offset >= 0) {
            styleSheet = new (static_cast<char*>(manager->base()) + offset)
                         HbCss::StyleSheet(HbMemoryManager::SharedMemory);
            parser.init(file.absoluteFilePath(), true);
            success = parser.parse(styleSheet);
            cssMap.add(inputFile.cacheName, offset);
            VERBOSE("cache key = " << inputFile.cacheName << "...");
        }
        if (success) {
            VERBOSELN("ok");
        } else {
            VERBOSELN("failed");
            err << "Failed to parse: " << file.absoluteFilePath() << endl;
            break;
        }
    }
    if (success) {
        HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);

        // Create shared cache to shared memory.
        QByteArray data(cssMap.data());

        if (shared->createSharedCache(data.data(), data.size(), cssMap.size())) {

            // Defragment the chunk contents before dumping it in a file
            int endOffset = HbCssConverterUtils::defragmentChunk();

            if (verboseOn) {
                HbSharedCache *cache = shared->cache();
        
                for (int k=0; k<cache->mOffsetItemCount; ++k) {
                    HbCss::StyleSheet *sheet = HbMemoryUtils::getAddress<HbCss::StyleSheet>(
                        HbMemoryManager::SharedMemory, cache->mOffsetItems[k].offset);
                
                    QString name(QLatin1String( ((char*)(cache->mOffsetItems)) + cache->mOffsetItems[k].nameOffset));

                    VERBOSE("Cssmap item ");
                    VERBOSE(k);
                    VERBOSE("- name: \"");
                    VERBOSE(name);
                    VERBOSELN("\"");

                    // Tests the stylesheet offsets and prints info to verbose out
                    testStyleSheet(sheet);
                }
            }

            VERBOSELN("writing the binary file");
            QFile binFile(targetFile);
            if (!binFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                err << "failed to open target binary file: " << binFile.fileName() << endl;
                return false;
            }
            //int size = shared->size();
            if (binFile.write(static_cast<char*>(manager->base()), endOffset) >= 0) {
                VERBOSELN("Wrote target binary file: " << binFile.fileName());
            } else {
                err << "failed to write to target binary file: " << binFile.fileName() << endl;
            }
        } else {
            err << "failed to create shared cache." << endl;
        }
    }
    return success;
}

int main(int argc, char **argv)
{
    QCoreApplication app(argc, argv);

    if(argc < 3) {
        printHelp();
    } else {
        QStringList inputFiles;
        QString targetFile;
        QStringList args(app.arguments());

        for(int count(0) ; count < args.count(); count++) {
            if (args[count].toLower() == "-i") {
                QString filePath = args.value(count + 1);
                if (!filePath.isEmpty()) {
                    inputFiles.append(QDir::fromNativeSeparators(filePath));
                }
                count++;
            } else if (args[count].toLower() == "-o") {
                targetFile = QDir::fromNativeSeparators(args.value(count+1));
                count++;
            } else if (args[count].toLower() == "-v") {
                verboseOn = true;
            }
        }
        if (targetFile.isEmpty()) {
            err << "target filename needed" << endl << endl;
            printHelp();
        } else {
            QString parentDir(QFileInfo(targetFile).absolutePath());
            if (QDir::current().mkpath(parentDir)) {
                writeCssBinary(inputFiles, targetFile);
            } else {
                err << "failed to create path: " << parentDir << endl;
            }
        }
    }
    return 0;
}