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

**

** 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 <QApplication>

#include <QObject>

#include <QTextStream>

#include <QFile>

#include <QSocketNotifier>

#include <cstdio>

#include <cstdlib>

#include <QMap>

#include <QDir>

#include <QStringList>

#include <QSet>

#include <qvaluespace.h>

#include <qvaluespacesubscriber.h>

#include <qvaluespacepublisher.h>

#ifdef USE_READLINE

#include <stdio.h>

#include <readline/readline.h>

#include <readline/history.h>

#include <QThread>

#include <QMutex>

#include <QEvent>

#include <QWaitCondition>

#include <pthread.h>

#endif

#ifdef Q_OS_WIN

#include <QThread>

#endif

QTM_USE_NAMESPACE

static bool terminateRequested = false;

class VSExplorer : public QObject

{

Q_OBJECT

public:

    VSExplorer();

    void printError();

    void printHelp();

    void ls();

    void dump();

    void pwdCmd();

    void ls(const QString &abs, bool);

    void subscribe();

    void unsubscribe();

    void quit();

    void suppress();

    void listwatchers();

    void watch(const QString &);

    void unwatch(const QString &);

    void set(const QString &, const QString &);

    void clear(const QString &);

    void subscriptions();

    QString path() const

    {

        return pwd.path();

    }

public slots:

    void processLine(const QString &);

private slots:

    void contentsChanged();

    void interestChanged(const QString &attribute, bool interested);

private:

    void lsPath(QValueSpaceSubscriber *, int = 0, bool = false);

    bool isSuppress;

    QValueSpaceSubscriber pwd;

    QValueSpacePublisher prov;

    QSet<QValueSpaceSubscriber *> subs;

    QSet<QValueSpacePublisher *> watchers;

};

static VSExplorer * vse = 0;

class LineInput :

#if defined(USE_READLINE) || defined(Q_OS_WIN)

    public QThread

#else

    public QObject

#endif

{

    Q_OBJECT

public:

    LineInput();

signals:

    void line(const QString &);

#if defined(USE_READLINE)

protected:

    virtual bool event(QEvent *);

    virtual void run();

private:

    QMutex mutex;

    QWaitCondition wait;

#elif defined(Q_OS_WIN)

protected:

    void run();

private:

    QFile ts;

#else

private slots:

    void readyRead();

private:

    QFile ts;

    QSocketNotifier *sock;

#endif

};

VSExplorer::VSExplorer()

{

}

void VSExplorer::interestChanged(const QString &attribute, bool interested)

{

    Q_ASSERT(sender());

    if (!isSuppress) {

        QValueSpacePublisher *obj = static_cast<QValueSpacePublisher *>(sender());

        fprintf(stdout, "\nInterest Changed: %s ... %s %d\n",

                qPrintable(obj->path()), qPrintable(attribute), interested);

    }

}

static QString variantToString( const QVariant& var )

{

    if ( var.type() == QVariant::StringList )

    else

        return var.toString();

}

void VSExplorer::contentsChanged()

{

    Q_ASSERT(sender());

    if(!isSuppress) {

        QValueSpaceSubscriber *subscriber = static_cast<QValueSpaceSubscriber *>(sender());

        fprintf(stdout, "\nChanged: %s\n", subscriber->path().toAscii().constData());

    }

}

void VSExplorer::printError()

{

    fprintf(stdout, "Come again?\n");

    fflush(stdout);

}

void VSExplorer::printHelp()

{

    fprintf(stdout, "help/?: Print this message\n");

    fprintf(stdout, "quit: Exit VSExplorer\n");

    fprintf(stdout, "ls: List contents of path\n");

    fprintf(stdout, "pwd: Print current working directory\n");

    fprintf(stdout, "subscribe: Subscribe to path\n");

    fprintf(stdout, "unsubscribe: Unsubscribe from path\n");

    fprintf(stdout, "suppress: Toggle suppression of publish messages\n");

    fprintf(stdout, "subscriptions: List current subscriptions\n");

    fprintf(stdout, "set <key> <value>: Set app layer<key> to <value>\n");

    fprintf(stdout, "clear <key>: Clear app layer <key>\n");

    fprintf(stdout, "cd <path>: Change working path\n");

    fprintf(stdout, "watch <path>: Add a watch for the path\n");

    fprintf(stdout, "unwatch <path>: Remove a watch for the path\n");

    fprintf(stdout, "watchers: List paths for which a watch is active\n");

    fflush(stdout);

}

void VSExplorer::ls()

{

    lsPath(&pwd);

    fflush(stdout);

}

void VSExplorer::ls(const QString &abs, bool all)

{

    QValueSpaceSubscriber subscriber(abs);

    lsPath(&subscriber, 0, all);

    fflush(stdout);

}

void VSExplorer::lsPath(QValueSpaceSubscriber * p, int indent, bool showHidden)

{

    QVariant var = p->value();

    bool spaceRequired = false;

    if(!var.isNull()) {

        fprintf(stdout, "Value: '%s' (%s)\n",

                variantToString(var).toAscii().constData(), var.typeName());

        spaceRequired = true;

    }

            continue;

        if(spaceRequired) {

            fprintf(stdout, "\n");

            spaceRequired = false;

        }

        for(int ii = 0; ii < indent; ++ii) fprintf(stdout, "\t");

        fprintf(stdout, "%s/", path.toAscii().constData());

        QVariant value = p->value(path);

        if(!value.isNull()) {

            if(path.length() < 30) {

                for(int ii = 0; ii < 30 - path.length(); ++ii)

                    fprintf(stdout, " ");

            } else {

                fprintf(stdout, "    ");

            }

            fprintf(stdout, " '%s' (%s)",

                    variantToString(value).toAscii().constData(), value.typeName());

        }

        fprintf(stdout, "\n");

    }

}

