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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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 qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qvaluespace_p.h"

#include "qvaluespacepublisher.h"

#include <QSet>

#include <QStringList>

#include <QEventLoop>

#include <QTimer>

#include <QVariant>

#include <QMutex>

#ifdef Q_OS_WINCE

#include <QThread>

#endif

#include <QDebug>

// Define win32 version to pull in RegisterWaitForSingleObject and UnregisterWait.

#define _WIN32_WINNT 0x0500

#include <windows.h>

#ifdef Q_OS_WINCE

#include <regext.h>

#define RegistryCallback REGISTRYNOTIFYCALLBACK

#else

#define RegistryCallback WAITORTIMERCALLBACK

#endif

QTM_BEGIN_NAMESPACE

#ifdef Q_OS_WINCE

class QWindowsCENotify : public QThread

{

    Q_OBJECT

public:

    QWindowsCENotify(QObject *parent = 0);

    ~QWindowsCENotify();

    void addHandle(HANDLE handle);

    void removeHandle(HANDLE handle);

protected:

    void run();

signals:

    void eventSignaled(void *handle);

private:

    HANDLE wakeUp;

    QSet<HANDLE> handles;

};

QWindowsCENotify::QWindowsCENotify(QObject *parent)

:   QThread(parent)

{

    wakeUp = CreateEvent(0, false, false, 0);

}

QWindowsCENotify::~QWindowsCENotify()

{

    CloseHandle(wakeUp);

    wakeUp = INVALID_HANDLE_VALUE;

    wait();

}

void QWindowsCENotify::addHandle(HANDLE handle)

{

    handles.insert(handle);

    SetEvent(wakeUp);

}

void QWindowsCENotify::removeHandle(HANDLE handle)

{

    handles.remove(handle);

    SetEvent(wakeUp);

}

void QWindowsCENotify::run()

{

    while (wakeUp != INVALID_HANDLE_VALUE) {

        ResetEvent(wakeUp);

        QVector<HANDLE> waitHandles = handles.toList().toVector();

        waitHandles.append(wakeUp);

        DWORD index = WaitForMultipleObjects(waitHandles.count(), waitHandles.data(),

                                             false, INFINITE);

        if (index >= WAIT_OBJECT_0 && index < WAIT_OBJECT_0 + waitHandles.count()) {

            if (index - WAIT_OBJECT_0 != waitHandles.count() - 1) {

                handles.remove(waitHandles.at(index - WAIT_OBJECT_0));

                emit eventSignaled(waitHandles.at(index - WAIT_OBJECT_0));

            }

        } else if (index >= WAIT_ABANDONED_0 && index < WAIT_ABANDONED_0 + waitHandles.count()) {

            //qDebug() << "woke up because of abandoned index" << index - WAIT_ABANDONED_0;

        } else {

            qDebug() << "WaitForMultipleObjects failed with error" << GetLastError();

        }

    }

}

#endif

class RegistryLayer : public QAbstractValueSpaceLayer

{

    Q_OBJECT

public:

    RegistryLayer(const QString &basePath, bool volatileKeys, RegistryCallback callback);

    ~RegistryLayer();

    /* Common functions */

    bool startup(Type t);

    Handle item(Handle parent, const QString &path);

    void removeHandle(Handle handle);

    void setProperty(Handle handle, Properties);

    bool value(Handle handle, QVariant *data);

    bool value(Handle handle, const QString &subPath, QVariant *data);

    QSet<QString> children(Handle handle);

    /* QValueSpaceSubscriber functions */

    bool supportsInterestNotification() const;

    bool notifyInterest(Handle handle, bool interested);

    /* QValueSpacePublisher functions */

    bool setValue(QValueSpacePublisher *creator, Handle handle, const QVariant &data);

    bool setValue(QValueSpacePublisher *creator, Handle handle, const QString &path,

                  const QVariant &data);

    bool removeValue(QValueSpacePublisher *creator, Handle handle, const QString &subPath);

    bool removeSubTree(QValueSpacePublisher *creator, Handle parent);

    void addWatch(QValueSpacePublisher *creator, Handle handle);

    void removeWatches(QValueSpacePublisher *creator, Handle parent);

    void sync();

public slots:

    void emitHandleChanged(void *hkey);

#ifdef Q_OS_WINCE

    void eventSignaled(void *handle);

#endif

private:

    struct RegistryHandle {

        RegistryHandle(const QString &p)

        :   path(p), valueHandle(false), refCount(1)

        {

        }

        QString path;

        bool valueHandle;

        unsigned int refCount;

    };

    void openRegistryKey(RegistryHandle *handle);

    bool createRegistryKey(RegistryHandle *handle);

    bool removeRegistryValue(RegistryHandle *handle, const QString &path);

