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

**

** All rights reserved.

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

**

** This file is part of the QtSCriptTools module of the Qt Toolkit.

**

** $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 "qscriptdebuggerlocalsmodel_p.h"

#include "qscriptdebuggercommandschedulerjob_p.h"

#include "qscriptdebuggervalue_p.h"

#include "qscriptdebuggerresponse_p.h"

#include "qscriptdebuggerevent_p.h"

#include "qscriptdebuggervalueproperty_p.h"

#include "qscriptdebuggercommandschedulerinterface_p.h"

#include "qscriptdebuggercommandschedulerfrontend_p.h"

#include "qscriptdebuggerjobschedulerinterface_p.h"

#include "qscriptdebuggerobjectsnapshotdelta_p.h"

#include "private/qabstractitemmodel_p.h"

#include <QtCore/qdebug.h>

#include <QtCore/qcoreapplication.h>

#include <QtGui/qbrush.h>

#include <QtGui/qfont.h>

Q_DECLARE_METATYPE(QScriptDebuggerObjectSnapshotDelta)

QT_BEGIN_NAMESPACE

struct QScriptDebuggerLocalsModelNode

{

    enum PopulationState {

        NotPopulated,

        Populating,

        Populated

    };

    QScriptDebuggerLocalsModelNode()

        : parent(0), populationState(NotPopulated), snapshotId(-1), changed(false) {}

    QScriptDebuggerLocalsModelNode(

        const QScriptDebuggerValueProperty &prop,

        QScriptDebuggerLocalsModelNode *par)

        : property(prop), parent(par),

          populationState(NotPopulated), snapshotId(-1), changed(false)

    {

        parent->children.append(this);

    }

    ~QScriptDebuggerLocalsModelNode() { qDeleteAll(children); }

    QScriptDebuggerLocalsModelNode *findChild(const QString &name)

    {

        for (int i = 0; i < children.size(); ++i) {

            QScriptDebuggerLocalsModelNode *child = children.at(i);

            if (child->property.name() == name)

                return child;

        }

        return 0;

    }

    QScriptDebuggerValueProperty property;

    QScriptDebuggerLocalsModelNode *parent;

    QList<QScriptDebuggerLocalsModelNode*> children;

    PopulationState populationState;

    int snapshotId;

    bool changed;

};

class QScriptDebuggerLocalsModelPrivate

    : public QAbstractItemModelPrivate

{

    Q_DECLARE_PUBLIC(QScriptDebuggerLocalsModel)

public:

    QScriptDebuggerLocalsModelPrivate();

    ~QScriptDebuggerLocalsModelPrivate();

    static QScriptDebuggerLocalsModelPrivate *get(QScriptDebuggerLocalsModel *q);

    QModelIndex addTopLevelObject(const QString &name, const QScriptDebuggerValue &object);

    QScriptDebuggerLocalsModelNode *nodeFromIndex(const QModelIndex &index) const;

    QModelIndex indexFromNode(QScriptDebuggerLocalsModelNode *node) const;

    bool isTopLevelNode(QScriptDebuggerLocalsModelNode *node) const;

    void populateIndex(const QModelIndex &index);

    void reallyPopulateIndex(const QModelIndex &index,

                             const QScriptDebuggerValuePropertyList &props);

    void syncIndex(const QModelIndex &index);

    void reallySyncIndex(const QModelIndex &index,

                         const QScriptDebuggerObjectSnapshotDelta &delta);

    void syncTopLevelNodes();

    void removeTopLevelNodes();

    void emitScopeObjectAvailable(const QModelIndex &index);

    void emitDataChanged(const QModelIndex &tl, const QModelIndex &br);

    void removeChild(const QModelIndex &parentIndex,

                     QScriptDebuggerLocalsModelNode *parentNode, int row);

    void depopulate(QScriptDebuggerLocalsModelNode *node);

    void repopulate(QScriptDebuggerLocalsModelNode *node);

    void addChildren(const QModelIndex &parentIndex,

                     QScriptDebuggerLocalsModelNode *parentNode,

                     const QScriptDebuggerValuePropertyList &props);

    void deleteObjectSnapshots(const QList<qint64> &snapshotIds);

    void deleteAllObjectSnapshots();

    QScriptDebuggerJobSchedulerInterface *jobScheduler;

    QScriptDebuggerCommandSchedulerInterface *commandScheduler;

    QScriptDebuggerLocalsModelNode *invisibleRootNode;

    int frameIndex;

};

QScriptDebuggerLocalsModelPrivate::QScriptDebuggerLocalsModelPrivate()

