#include "hbinputmodecache_p_p.h"

#include <QSharedMemory>

#include <QDataStream>

#include <QBuffer>

void HbInputMethodListItem::setValues(QInputContextPlugin *plugin, const QString &key)

{

    if (plugin) {

        descriptor.setKey(key);

        descriptor.setDisplayName(plugin->displayName(key));

        HbInputContextPlugin *extension = qobject_cast<HbInputContextPlugin *>(plugin);

        if (extension) {

            descriptor.setDisplayNames(extension->displayNames(key));

            descriptor.setIcon(extension->icon(key));

            descriptor.setIcons(extension->icons(key));

        }

    }

}

QDataStream &operator<<(QDataStream &out, const HbInputMethodListItem &item)

{

    out << item.descriptor;

    out << item.languages;

    return out;

}

QDataStream &operator>>(QDataStream &in, HbInputMethodListItem &item)

{

    in >> item.descriptor;

    in >> item.languages;

    item.cached = 0;

    item.toBeRemoved = false;

    return in;

}

HbInputModeCachePrivate::HbInputModeCachePrivate()

  : mSharedMethodList(0),

    mMethodListModTime(0),

    mMethodListLastUpdate(0),

    mMethodsFetchedFromDisk(false),

    mShuttingDown(false)

    mSharedMethodList = new QSharedMemory(HbInputMethodListKey);

    // sharedMethodList is only attached when the list is updated

    mMethodListModTime = new QSharedMemory(HbInputMethodListModTimeKey);

    mMethodListModTime->attach();

}

HbInputModeCachePrivate::~HbInputModeCachePrivate()

{

    delete mSharedMethodList;

    delete mMethodListModTime;

}

void HbInputModeCachePrivate::refresh()

{

    // Shared memory data is used if available (checked every time we refresh)

    // Otherwise the methods are read from disk, but just once during modecache lifetime

    if (!readInputMethodDataFromSharedMemory() && !mMethodsFetchedFromDisk) {

        readInputMethodDataFromDisk(&mMethods);

        pruneRemovedMethods();

        mMethodsFetchedFromDisk = true;

    }

}

void HbInputModeCachePrivate::readInputMethodDataFromDisk(QList<HbInputMethodListItem>* methodList, const QDir &readPath)

{

    bool readFromSinglePath = (readPath != QDir());

    // First go through all the previously found entries and

    // tag them not refreshed. In case a directory is defined, only marks entries

    // in that directory

    for (int i = 0; i < methodList->size(); ++i) {

        if (readFromSinglePath) {

            if (methodList->at(i).descriptor.pluginNameAndPath().left(methodList->at(i).descriptor.pluginNameAndPath().lastIndexOf(QDir::separator()))

                == readPath.absolutePath()) {

                (*methodList)[i].toBeRemoved = true;

            }

        } else {

            (*methodList)[i].toBeRemoved = true;

        }

    // Query plugin paths and scan the folders.

    QStringList folders = HbInputSettingProxy::instance()->inputMethodPluginPaths();

    foreach(const QString &folder, folders) {

        QDir dir(folder);

        if (!readFromSinglePath || readPath == dir) {

            for (unsigned int i = 0; i < dir.count(); i++) {

                QString path = QString(dir.absolutePath());

                if (path.right(1) != "\\" && path.right(1) != "/") {

                    path += QDir::separator();

                }

                path += dir[i];

                QInputContextPlugin *inputContextPlugin = pluginInstance(path);

                if (inputContextPlugin) {

                    HbInputMethodListItem listItem;

                    listItem.descriptor.setPluginNameAndPath(dir.absolutePath() + QDir::separator() + dir[i]);

                    // For each found plugin, check if there is already a list item for it.

                    // If not, then add one.

                    QStringList contextKeys = inputContextPlugin->keys();

                    foreach(const QString &key, contextKeys) {

                        listItem.setValues(inputContextPlugin, key);

                        int index = methodList->indexOf(listItem);

                        if (index >= 0) {

                            // The method is already in the list, the situation hasn't changed.

                            // just tag it not to be removed.

                            (*methodList)[index].toBeRemoved = false;

                        } else {

                            listItem.languages = inputContextPlugin->languages(key);

                            methodList->append(listItem);

                        }

                    }

                }

            }

        }

    }

}

bool HbInputModeCachePrivate::readInputMethodDataFromSharedMemory()

    // Check if the shared list has been modified

    if (!mMethodListModTime->isAttached()) {

        // Shared memory is not attached

        // Revert to in-process handling

        return false;

    }

    // No locking, since in case the value is corrupt we just need to read the list again

    // on the next run

    uint *newModTime = static_cast<uint *>(mMethodListModTime->data());

    if (*newModTime == mMethodListLastUpdate) {

        // The internal list is still in sync with the one in shared memory

        return true;

    }

    // Modifications done since last update, try to attach the method list

    // Revert to in-process handling if not successful

    if (!mSharedMethodList->attach()) {

        return false;

    }

    // Attached successfully, update the modification time

    mMethodListLastUpdate = *newModTime;

    // To start updating the list, first mark all methods for removal

    for (int k = 0; k < mMethods.count(); k++) {

        mMethods[k].toBeRemoved = true;

    }

    // Get a copy of the list from shared memory

    mSharedMethodList->lock();

    QByteArray array(static_cast<const char *>(mSharedMethodList->data())+sizeof(int), *static_cast<int *>(mSharedMethodList->data()));

    // array now has a copy of the data, so we can unlock and detach

    mSharedMethodList->unlock();

    mSharedMethodList->detach();

    // Next read the entries from the array to a temporary list

    QDataStream in(&array, QIODevice::ReadOnly);

    QList<HbInputMethodListItem> newMethodList;

    in >> newMethodList;

    // Go through the temporary list and append new methods to internal list

    // Duplicates are marked as not to be removed, the rest will be removed by pruneRemovedMethods

    foreach (const HbInputMethodListItem& item, newMethodList) {

        int index = mMethods.indexOf(item);

        if (index >= 0) {

            mMethods[index].toBeRemoved = false;

        } else {

            mMethods.append(item);

        }

    }

    pruneRemovedMethods();

    return true;

}

