/****************************************************************************
**
** 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 <QMap>
#include "hbcssconverterutils_p.h"
#include "hbsharedmemorymanager_p.h"
#include "hbsharedmemoryallocators_p.h"

// Global list that stores pointers to the member variables where shared container instances
// store offsets returned my memory allocator.
// CSS converter utilizes it to automatically adjust the offsets if allocated cells are moved.

// Map is used only to get faster lookups, item's value is obsolete
static QMap<int *, int> registered;


// Shared chunk allocation information for css data
static int totalAllocated = 0;
// Using map instead of hash to guarantee that the items are in order
// so the cell with offset 0 which is the HbCss::StyleSheet structure
// is always first in the cell list, so its offset does not get changed
// when the chunk is defragmented.
static QMap<int, int> cells;


void HbCssConverterUtils::registerOffsetHolder(int *offset)
{
    registered.insert(offset, 1);
}

void HbCssConverterUtils::unregisterOffsetHolder(int *offset)
{
    registered.remove(offset);
}

QMultiHash<int, int *> HbCssConverterUtils::registeredOffsetHolders()
{
    QMultiHash<int, int *> holders;
    holders.reserve(registered.size());
    QMap<int *, int>::const_iterator end = registered.constEnd();
    for (QMap<int *, int>::const_iterator i = registered.constBegin(); i != end; ++i) {
        int *holder = i.key();
        holders.insertMulti(*holder, holder);
    }
    return holders;
}

void HbCssConverterUtils::unregisterAll()
{
    registered.clear();
}


void HbCssConverterUtils::cellAllocated(int offset, int size)
{
    cells.insert(offset, ALIGN(size));
    totalAllocated += ALIGN(size);
}

void HbCssConverterUtils::cellFreed(int offset)
{
    int size = cells.value(offset, 0);
    totalAllocated -= size;
    cells.remove(offset);

    if (size > 0) {
        // Make sure there are no registered offset holders in the freed cell any more
        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
        HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);
        const char *chunkBase = static_cast<const char *>(shared->base());
        const char *freedEnd = chunkBase + offset + size;
        const int *freedStart = reinterpret_cast<const int *>(chunkBase + offset);

        QMap<int *, int>::iterator freedHolders =
                registered.lowerBound(const_cast<int *>(freedStart));
        while(freedHolders != registered.end()
              && reinterpret_cast<char*>(freedHolders.key()) <  freedEnd) {
            freedHolders = registered.erase(freedHolders);
        }
    }
}

void HbCssConverterUtils::cellMoved(int offset, int newOffset)
{
    int size = cells.value(offset, 0);

    if (size > 0) {
        // Check if there were registered offset holders in the old cell
        // and register corresponding ones in the reallocated cell.
        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
        HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);
        const char *chunkBase = static_cast<const char *>(shared->base());
        const char *freedEnd = chunkBase + offset + size;
        const int *freedStart = reinterpret_cast<const int *>(chunkBase + offset);

        QMap<int *, int>::iterator freedHolders =
                registered.lowerBound(const_cast<int *>(freedStart));
        QList<int *> newHolders;
        while(freedHolders != registered.end()
              && reinterpret_cast<char*>(freedHolders.key()) <  freedEnd) {
            char *holderC = reinterpret_cast<char*>(freedHolders.key());
            newHolders.append(reinterpret_cast<int*>(holderC + newOffset - offset));
            freedHolders = registered.erase(freedHolders);
        }
        for (int i = 0; i < newHolders.size(); ++i) {
            registerOffsetHolder(newHolders.at(i));
        }
    }
}

/**
* Defragments the shared chunk contents and places defragmented buffer in the beginning of the chunk.
* Registered chunk offset holders are updated during the process.
* Returns the next free offset in the chunk.
*/
int HbCssConverterUtils::defragmentChunk()
{
    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
    HbSharedMemoryManager *shared = static_cast<HbSharedMemoryManager*>(manager);

    // Register shared cache pointer in chunk header
    //as shared cache may also be moved in defragmentation
    HbSharedChunkHeader *chunkHeader = static_cast<HbSharedChunkHeader*>(shared->base());
    registerOffsetHolder(reinterpret_cast<int *>(&chunkHeader->sharedCacheOffset));

    QMultiHash<int, int *> offsetHolders = registeredOffsetHolders();

    // Create new buffer where the current chunk contents are defragmented
    char *buffer = static_cast<char*>(::malloc(shared->size()));
    int newCurrentOffset = 0;

    // Create new cell order and update offset holders
    QMap<int,int>::const_iterator end = cells.constEnd();

    for (QMap<int,int>::const_iterator i = cells.constBegin(); i != end; ++i) {
        // Get the old cell
        int offset = i.key();
        int size = i.value();
        
        // Update registered offset holders
        QList<int *> values = offsetHolders.values(offset);
        offsetHolders.remove(offset);
        int newOffset = newCurrentOffset + sizeof(HbSharedChunkHeader);
        for (int j = 0; j < values.size(); ++j) {
            int *holder = values[j];
            *holder = newOffset;
            offsetHolders.insertMulti(*holder, holder);
        }
        newCurrentOffset += size;
    }

    newCurrentOffset = 0;
    // Move allocated cells to a linear buffer
    for (QMap<int, int>::const_iterator i = cells.constBegin(); i != end; ++i) {
        // Get the old cell
        int offset = i.key();
        int size = i.value();
        // Copy to new chunk
        memcpy(buffer + newCurrentOffset, static_cast<char*>(shared->base()) + offset, size);
        newCurrentOffset += size;
    }

    // Free all cells from the shared chunk and move the defragmented buffer in the beginning of the chunk.
    // Note that chunk memory management is screwed up after this point, so no more allocations should be
    // done in it after this.

    unregisterAll();
    QList<int> keys = cells.keys();

    for (int j = 0; j < keys.count(); ++j) {
        shared->free(keys.at(j));
    }

    // CSS binary data is placed after the chunk header.
    int cssBinaryOffset = sizeof(HbSharedChunkHeader);
    char *address = HbMemoryUtils::getAddress<char>(HbMemoryManager::SharedMemory, cssBinaryOffset);
    memcpy(address, buffer, newCurrentOffset);

    cells.clear();
    totalAllocated = 0;

    // Free the temp buffer
    ::free(buffer);

    // Return the next free address in the chunk
    return cssBinaryOffset + newCurrentOffset;
}