{

    invisibleRootNode = new QScriptDebuggerLocalsModelNode();

    frameIndex = -1;

}

QScriptDebuggerLocalsModelPrivate::~QScriptDebuggerLocalsModelPrivate()

{

    delete invisibleRootNode;

}

void QScriptDebuggerLocalsModelPrivate::emitDataChanged(const QModelIndex &tl, const QModelIndex &br)

{

    q_func()->dataChanged(tl, br);

}

static QList<qint64> findSnapshotIdsRecursively(QScriptDebuggerLocalsModelNode *root)

{

    QList<qint64> result;

    if (root->snapshotId == -1) {

        Q_ASSERT(root->children.isEmpty());

        return result;

    }

    QList<QScriptDebuggerLocalsModelNode*> nodeStack;

    nodeStack.append(root);

    while (!nodeStack.isEmpty()) {

        QScriptDebuggerLocalsModelNode *node = nodeStack.takeFirst();

        result.append(node->snapshotId);

        for (int i = 0; i < node->children.count(); ++i) {

            QScriptDebuggerLocalsModelNode *child = node->children.at(i);

            if (child->snapshotId != -1)

                nodeStack.prepend(child);

        }

    }

    return result;

}

void QScriptDebuggerLocalsModelPrivate::removeChild(const QModelIndex &parentIndex,

                                                    QScriptDebuggerLocalsModelNode *parentNode,

                                                    int row)

{

    Q_Q(QScriptDebuggerLocalsModel);

    q->beginRemoveRows(parentIndex, row, row);

    QScriptDebuggerLocalsModelNode *child = parentNode->children.takeAt(row);

    QList<qint64> snapshotIds = findSnapshotIdsRecursively(child);

    delete child;

    q->endRemoveRows();

    deleteObjectSnapshots(snapshotIds);

}

void QScriptDebuggerLocalsModelPrivate::depopulate(QScriptDebuggerLocalsModelNode *node)

{

    Q_Q(QScriptDebuggerLocalsModel);

    bool hasChildren = !node->children.isEmpty();

    if (hasChildren)

        q->beginRemoveRows(indexFromNode(node), 0, node->children.count() - 1);

    QList<qint64> snapshotIds = findSnapshotIdsRecursively(node);

    qDeleteAll(node->children);

    node->children.clear();

    node->snapshotId = -1;

    node->populationState = QScriptDebuggerLocalsModelNode::NotPopulated;

    if (hasChildren)

        q->endRemoveRows();

    deleteObjectSnapshots(snapshotIds);

}

void QScriptDebuggerLocalsModelPrivate::repopulate(QScriptDebuggerLocalsModelNode *node)

{

    if (node->populationState != QScriptDebuggerLocalsModelNode::Populated)

        return;

    depopulate(node);

    if (node->property.value().type() == QScriptDebuggerValue::ObjectValue)

        populateIndex(indexFromNode(node));

}

void QScriptDebuggerLocalsModelPrivate::addChildren(const QModelIndex &parentIndex,

                                                    QScriptDebuggerLocalsModelNode *parentNode,

                                                    const QScriptDebuggerValuePropertyList &props)

{

    Q_Q(QScriptDebuggerLocalsModel);

    if (props.isEmpty())

        return;

    int first = parentNode->children.size();

    int last = first + props.size() - 1;

    q->beginInsertRows(parentIndex, first, last);

    for (int i = 0; i < props.size(); ++i)

        new QScriptDebuggerLocalsModelNode(props.at(i), parentNode);

    q->endInsertRows();

}

void QScriptDebuggerLocalsModelPrivate::deleteObjectSnapshots(const QList<qint64> &snapshotIds)

{

    QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler, 0);

    for (int i = 0; i < snapshotIds.size(); ++i)

        frontend.scheduleDeleteScriptObjectSnapshot(snapshotIds.at(i));

}

void QScriptDebuggerLocalsModelPrivate::deleteAllObjectSnapshots()

{

    QList<qint64> snapshotIds;

    for (int i = 0; i < invisibleRootNode->children.count(); ++i)

        snapshotIds += findSnapshotIdsRecursively(invisibleRootNode->children.at(i));

    deleteObjectSnapshots(snapshotIds);

}

QScriptDebuggerLocalsModelPrivate *QScriptDebuggerLocalsModelPrivate::get(QScriptDebuggerLocalsModel *q)

{

    return q->d_func();

}

namespace {

class SetPropertyJob : public QScriptDebuggerCommandSchedulerJob

{

public:

    SetPropertyJob(const QPersistentModelIndex &index,

                   const QString &expression,

                   QScriptDebuggerCommandSchedulerInterface *scheduler)