    void closeRegistryKey(RegistryHandle *handle);

    void pruneEmptyKeys(RegistryHandle *handle);

    QMutex localLock;

    QString m_basePath;

    bool m_volatileKeys;

    RegistryCallback m_callback;

    QHash<QString, RegistryHandle *> handles;

    RegistryHandle *registryHandle(Handle handle)

    {

        if (handle == InvalidHandle)

            return 0;

        RegistryHandle *h = reinterpret_cast<RegistryHandle *>(handle);

        if (handles.values().contains(h))

            return h;

        return 0;

    }

    QMap<RegistryHandle *, HKEY> hKeys;

    QMultiMap<RegistryHandle *, RegistryHandle *> notifyProxies;

    // MinGW complains about QPair<::HANDLE, ::HANDLE>

    typedef ::HANDLE HandleType;

    typedef QPair<HandleType, HandleType> HandlePair;

    QMap<HKEY, HandlePair > waitHandles;

#ifdef Q_OS_WINCE

    QWindowsCENotify *notifyThread;

#endif

    QMap<QValueSpacePublisher *, QList<QString> > creators;

};

class VolatileRegistryLayer : public RegistryLayer

{

    Q_OBJECT

public:

    VolatileRegistryLayer();

    ~VolatileRegistryLayer();

    /* Common functions */

    QString name();

    QUuid id();

    unsigned int order();

    QValueSpace::LayerOptions layerOptions() const;

    static VolatileRegistryLayer *instance();

};

Q_GLOBAL_STATIC(VolatileRegistryLayer, volatileRegistryLayer);

QVALUESPACE_AUTO_INSTALL_LAYER(VolatileRegistryLayer);

class NonVolatileRegistryLayer : public RegistryLayer

{

    Q_OBJECT

public:

    NonVolatileRegistryLayer();

    ~NonVolatileRegistryLayer();

    /* Common functions */

    QString name();

    QUuid id();

    unsigned int order();

    QValueSpace::LayerOptions layerOptions() const;

    static NonVolatileRegistryLayer *instance();

};

Q_GLOBAL_STATIC(NonVolatileRegistryLayer, nonVolatileRegistryLayer);

QVALUESPACE_AUTO_INSTALL_LAYER(NonVolatileRegistryLayer);

#ifdef Q_OS_WINCE

void qVolatileRegistryLayerCallback(HREGNOTIFY hNotify, DWORD dwUserData,

                                    const PBYTE pData, const UINT cbdata)

{

}

void qNonVolatileRegistryLayerCallback(HREGNOTIFY hNotify, DWORD dwUserData,

                                    const PBYTE pData, const UINT cbdata)

{

}

#else

void CALLBACK qVolatileRegistryLayerCallback(PVOID lpParameter, BOOLEAN)

{

    QMetaObject::invokeMethod(volatileRegistryLayer(), "emitHandleChanged", Qt::QueuedConnection,

                              Q_ARG(void *, lpParameter));

}

void CALLBACK qNonVolatileRegistryLayerCallback(PVOID lpParameter, BOOLEAN)

{

    QMetaObject::invokeMethod(nonVolatileRegistryLayer(), "emitHandleChanged",

                              Qt::QueuedConnection, Q_ARG(void *, lpParameter));

}

#endif

static QString qConvertPath(const QString &path)

{

    QString fixedPath(path);

    while (fixedPath.endsWith(QLatin1Char('/')))

        fixedPath.chop(1);

    fixedPath.replace(QLatin1Char('/'), QLatin1Char('\\'));

    return fixedPath;

}

VolatileRegistryLayer::VolatileRegistryLayer()

:   RegistryLayer(QLatin1String("Software/Nokia/QtMobility/volatileContext"), true,

                  &qVolatileRegistryLayerCallback)

{

}

VolatileRegistryLayer::~VolatileRegistryLayer()

{

}

QString VolatileRegistryLayer::name()

{

    return QLatin1String("Volatile Registry Layer");

}

QUuid VolatileRegistryLayer::id()

{

    return QVALUESPACE_VOLATILEREGISTRY_LAYER;

}

unsigned int VolatileRegistryLayer::order()

{

    return 0x1000;

}

QValueSpace::LayerOptions VolatileRegistryLayer::layerOptions() const

{

    return QValueSpace::TransientLayer | QValueSpace::WritableLayer;

}

VolatileRegistryLayer *VolatileRegistryLayer::instance()

{

    return volatileRegistryLayer();

}

NonVolatileRegistryLayer::NonVolatileRegistryLayer()

:   RegistryLayer(QLatin1String("Software/Nokia/QtMobility/nonVolatileContext"), false,

                  &qNonVolatileRegistryLayerCallback)

{

}

NonVolatileRegistryLayer::~NonVolatileRegistryLayer()

