#include <hboffsetmapbuilder_p.h>

#include <hbwidgetloader_p.h>

static const QString CSSFileExtension = ".css";

static const QString WMLFileExtension = ".widgetml";

static const QString ColorCSSEnding = "_color.css";

static const QString AppName = "hbbincssmaker";

struct WidgetMLParseInput

{

    QString filename;

    QList<CSSLayoutInfo> layouts;

    void clear()

    {

        layouts.clear();

        filename.clear();

    }

};

void testLayoutDef(const HbWidgetLoader::LayoutDefinition *layoutDef)

{

    VERBOSELN("mesh items count: " << layoutDef->meshItems.count());

    for (int i = 0; i < layoutDef->meshItems.count(); ++i) {

        const HbWidgetLoader::MeshItem &meshItem = layoutDef->meshItems.at(i);

        VERBOSELN("src: " << meshItem.src);

        VERBOSELN("dst: " << meshItem.dst);

        VERBOSELN("spacing text: " << meshItem.spacingText);

        VERBOSELN("spacer: " << meshItem.spacer);

    }

}

bool testCss()

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);

    HbSharedCache *cache = shared->cache();

    for (int k = 0; k < cache->mOffsetItemCount; ++k) {

        if (cache->mOffsetItems[k].offsetCSS >= 0) {

            HbCss::StyleSheet *sheet = HbMemoryUtils::getAddress<HbCss::StyleSheet>(

                HbMemoryManager::SharedMemory, cache->mOffsetItems[k].offsetCSS);

            VERBOSELN("Cssmap item " << k

                    << "- hash value: \"" << cache->mOffsetItems[k].offsetCSS << "\"");

            // Tests the stylesheet offsets and prints info to verbose out

            testStyleSheet(sheet);

            //test layout definition.

            int tableSize = 0;

            const HbLayoutIndexItem *ptr = cache->layoutIndexItemBegin(

                    cache->mOffsetItems[k].offsetLayoutIndexTable, &tableSize);

            for (; tableSize > 0; --tableSize, ++ptr) {

                HbWidgetLoader::LayoutDefinition *layoutDef =

                    HbMemoryUtils::getAddress<HbWidgetLoader::LayoutDefinition>(

                            HbMemoryManager::SharedMemory, ptr->offset);

                testLayoutDef(layoutDef);

            }

    return true;

}

/*!

    Collects and return layout names from \a styleRules.

    \a layoutSet - map of already found layoutnames and sections to prevent duplicate layouts

    to be added.

*/

QList<CSSLayoutInfo> collectLayoutNames(

        QSet<QPair<QString, QString> > &layoutSet,

        const HbVector<HbCss::StyleRule> &styleRules)

{

    QList<CSSLayoutInfo> layouts;

    layouts.append(CSSLayoutInfo());

    foreach(const HbCss::StyleRule &rule, styleRules) {

        foreach(const HbCss::Declaration &decl, rule.declarations) {

            if (decl.propertyId == HbCss::Property_Layout) {

                if (decl.values.count() == 1) {

                    layouts.last().layoutname = decl.values.at(0).variant.toString();

                }

            } else if (decl.propertyId == HbCss::Property_Section) {

                if (decl.values.count() == 1) {

                    layouts.last().section = decl.values.at(0).variant.toString();

                }

            }

        }

        const CSSLayoutInfo &infoRef = layouts.last();

        if (!infoRef.layoutname.isEmpty()) {

            QPair<QString, QString> layout = qMakePair(infoRef.layoutname,

                                                       infoRef.section);

            //only add layout, if not already collected before.

            if (!layoutSet.contains(layout)) {

                layoutSet.insert(layout);

                layouts.append(CSSLayoutInfo());

            }

        }

    layouts.removeLast();

    return layouts;

}

/*!

    Collects all the layouts defined in \a stylesheet and add the result to \a input.

    returns true, if at least one layout is found.

*/

bool collectLayouts(const QString &cssFilePath,

                    HbCss::StyleSheet *styleSheet,

                    WidgetMLParseInput &input)

    input.clear();

    QSet<QPair<QString, QString> > layoutSet; //for removing duplicate layout names.

    foreach(const HbCss::WidgetStyleRules &rule, styleSheet->widgetRules) {

        layoutSet.clear();

        input.layouts += collectLayoutNames(layoutSet, rule.styleRules);

        input.layouts += collectLayoutNames(layoutSet, rule.portraitRules);

        input.layouts += collectLayoutNames(layoutSet, rule.landscapeRules);

    }

    bool hasLayoutDef = false;

    if (!input.layouts.isEmpty()) {

        //if css contains at least 1 layout declaration, it might have .widgetml file.

        QString filePath(cssFilePath);

        filePath.replace(filePath.size() - CSSFileExtension.size(),

                         CSSFileExtension.size(), WMLFileExtension);

        input.filename = filePath;

        hasLayoutDef = true;

    }

    return hasLayoutDef;

QMap<QString, QFileInfo> collectCssFiles(const QStringList &inputFilePaths)

    QMap<QString, QFileInfo> cssFileMap;

            QMap<QString, QFileInfo>::const_iterator i = cssFileMap.find(info.fileName());

            if (i == cssFileMap.end()) {

                cssFileMap.insert(info.fileName(), info);

            } else {

                err << "duplicate css filenames found: " << i.value().absoluteFilePath() <<

                       " & " << info.absoluteFilePath();

            }

    return cssFileMap;

/*!

    Collects the css files from \a inputFiles, parses them to shared memory, stores

    offsets to \a offsetMap.

    returns true on success.

*/

bool parseCss(const QStringList &inputFiles, HbOffsetMapBuilder &offsetMap)

    QMap<QString, QFileInfo> cssFiles = collectCssFiles(inputFiles);

    while (!cssFiles.isEmpty()) {

        QMap<QString, QFileInfo>::iterator first = cssFiles.begin();

        QMap<QString, QFileInfo>::iterator CSSFiles[CSSFileTypeEnd];

        QString widgetName(first.key());

        if (widgetName.endsWith(ColorCSSEnding)) {

            //color css file, find the layout css pair.

            CSSFiles[ColorCSSFile] = first;

            widgetName.remove(widgetName.size() - ColorCSSEnding.size(),

                              ColorCSSEnding.size());

            CSSFiles[CSSFile] = cssFiles.find(widgetName + CSSFileExtension);

        } else {

            //layout css file, find the color css pair.

            CSSFiles[CSSFile] = first;

            widgetName.remove(widgetName.size() - CSSFileExtension.size(),

                              CSSFileExtension.size());

            CSSFiles[ColorCSSFile] = cssFiles.find(widgetName + ColorCSSEnding);

        }

        int offsets[] = {-1, -1};

        for (int i = 0; i < CSSFileTypeEnd; ++i) {

            if (CSSFiles[i] != cssFiles.end()) {

                const QFileInfo &file = CSSFiles[i].value();

                VERBOSE("processing " << file.absoluteFilePath() << "...");

                offsets[i] = manager->alloc(sizeof(HbCss::StyleSheet));

                if (offsets[i] >= 0) {

                    styleSheet = new (static_cast<char*>(manager->base()) + offsets[i])

                                 HbCss::StyleSheet(HbMemoryManager::SharedMemory);

                    parser.init(file.absoluteFilePath(), true);

                    success = parser.parse(styleSheet);

                    VERBOSE("cache key = " << CSSFiles[i].key() << "...");

                }

                if (success) {

                    VERBOSELN("ok");

                } else {

                    VERBOSELN("failed");

                    err << "Failed to parse: " << file.absoluteFilePath() << endl;

                    break;

                }

            }

        const QFileInfo *info = 0;

        QString tmp;

        if (CSSFiles[CSSFile] != cssFiles.end()) {

            tmp = CSSFiles[CSSFile].key();

            info = &CSSFiles[CSSFile].value();

        }

        if (!offsetMap.addWidgetOffsets(widgetName, info, offsets)) {

            return false;

        }

        //remove processed files from the map.

        cssFiles.erase(CSSFiles[ColorCSSFile]);

        if (!tmp.isEmpty()) {

            cssFiles.remove(tmp);

        }

    }

    return success;

}

/*!

    Parses widgetml file and all the layouts using the info from \a parseInput for a widget,

    which hash is \a widgetHash, add offsets to \a offsetMap.

*/

bool parseWidgetML(HbOffsetMapBuilder &offsetMap,

                   quint32 widgetHash,

                   const WidgetMLParseInput &parseInput)

{

    HbWidgetLoader loader;

    VERBOSELN("processing: " << parseInput.filename);

    QFile file(parseInput.filename);

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

        VERBOSELN("unable to open file: " << parseInput.filename);

        return false;

    }

    HbWidgetLoader::LayoutDefinition *layoutDef = 0;

    int layoutDefOffset = -1;

    bool success = true;

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    QList<LayoutItem> layoutInfoList;

    Q_FOREACH(const CSSLayoutInfo &info, parseInput.layouts) {

        VERBOSE("layout: " << info.layoutname << ", " << "section: " << info.section << "...");

        layoutDefOffset = manager->alloc(sizeof(HbWidgetLoader::LayoutDefinition));

        layoutDef = new(static_cast<char *>(manager->base()) + layoutDefOffset)

            HbWidgetLoader::LayoutDefinition(HbMemoryManager::SharedMemory);

        success = loader.loadLayoutDefinition(layoutDef, &file, info.layoutname, info.section);

            layoutInfoList.append(LayoutItem(&info));

            layoutInfoList.last().offset = layoutDefOffset;

        file.seek(0);

    }

    success = offsetMap.addWidgetMLOffsets(parseInput.filename, widgetHash, layoutInfoList);

    return success;

}

/*!

    Parse all the widgetmls to shared memory for widget's found in \a offsetMap,

    store the offsets to \a offsetMap.

*/

bool parseWidgetML(HbOffsetMapBuilder &offsetMap)

{

    QList<HbBinMakerOffsetItem> itemList = offsetMap.items();

    Q_FOREACH(const HbBinMakerOffsetItem &item, itemList) {

        if (item.offsetCSS >= 0) {

            HbCss::StyleSheet *sheet = HbMemoryUtils::getAddress<HbCss::StyleSheet>(

                HbMemoryManager::SharedMemory, item.offsetCSS);

            WidgetMLParseInput file;

            if (collectLayouts(item.name, sheet, file)) {

                parseWidgetML(offsetMap, item.widgetHash, file);

            }

        }

    return true;

}

bool writeCssBinary(const QStringList &inputFiles, const QString &targetFile)

{

    HbOffsetMapBuilder offsetMap;

    if (!(parseCss(inputFiles, offsetMap)

        && parseWidgetML(offsetMap))) {

        return false;

    }

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);

    // Create shared cache to shared memory.

    QByteArray data(offsetMap.result());

    bool success = false;

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

        // Defragment the chunk contents before dumping it in a file

        int endOffset = HbCssConverterUtils::defragmentChunk();

        if (verboseOn) testCss();

        VERBOSELN("writing the binary file");

        QFile binFile(targetFile);

        success = binFile.open(QIODevice::WriteOnly | QIODevice::Truncate);

        if (success) {

            success = (binFile.write(static_cast<char*>(manager->base()), endOffset) >= 0);

            if (success) {

            err << "failed to open target binary file: " << binFile.fileName() << endl;

    } else {

        err << "failed to create shared cache." << endl;

    int returnValue = 0;

            returnValue = 1;

                if (!writeCssBinary(inputFiles, targetFile)) {

                    returnValue = 3;

                }