        : QScriptDebuggerCommandSchedulerJob(scheduler),

          m_index(index), m_expression(expression), m_state(0) {}

    QScriptDebuggerLocalsModelPrivate *model() const

    {

        if (!m_index.isValid())

            return 0;

        QAbstractItemModel *m = const_cast<QAbstractItemModel*>(m_index.model());

        QScriptDebuggerLocalsModel *lm = qobject_cast<QScriptDebuggerLocalsModel*>(m);

        return QScriptDebuggerLocalsModelPrivate::get(lm);

    }

    void start()

    {

        if (!m_index.isValid()) {

            // nothing to do, the node has been removed

            return;

        }

        QScriptDebuggerLocalsModelNode *node = model()->nodeFromIndex(m_index);

        QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

        frontend.scheduleEvaluate(model()->frameIndex, m_expression,

                                  QString::fromLatin1("set property '%0' (%1)")

                                  .arg(node->property.name())

                                  .arg(QDateTime::currentDateTime().toString()));

    }

    void handleResponse(const QScriptDebuggerResponse &, int)

    {

        switch (m_state) {

        case 0:

            hibernateUntilEvaluateFinished();

            ++m_state;

            break;

        case 1:

            finish();

            break;

        }

    }

    void evaluateFinished(const QScriptDebuggerValue &result)

    {

        if (!m_index.isValid()) {

            // nothing to do, the node has been removed

            return;

        }

        QScriptDebuggerLocalsModelNode *node = model()->nodeFromIndex(m_index);

        Q_ASSERT(node->parent != 0);

        QScriptDebuggerValue object = node->parent->property.value();

        QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

        frontend.scheduleSetScriptValueProperty(object, node->property.name(), result);

    }

private:

    QPersistentModelIndex m_index;

    QString m_expression;

    int m_state;

};

} // namespace

QScriptDebuggerLocalsModelNode *QScriptDebuggerLocalsModelPrivate::nodeFromIndex(

    const QModelIndex &index) const

{

    if (!index.isValid())

        return invisibleRootNode;

    return static_cast<QScriptDebuggerLocalsModelNode*>(index.internalPointer());

}

QModelIndex QScriptDebuggerLocalsModelPrivate::indexFromNode(

    QScriptDebuggerLocalsModelNode *node) const

{

    if (!node || (node == invisibleRootNode))

        return QModelIndex();

    QScriptDebuggerLocalsModelNode *par = node->parent;

    int row = par ? par->children.indexOf(node) : 0;

    return createIndex(row, 0, node);

}

bool QScriptDebuggerLocalsModelPrivate::isTopLevelNode(QScriptDebuggerLocalsModelNode *node) const

{

    return node && (node->parent == invisibleRootNode);

}

namespace {

class PopulateModelIndexJob : public QScriptDebuggerCommandSchedulerJob

{

public:

    PopulateModelIndexJob(const QPersistentModelIndex &index,

                          QScriptDebuggerCommandSchedulerInterface *scheduler)

        : QScriptDebuggerCommandSchedulerJob(scheduler),

          m_index(index), m_state(0)

    { }

    QScriptDebuggerLocalsModelPrivate *model() const

    {

        if (!m_index.isValid())

            return 0;

        QAbstractItemModel *m = const_cast<QAbstractItemModel*>(m_index.model());

        QScriptDebuggerLocalsModel *lm = qobject_cast<QScriptDebuggerLocalsModel*>(m);

        return QScriptDebuggerLocalsModelPrivate::get(lm);

    }

    void start()

    {

        if (!m_index.isValid()) {

            // nothing to do, the node has been removed

            return;

        }

        QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

        frontend.scheduleNewScriptObjectSnapshot();

    }

    void handleResponse(const QScriptDebuggerResponse &response,

                        int)

    {

        if (!m_index.isValid()) {

            // the node has been removed

            finish();

            return;

        }

        switch (m_state) {

        case 0: {

            QScriptDebuggerLocalsModelNode *node = model()->nodeFromIndex(m_index);

            Q_ASSERT(node->populationState == QScriptDebuggerLocalsModelNode::Populating);

            node->snapshotId = response.resultAsInt();

            QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

            frontend.scheduleScriptObjectSnapshotCapture(node->snapshotId, node->property.value());

            ++m_state;

        }   break;

        case 1: {

            QScriptDebuggerObjectSnapshotDelta delta;

            delta = qvariant_cast<QScriptDebuggerObjectSnapshotDelta>(response.result());

            Q_ASSERT(delta.removedProperties.isEmpty());

            Q_ASSERT(delta.changedProperties.isEmpty());

            QScriptDebuggerValuePropertyList props = delta.addedProperties;

            model()->reallyPopulateIndex(m_index, props);

            finish();

          } break;

        }

    }

private:

