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

**

** 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 HbServers 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 "hbthemeserverutils_p.h"

#include <QHash>

#include <QString>

#include <QStringList>

#include <QFile>

#include <QDebug>

#include "hbmemoryutils_p.h"

#include "hbcssparser_p.h"

#include "hbeffectfxmldata_p.h"

#include "hbeffectxmlparser_p.h"

#include "hbdeviceprofiledatabase_p.h"

#include "hbthemeperf_p.h"

#include "hbiconsource_p.h"

#include "hbwidgetloader_p.h"

#include "hbwidgetloaderactions_p.h"

#include "hbthemeindex_p.h"

//Hash of fileName-offset

typedef QHash<QString, int> HbServerCache;

Q_GLOBAL_STATIC(HbServerCache, effCache)

// cache at the server side to maintain the offsets for

// the filename,layout and section combination.

typedef QHash<QString, int> ServerHashForLayoutDefs;

Q_GLOBAL_STATIC(ServerHashForLayoutDefs, layoutDefsCache)

// Offset for the cache of the missed CSS files for classes starting 'hb'

static int missedHbCssFilesOffset = -1;

static const QString HB_CLASSNAME_PREFIX("hb");

static const int ICON_SOURCES_MAX_SIZE = 8;

static QList<HbIconSource *> iconSources; // cache of recently used icon sources

HbIconSource *HbThemeServerUtils::getIconSource(const QString &filename)

{

    foreach(HbIconSource *source, iconSources) {

        if (source->filename() == filename) {

            return source;

        }

    }

    // Add new icon source last in the list, delete the first entry if the max size is exceeded.

    QScopedPointer<HbIconSource> tempHbIconSource(new HbIconSource(filename));

    HbIconSource *newSource = tempHbIconSource.data();

    if (iconSources.count() >= ICON_SOURCES_MAX_SIZE) {

        delete iconSources.takeFirst();

    }

    iconSources.append(newSource);

    tempHbIconSource.take();

    return newSource;

}

/**

 * formatFromPath

 */

QString HbThemeServerUtils::formatFromPath(const QString &iconPath)

{

    QString suffix = QFileInfo(iconPath).suffix().toUpper();

    if (suffix == "SVGZ") {

        return "SVG";

    }

    if (suffix == "QPIC") {

        return "PIC";

    }

    if (suffix == "XML" || suffix == "AXML" || suffix == "FXML") {

        return "BLOB";

    }

    return suffix;

}

/**

 * HbThemeServerUtils::getSharedStylesheet() parses the requested stylesheet

 * in shared memory and returns its offset. The offset could be -1 in case of

 * OOM condition or any error while parsing the css file.

 *

 * \param fileName required stylesheet (complete file path)

 * \param priority layer priority

 * \return offset of the shared style sheet in the shared memory, -1 if error

 *

 */

int HbThemeServerUtils::getSharedStylesheet(const QString &fileName,

                                            HbLayeredStyleLoader::LayerPriority priority,

                                            bool &fileExists,

                                            bool *inSharedCache)

{

    qptrdiff cssOffset = -1;

    HbSharedCache *sharedCache = 0;

    if (priority == HbLayeredStyleLoader::Priority_Core) {

        sharedCache = HbSharedCache::instance();

        cssOffset = sharedCache->offset(HbSharedCache::Stylesheet, fileName);

        if (inSharedCache) {

            *inSharedCache = (cssOffset >= 0) ? true : false;

        }

    } else if (inSharedCache) {

        *inSharedCache = false;

    }

    if (cssOffset < 0) {

        HbCss::Parser parser;

        if (!parseCssFile(parser, fileName, cssOffset, fileExists)) {

            if (parser.errorCode == HbCss::Parser::OutOfMemoryError) {

                return OUT_OF_MEMORY_ERROR;

            }

        }

        if (sharedCache) { //sharedCache valid only when priority is Priority_Core

            sharedCache->add(HbSharedCache::Stylesheet, fileName, cssOffset);

        }

    }

    return cssOffset;

}

/*

 * Returns the offset of the missed CSS files for widgets starting with 'hb'

 */

int HbThemeServerUtils::getMissedHbCssFilesOffset()

{

    if (missedHbCssFilesOffset < 0) {

        initMissedHbCssFilesList();

    }

    return missedHbCssFilesOffset;

}

void HbThemeServerUtils::initMissedHbCssFilesList()

{

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    int offset = -1;

    try {

        offset = manager->alloc(sizeof(HbVector<uint>));

        HbVector<uint> *list = new((char*)manager->base() + offset)

                HbVector<uint>(HbMemoryManager::SharedMemory);

    } catch (std::bad_alloc &) {

        if (offset >= 0) {

            manager->free(offset);

            offset = -1;

        }

    }

    missedHbCssFilesOffset = offset;

}

/**

 * HbThemeServerUtils::parseCssFile()

 *

 * Returns false in case Css file has some error or there is not enough memory

 */

bool HbThemeServerUtils::parseCssFile(HbCss::Parser &parser, const QString &fileName,

                                      qptrdiff &cssOffset, bool &fileExists)