void HbInputModeCachePrivate::pruneRemovedMethods()

{

    // Go through the cache list and find out if some of the previous items need to be

    // removed after the refresh.

    for (int i = 0; i < mMethods.count(); i++) {

        if (mMethods.at(i).toBeRemoved) {

            if (mMethods.at(i).cached && mMethods.at(i).cached->isActiveMethod()) {

                // If the item to be removed happens to be the active one,

                // try to deal with the situation.

                mMethods.at(i).cached->forceUnfocus();

                // The active custom method is being removed.

                // Clear out related setting proxy values.

                if (mMethods.at(i).descriptor.pluginNameAndPath() == HbInputSettingProxy::instance()->preferredInputMethod(Qt::Horizontal).pluginNameAndPath()) {

                    HbInputSettingProxy::instance()->setPreferredInputMethod(Qt::Horizontal, HbInputMethodDescriptor());

                }

                if (mMethods.at(i).descriptor.pluginNameAndPath() == HbInputSettingProxy::instance()->preferredInputMethod(Qt::Vertical).pluginNameAndPath()) {

                    HbInputSettingProxy::instance()->setPreferredInputMethod(Qt::Vertical, HbInputMethodDescriptor());

                }

                // Replace it with null input context.

                HbInputMethod *master = HbInputMethodNull::Instance();

                master->d_ptr->mIsActive = true;

                QInputContext *proxy = master->d_ptr->proxy();

                if (proxy != qApp->inputContext()) {

                    qApp->setInputContext(proxy);

                }

            }

            delete mMethods[i].cached;

            mMethods.removeAt(i);

            i--;

        }

    }

}

QInputContextPlugin *HbInputModeCachePrivate::pluginInstance(const QString &pluginFileName)

                modeList.append(HbInputModeProperties::fromString(language));

    return (HbKeymapFactory::instance()->keymap(language) != 0);

    d->refresh();

        if (d->mMethods.at(i).descriptor.pluginNameAndPath() == inputMethod.pluginNameAndPath() &&

            d->mMethods.at(i).descriptor.key() == inputMethod.key()) {

            if (!d->mMethods.at(i).cached) {

    d->refresh();

            HbInputModeProperties properties = HbInputModeProperties::fromString(language);

    d->refresh();

    for (int i = 0; i < d->mMethods.count(); i++) {

        foreach (const QString &lang, d->mMethods.at(i).languages) {

            HbInputModeProperties properties = HbInputModeProperties::fromString(lang);

                result.append(d->mMethods[i].descriptor);

    d->refresh();

    HbInputLanguage currentLanguage = HbInputSettingProxy::instance()->globalInputLanguage();

    bool mapped = d->isMappedLanguage(currentLanguage);

    for (int i = 0; i < d->mMethods.count(); i++) {

        foreach (const QString &language, d->mMethods[i].languages) {

            HbInputModeProperties properties = HbInputModeProperties::fromString(language);

            if (properties.language().undefined()) {

                // The input method reports language range but current language is not mapped

                // language. Skip this one. 

                if (!mapped) {

                    continue; 

                }

            } else {

                // The input method reports support for specific language but it is not an exact

                // match to current language. Skip this one 

                if (properties.language() != currentLanguage) {

                    // It is not direct match either.

                    continue;

                }

            }

                return d->mMethods[i].descriptor;

    return HbInputMethodDescriptor();

    d->refresh();

    HbInputModeProperties stateProperties(state);

            HbInputModeProperties properties = HbInputModeProperties::fromString(language);