{

}

QString NonVolatileRegistryLayer::name()

{

    return QLatin1String("Non-Volatile Registry Layer");

}

QUuid NonVolatileRegistryLayer::id()

{

    return QVALUESPACE_NONVOLATILEREGISTRY_LAYER;

}

unsigned int NonVolatileRegistryLayer::order()

{

    return 0;

}

QValueSpace::LayerOptions NonVolatileRegistryLayer::layerOptions() const

{

    return QValueSpace::PermanentLayer | QValueSpace::WritableLayer;

}

NonVolatileRegistryLayer *NonVolatileRegistryLayer::instance()

{

    return nonVolatileRegistryLayer();

}

RegistryLayer::RegistryLayer(const QString &basePath, bool volatileKeys, RegistryCallback callback)

:   localLock(QMutex::Recursive), m_basePath(basePath), m_volatileKeys(volatileKeys),

    m_callback(callback)

{

    // Ensure that the m_basePath key exists and is non-volatile.

    HKEY key;

    RegCreateKeyEx(HKEY_CURRENT_USER,

                    reinterpret_cast<const wchar_t*>(qConvertPath(m_basePath).utf16()),

                    0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0, &key, 0);

    RegCloseKey(key);

#ifdef Q_OS_WINCE

    notifyThread = new QWindowsCENotify(this);

    connect(notifyThread, SIGNAL(eventSignaled(void*)),

            this, SLOT(eventSignaled(void*)), Qt::QueuedConnection);

    notifyThread->start();

#endif

}

RegistryLayer::~RegistryLayer()

{

    QMutableHashIterator<QString, RegistryHandle *> i(handles);

    while (i.hasNext()) {

        i.next();

        RegistryHandle *handle = i.value();

        if (handle->valueHandle)

            removeHandle(Handle(handle));

    }

    i.toFront();

    while (i.hasNext()) {

        i.next();

        removeHandle(Handle(i.value()));

    }

}

bool RegistryLayer::startup(Type)

{

    return true;

}

bool RegistryLayer::value(Handle handle, QVariant *data)

{

    QMutexLocker locker(&localLock);

    RegistryHandle *rh = registryHandle(handle);

    if (!rh)

        return false;

    return value(InvalidHandle, rh->path, data);

}

bool RegistryLayer::value(Handle handle, const QString &subPath, QVariant *data)

{

    QMutexLocker locker(&localLock);

    if (handle != InvalidHandle && !registryHandle(handle))

        return false;

    QString path(subPath);

    while (path.endsWith(QLatin1Char('/')))

        path.chop(1);

    if (handle != InvalidHandle)

        while (path.startsWith(QLatin1Char('/')))

            path = path.mid(1);

    Handle fullHandle = item(handle, subPath);

    if (fullHandle != InvalidHandle) {

        RegistryHandle *rh = registryHandle(fullHandle);

        if (rh) {

            openRegistryKey(rh);

            if (!rh->valueHandle) {

                handle = fullHandle;

                path.clear();

            }

        }

    }

    int index = path.lastIndexOf(QLatin1Char('/'), -1);

    bool createdHandle = false;

    QString value;

    if (index == -1) {

        value = path;

    } else {

        // want a value that is in a sub path under handle

        value = path.mid(index + 1);

        path.truncate(index);

        if (path.isEmpty())

            path = QLatin1String("/");

        handle = item(handle, path);

        createdHandle = true;

    }

    RegistryHandle *rh = registryHandle(handle);

    openRegistryKey(rh);

    if (!hKeys.contains(rh)) {

        if (createdHandle)

            removeHandle(handle);

        return false;

    }

    HKEY key = hKeys.value(rh);

    DWORD regSize = 0;

    long result = RegQueryValueEx(key,

            reinterpret_cast<const wchar_t*>(value.utf16()), 0, 0, 0, &regSize);

    if (result == ERROR_FILE_NOT_FOUND) {

        *data = QVariant();

        if (createdHandle)

            removeHandle(handle);

        return false;

    } else if (result != ERROR_SUCCESS) {

        qDebug() << "RegQueryValueEx failed with error" << result;

        *data = QVariant();

        if (createdHandle)

            removeHandle(handle);

        return false;

    }

    BYTE *regData = new BYTE[regSize];

    DWORD regType;

    result = RegQueryValueEx(key,

            reinterpret_cast<const wchar_t*>(value.utf16()), 

            0, &regType, regData, &regSize);

    if (result != ERROR_SUCCESS) {

        qDebug() << "real RegQueryValueEx failed with error" << result;

        if (createdHandle)

            removeHandle(handle);

        return false;

    }

    switch (regType) {

    case REG_DWORD:

        *data = qVariantFromValue(*reinterpret_cast<uint *>(regData));

        break;