{

    bool retVal = false;

    // 1. Create a styleSheet in shared memory

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory) ;

    HB_START_SHAREDMEMORY_PRINT("");

    HB_START_HEAPMEMORY_PRINT("");

    HbCss::StyleSheet *styleSheet = 0;

    try {

        cssOffset = manager->alloc(sizeof(HbCss::StyleSheet));

        styleSheet = new(static_cast<char *>(manager->base()) + cssOffset)

                     HbCss::StyleSheet(HbMemoryManager::SharedMemory);

    } catch (std::bad_alloc &) {

        if (cssOffset != -1) {

            // if manager->alloc in the previous try block suceeds but creation of

            // HbCss::StyleSheet on shared memory failed

            manager->free(cssOffset);

            cssOffset = -1;

        }

        return retVal;

    }

    // 2. Parse the required file into styleSheet.

    fileExists = parser.init(fileName, true);

    if (!fileExists) {

        if (QFileInfo(fileName).fileName().startsWith(HB_CLASSNAME_PREFIX)) {

            HbVector<uint> *list = HbMemoryUtils::getAddress<HbVector<uint> >(

                HbMemoryManager::SharedMemory, getMissedHbCssFilesOffset());

            if (list) {

                list->append(qHash(fileName));

            }

        }

        if (cssOffset != -1) {

            manager->free(cssOffset);

            cssOffset = -1;

        }

        return retVal;

    }

    retVal = parser.parse(styleSheet);

    if (!retVal) {

        //parser::parse returns false in a number of scenarios

        // 1. css file has some error

        // 2. shared memory operations on HbVector/HbString/HbVariant threw an exception

        // in either case free the memory occupied by stylesheet

        HbMemoryUtils::release<HbCss::StyleSheet>(styleSheet);

        cssOffset = -1;

    }

    HB_END_SHAREDMEMORY_PRINT("");

    HB_END_HEAPMEMORY_PRINT("");

    return retVal;

}

/*

  Returns of the offset for the given filename,layout and section name.

 */

int HbThemeServerUtils::getSharedLayoutDefinition(const QString &fileName, const QString &layout,

                                                  const QString &section, bool &fileExists)

{

    qptrdiff layoutDefOffset = -1;

    QStringRef nameKey(&fileName);

    if (nameKey.at(0) == ':') {

        //use only filename as a key.

        int index = fileName.lastIndexOf('/');

        if (index >= 0) {

            nameKey = fileName.rightRef((fileName.size() - 1) - index);

        }

    }

    // check in the cache.

    QString key;

    QChar separator('\0');

    key.reserve(nameKey.length() + 2 //separators

                + layout.length() + section.length());

    key.append(nameKey)

       .append(separator)

       .append(layout)

       .append(separator)

       .append(section);

    if (layoutDefsCache()->contains(key)) {

        layoutDefOffset = layoutDefsCache()->value(key);

        return layoutDefOffset;

    }

    HbWidgetLoader loader;

    QFile file(fileName);

    fileExists = file.open(QFile::ReadOnly | QFile::Text);

    if (!fileExists) {

        return -1;

    }

    HbWidgetLoader::LayoutDefinition *layoutDef(0);

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    try {

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

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

            HbWidgetLoader::LayoutDefinition(HbMemoryManager::SharedMemory);

    } catch (std::bad_alloc &badAlloc) {

        Q_UNUSED(badAlloc)

        if (layoutDefOffset != -1) {

            manager->free(layoutDefOffset);

            layoutDefOffset = -1;

        }

        return layoutDefOffset;

    }

    if (loader.loadLayoutDefinition(layoutDef, &file, layout, section)) {

        layoutDefsCache()->insert(key, layoutDefOffset);

        // add the filename and css offset to the shared cache.

        // no need to check if this item is already present in the

        // cache as the parsing of the file happens only once

        // in the server side.

        HbSharedCache::instance()->addLayoutDefinition(fileName, layout, section,

                                                       layoutDefOffset);

    } else {

        // load failed

        layoutDef->~LayoutDefinition();

        manager->free(layoutDefOffset);

        layoutDefOffset = -1;

    }

    return layoutDefOffset;

}

/**

 * Creates the singleton HbDeviceProfileDatabase instance in shared memory

 *

 */

void HbThemeServerUtils::createDeviceProfileDatabase()

{

    HbDeviceProfileDatabase::instance(HbMemoryManager::SharedMemory);

}

/**

 * Removes fxml document from the shared memory and effects cache

 *

 * \param fileName of the removed fxml file

 * \return true if effect was found and removed, false otherwise

 */

bool HbThemeServerUtils::removeSharedEffect(const QString &fileName)

{

    if (effCache()->contains(fileName)) {

        effCache()->remove(fileName);

        HbSharedCache::instance()->remove(HbSharedCache::Effect, fileName);

        return true;

    }

    return false;

}

/**

 * Clears fxml documents from the shared memory and effects cache

 *

 */

void HbThemeServerUtils::clearSharedEffects()