    QPersistentModelIndex m_index;

    int m_state;

};

} // namespace

void QScriptDebuggerLocalsModelPrivate::populateIndex(

    const QModelIndex &index)

{

    if (!index.isValid())

        return;

    QScriptDebuggerLocalsModelNode *node = nodeFromIndex(index);

    if (node->populationState != QScriptDebuggerLocalsModelNode::NotPopulated)

        return;

    if (node->property.value().type() != QScriptDebuggerValue::ObjectValue)

        return;

    node->populationState = QScriptDebuggerLocalsModelNode::Populating;

    QScriptDebuggerJob *job = new PopulateModelIndexJob(index, commandScheduler);

    jobScheduler->scheduleJob(job);

}

void QScriptDebuggerLocalsModelPrivate::reallyPopulateIndex(

    const QModelIndex &index,

    const QScriptDebuggerValuePropertyList &props)

{

    if (!index.isValid())

        return;

    QScriptDebuggerLocalsModelNode *node = nodeFromIndex(index);

    Q_ASSERT(node->populationState == QScriptDebuggerLocalsModelNode::Populating);

    node->populationState = QScriptDebuggerLocalsModelNode::Populated;

    addChildren(index, node, props);

}

QScriptDebuggerLocalsModel::QScriptDebuggerLocalsModel(

    QScriptDebuggerJobSchedulerInterface *jobScheduler,

    QScriptDebuggerCommandSchedulerInterface *commandScheduler,

    QObject *parent)

    : QAbstractItemModel(*new QScriptDebuggerLocalsModelPrivate, parent)

{

    Q_D(QScriptDebuggerLocalsModel);

    d->jobScheduler = jobScheduler;

    d->commandScheduler = commandScheduler;

}

QScriptDebuggerLocalsModel::~QScriptDebuggerLocalsModel()

{

}

QModelIndex QScriptDebuggerLocalsModelPrivate::addTopLevelObject(const QString &name, const QScriptDebuggerValue &object)

{

    Q_Q(QScriptDebuggerLocalsModel);

    QScriptDebuggerLocalsModelNode *node = invisibleRootNode->findChild(name);

    if (node)

        return indexFromNode(node);

    QScriptDebuggerValueProperty prop(name, object,

                                      QString::fromLatin1(""), // ### string representation of object

                                      /*flags=*/0);

    int rowIndex = invisibleRootNode->children.size();

    q->beginInsertRows(QModelIndex(), rowIndex, rowIndex);

    node = new QScriptDebuggerLocalsModelNode(prop, invisibleRootNode);

    q->endInsertRows();

    return indexFromNode(node);

}

namespace {

class InitModelJob : public QScriptDebuggerCommandSchedulerJob

{

public:

    InitModelJob(QScriptDebuggerLocalsModelPrivate *model,

                 int frameIndex,

                 QScriptDebuggerCommandSchedulerInterface *scheduler)

        : QScriptDebuggerCommandSchedulerJob(scheduler),

          m_model(model), m_frameIndex(frameIndex), m_state(0)

    { }

    void start()

    {

        QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

        frontend.scheduleGetScopeChain(m_frameIndex);

    }

    void handleResponse(const QScriptDebuggerResponse &response,

                        int)

    {

        QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

        switch (m_state) {

        case 0: {

            QScriptDebuggerValueList scopeChain = response.resultAsScriptValueList();

            for (int i = 0; i < scopeChain.size(); ++i) {

                const QScriptDebuggerValue &scopeObject = scopeChain.at(i);

                QString name = QString::fromLatin1("Scope");

                if (i > 0)

                    name.append(QString::fromLatin1(" (%0)").arg(i));

                QModelIndex index = m_model->addTopLevelObject(name, scopeObject);

                if (i == 0)

                    m_model->emitScopeObjectAvailable(index);

            }

            frontend.scheduleGetThisObject(m_frameIndex);

            ++m_state;

        }   break;

        case 1: {

            QScriptDebuggerValue thisObject = response.resultAsScriptValue();

            m_model->addTopLevelObject(QLatin1String("this"), thisObject);

            finish();

          } break;

        }

    }

private:

    QScriptDebuggerLocalsModelPrivate *m_model;

    int m_frameIndex;

    int m_state;

};

} // namespace

void QScriptDebuggerLocalsModel::init(int frameIndex)

{

    Q_D(QScriptDebuggerLocalsModel);