void VSExplorer::listwatchers()

{

    if(watchers.isEmpty()) {

        fprintf(stdout, "No watchers.\n");

    } else {

        fprintf(stdout, "Current watchers:\n");

        foreach (QValueSpacePublisher *obj, watchers)

            fprintf(stdout, "\t%s\n", obj->path().toAscii().constData());

    }

    fflush(stdout);

}

void VSExplorer::subscriptions()

{

    if(subs.isEmpty()) {

        fprintf(stdout, "No subscriptions.\n");

    } else {

        fprintf(stdout, "Current subscriptions:\n");

        foreach (QValueSpaceSubscriber *subscriber, subs)

            fprintf(stdout, "\t%s\n", subscriber->path().toAscii().constData());

    }

    fflush(stdout);

}

void VSExplorer::subscribe()

{

    QValueSpaceSubscriber *subscriber = new QValueSpaceSubscriber;

    subscriber->setPath(&pwd);

    QObject::connect(subscriber, SIGNAL(contentsChanged()),

                     this, SLOT(contentsChanged()));

    subs.insert(subscriber);

    fprintf(stdout, "OK\n");

    fflush(stdout);

}

void VSExplorer::unsubscribe()

{

    foreach (QValueSpaceSubscriber *subscriber, subs) {

        if (subscriber->path() == pwd.path()) {

            subs.remove(subscriber);

            delete subscriber;

            fprintf(stdout, "OK\n");

            fflush(stdout);

            return;

        }

    }

    fprintf(stdout, "No subscription.\n");

    fflush(stdout);

}

void VSExplorer::quit()

{

    fprintf(stdout, "Bye, bye.\n");

    fflush(stdout);

    terminateRequested = true;

}

void VSExplorer::watch(const QString &path)

{

    foreach (QValueSpacePublisher *obj, watchers) {

        if (obj->path() == path)

            return;

    }

    QValueSpacePublisher * newObject = new QValueSpacePublisher(path);

    watchers.insert(newObject);

    QObject::connect(newObject, SIGNAL(interestChanged(QString,bool)),

                     this, SLOT(interestChanged(QString,bool)));

}

void VSExplorer::unwatch(const QString &path)

{

    foreach (QValueSpacePublisher *obj, watchers) {

        if (obj->path() == path) {

            watchers.remove(obj);

            delete obj;

            return;

        }

    }

}

void VSExplorer::suppress()

{

    if (isSuppress) {

        isSuppress = false;

        fprintf(stdout, "Suppression off.\n");

    } else {

        isSuppress = true;

        fprintf(stdout, "Suppression on.\n");

    }

    fflush(stdout);

}

void VSExplorer::set(const QString &name, const QString &value)

{

        prov.setValue(name, value);

        prov.setValue(pwd.path() + name, value);

    else

}

void VSExplorer::clear(const QString &name)

{

        prov.resetValue(name);

        prov.resetValue(pwd.path() + name);

    else

}

void VSExplorer::processLine(const QString &line)

{

    if(cmds.isEmpty()) {

        return;

    }

    const QString & cmd = cmds.at(0);

        ls();

        dump();

        pwdCmd();

        QStringList newCmds = cmds;

        newCmds.removeFirst();

        bool lsAll = false;

            lsAll = true;

            newCmds.removeFirst();

        }

            newPath = newPath.mid(1);

            newPath = newPath.left(newPath.length() - 1);

        }

        if(newPath.isEmpty()) {

        } else {

            QString oldPath = pwd.path();

            oldPath.append(newPath);

            oldPath = QDir::cleanPath(oldPath);

        }

        QStringList newCmds = cmds;

        newCmds.removeFirst();

            newPath = newPath.mid(1);

            newPath = newPath.left(newPath.length() - 1);

        }

            pwd.setPath(newPath);

        } else {

            QString oldPath = pwd.path();

            oldPath.append(newPath);

            oldPath = QDir::cleanPath(oldPath);

            pwd.setPath(oldPath);

        }

        QStringList newCmds = cmds;

        newCmds.removeFirst();

        QString finalPath;

            newPath = newPath.mid(1);

            newPath = newPath.left(newPath.length() - 1);

        }

            finalPath = QValueSpaceSubscriber(newPath).path();

        } else {

            QString oldPath = pwd.path();

            oldPath.append(newPath);

            oldPath = QDir::cleanPath(oldPath);

            finalPath = QValueSpaceSubscriber(oldPath).path();

        }

        QStringList newCmds = cmds;

        newCmds.removeFirst();

        QString finalPath;

            newPath = newPath.mid(1);

            newPath = newPath.left(newPath.length() - 1);

        }

            finalPath = QValueSpaceSubscriber(newPath).path();

        } else {

            QString oldPath = pwd.path();

            oldPath.append(newPath);

            oldPath = QDir::cleanPath(oldPath);

            finalPath = QValueSpaceSubscriber(oldPath).path();

        }

        set(cmds.at(1).trimmed(), cmds.at(2).trimmed());

        clear(cmds.at(1).trimmed());

        subscribe();

        unsubscribe();

        printHelp();

        quit();

        suppress();

        listwatchers();

        subscriptions();

    } else {

        printError();

    }

}

#ifdef USE_READLINE

extern "C" {

    char * item_generator(const char * text, int num);

    char * command_generator(const char * text, int num);