{

    HbSharedCache *cache = HbSharedCache::instance();

    HbServerCache::const_iterator iterEnd(effCache()->constEnd());

    for (HbServerCache::const_iterator iter = effCache()->constBegin();iter != iterEnd;++iter) {

        cache->remove(HbSharedCache::Effect, iter.key());

    }

    effCache()->clear();

}

/**

 * getSharedEffect parses the requested fxml document into the shared

 * memory and returns the offset of the parsed data.

 *

 * \param fileName requested fxml file

 * \return offset of the parsed effect data in the shared memory, -1 if error

 *

 */

int HbThemeServerUtils::getSharedEffect(const QString &fileName)

{

    qptrdiff effOffset = -1;

    if (effCache()->contains(fileName)) {

        effOffset = effCache()->value(fileName);

    } else {

        // 1. Create an effect in shared memory

        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

        HbEffectFxmlData *data = 0;

        try {

            effOffset = manager->alloc(sizeof(HbEffectFxmlData));

            data = new(static_cast<char*>(manager->base()) + effOffset)

                   HbEffectFxmlData(HbMemoryManager::SharedMemory);

        } catch (std::exception &) {

            if (effOffset != -1) {

                // if manager->alloc in the previous try block suceeds but creation of

                // HbEffectFxmlData on shared memory failed

                manager->free(effOffset);

                effOffset = -1;

            }

            return effOffset;

        }

        // 2. Parse the file.

        HbEffectXmlParser parser;

        QFile f(fileName);

        bool fail = false;

        if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {

            try {

                parser.read(&f, data);

                f.close();

                // 3. Mark an entry for this styleSheet into the table

                effCache()->insert(fileName, effOffset);

            } catch (std::exception &) {

                f.close();

                fail = true;

            }

        } else {

            fail = true;

        }

        if (fail) {

            data->~HbEffectFxmlData();

            manager->free(effOffset);

            return -1;

        }

        // add the filename and css offset to the secondary cache.

        // no need to check if this item is already present in the

        // cache as the parsing of the file happens only once

        // in the server side.

        HbSharedCache::instance()->add(HbSharedCache::Effect, fileName, effOffset);

    }

    return effOffset;

}

void HbThemeServerUtils::createThemeIndex(const QString &themePath, const HbThemeType &themetype)

{

    QDir themeBasePath(themePath);

    // Path is like "C:/resource/hb/themes/icons/sfwhitetheme"

    QString themeName = themeBasePath.dirName();

    QString filename(themeBasePath.absolutePath());

    filename = filename.left(cutindex);

    themeBasePath.setPath(filename);

    filename.append(themeName);

    filename.append(".themeindex");

    if (themePath == ":\\themes\\icons\\hbdefault") {

        themeBasePath.setPath(":/themes");

        filename = ":/themes/hbdefault.themeindex";

        themeName = "hbdefault";

    }

    QFile indexFile(filename);

    bool indexOK = false;

    if (indexFile.open(QIODevice::ReadOnly)) {

        indexOK = true;

        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

        qint64 byteSize = indexFile.size();

        int offset = manager->alloc(byteSize);

        if (offset >= 0) {

            // Read the theme index in the shared chunk

            char *address = HbMemoryUtils::getAddress<char>(HbMemoryManager::SharedMemory, offset);

            indexFile.read(address, byteSize);

            indexFile.close();

            // Verify theme index contents if it is not located in ROM,

            // so that it does not have over-indexing offsets which might

            // crash all the clients trying to read from it.

            if (themePath[0] != 'z' && themePath[0] != 'Z') {

                HbThemeIndex index(address);

                indexOK = index.validateItems(byteSize);

            }

            if (indexOK) {

                // Allocate theme path string from shared memory

                QByteArray themePathArray = themeBasePath.absolutePath().toLatin1();

                quint32 themePathOffset = manager->alloc(themePathArray.size()+1);

                memcpy(HbMemoryUtils::getAddress<char>(

                           HbMemoryManager::SharedMemory,

                           themePathOffset),

                           themePathArray.data(),

                           themePathArray.size()+1); // +1 for '/0'

                // Allocate theme name string from shared memory

                QByteArray themeNameArray = themeName.toLatin1();

                quint32 themeNameOffset = manager->alloc(themeNameArray.size()+1);

                memcpy(HbMemoryUtils::getAddress<char>(

                           HbMemoryManager::SharedMemory,

                           themeNameOffset),

                           themeNameArray.data(),

                           themeNameArray.size()+1); // +1 for '/0'

                // Store offset to the index in chunk

                switch (themetype) {

                case BaseTheme:

                    // Release previously allocated content

                    manager->free(chunkHeader->baseThemePathOffset);

                    manager->free(chunkHeader->baseThemeNameOffset);

                    manager->free(chunkHeader->baseThemeIndexOffset);

                    // Base theme offsets

                    chunkHeader->baseThemePathOffset = themePathOffset;

                    chunkHeader->baseThemeNameOffset = themeNameOffset;

                    chunkHeader->baseThemeIndexOffset = offset;

                    break;

                case OperatorC:

                    // Release previously allocated content

                    manager->free(chunkHeader->operatorThemeDriveCPathOffset);