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

**

** 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 QtDeclarative 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 "private/qdeclarativexmllistmodel_p.h"

#include <qdeclarativecontext.h>

#include <qdeclarativeengine_p.h>

#include <QDebug>

#include <QStringList>

#include <QQueue>

#include <QApplication>

#include <QThread>

#include <QMutex>

#include <QWaitCondition>

#include <QXmlQuery>

#include <QXmlResultItems>

#include <QXmlNodeModelIndex>

#include <QBuffer>

#include <QNetworkRequest>

#include <QNetworkReply>

#include <QTimer>

#include <private/qobject_p.h>

Q_DECLARE_METATYPE(QDeclarativeXmlQueryResult)

QT_BEGIN_NAMESPACE

typedef QPair<int, int> QDeclarativeXmlListRange;

#define XMLLISTMODEL_CLEAR_ID 0

/*!

    \qmlclass XmlRole QDeclarativeXmlListModelRole

  \since 4.7

    \brief The XmlRole element allows you to specify a role for an XmlListModel.

    \sa {QtDeclarative}

*/

/*!

    \qmlproperty string XmlRole::name

    The name for the role. This name is used to access the model data for this role from Qml.

    \qml

    XmlListModel {

        id: xmlModel

        ...

        XmlRole { name: "title"; query: "title/string()" }

    }

    ListView {

        model: xmlModel

        Text { text: title }

    }

    \endqml

*/

/*!

    \qmlproperty string XmlRole::query

    The relative XPath query for this role. The query should not start with a '/' (i.e. it must be

    relative).

    \qml

    XmlRole { name: "title"; query: "title/string()" }

    \endqml

*/

/*!

    \qmlproperty bool XmlRole::isKey

    Defines whether this is a key role.

    Key roles are used to to determine whether a set of values should

    be updated or added to the XML list model when XmlListModel::reload()

    is called.

    \sa XmlListModel

*/

struct XmlQueryJob

{

    int queryId;

    QByteArray data;

    QString query;

    QString namespaces;

    QStringList roleQueries;

    QList<void*> roleQueryErrorId; // the ptr to send back if there is an error

    QStringList keyRoleQueries;

    QStringList keyRoleResultsCache;

};

class QDeclarativeXmlQuery : public QThread

{

    Q_OBJECT

public:

    QDeclarativeXmlQuery(QObject *parent=0)

        : QThread(parent), m_quit(false), m_abortQueryId(-1), m_queryIds(XMLLISTMODEL_CLEAR_ID + 1) {

        qRegisterMetaType<QDeclarativeXmlQueryResult>("QDeclarativeXmlQueryResult");

    }

    ~QDeclarativeXmlQuery() {

        m_mutex.lock();

        m_quit = true;

        m_condition.wakeOne();

        m_mutex.unlock();

        wait();

    }

    void abort(int id) {

        QMutexLocker locker(&m_mutex);

        m_abortQueryId = id;

    }

    int doQuery(QString query, QString namespaces, QByteArray data, QList<QDeclarativeXmlListModelRole *> *roleObjects, QStringList keyRoleResultsCache) {

        QMutexLocker locker(&m_mutex);

        XmlQueryJob job;

        job.queryId = m_queryIds;

        job.data = data;

        job.query = QLatin1String("doc($src)") + query;

        job.namespaces = namespaces;

        job.keyRoleResultsCache = keyRoleResultsCache;

        for (int i=0; i<roleObjects->count(); i++) {

            if (!roleObjects->at(i)->isValid()) {

                job.roleQueries << QString();

                continue;

            }

            job.roleQueries << roleObjects->at(i)->query();

            job.roleQueryErrorId << static_cast<void*>(roleObjects->at(i));

            if (roleObjects->at(i)->isKey())

                job.keyRoleQueries << job.roleQueries.last();

        }

        m_jobs.enqueue(job);

        m_queryIds++;

        if (!isRunning())

            start();

        else

            m_condition.wakeOne();

        return job.queryId;

    }

Q_SIGNALS:

    void queryCompleted(const QDeclarativeXmlQueryResult &);

    void error(void*, const QString&);

protected:

    void run() {

        while (!m_quit) {

            m_mutex.lock();

            doQueryJob();

            doSubQueryJob();

            m_mutex.unlock();

            m_mutex.lock();

            const XmlQueryJob &job = m_jobs.dequeue();

            if (m_abortQueryId != job.queryId) {

                QDeclarativeXmlQueryResult r;

                r.queryId = job.queryId;

                r.size = m_size;

                r.data = m_modelData;

                r.inserted = m_insertedItemRanges;

                r.removed = m_removedItemRanges;

                r.keyRoleResultsCache = job.keyRoleResultsCache;

                emit queryCompleted(r);

            }

            if (m_jobs.isEmpty())

                m_condition.wait(&m_mutex);

            m_abortQueryId = -1;

            m_mutex.unlock();

        }

    }

private:

    void doQueryJob();

    void doSubQueryJob();

    void getValuesOfKeyRoles(QStringList *values, QXmlQuery *query) const;

    void addIndexToRangeList(QList<QDeclarativeXmlListRange> *ranges, int index) const;

private:

    QMutex m_mutex;

    QWaitCondition m_condition;

    QQueue<XmlQueryJob> m_jobs;

    bool m_quit;

    int m_abortQueryId;

    QString m_prefix;

    int m_size;

    int m_queryIds;

    QList<QList<QVariant> > m_modelData;

    QList<QDeclarativeXmlListRange> m_insertedItemRanges;

    QList<QDeclarativeXmlListRange> m_removedItemRanges;

};

Q_GLOBAL_STATIC(QDeclarativeXmlQuery, globalXmlQuery)

void QDeclarativeXmlQuery::doQueryJob()

{

    Q_ASSERT(!m_jobs.isEmpty());

    XmlQueryJob &job = m_jobs.head();

    QString r;

    QXmlQuery query;

    QBuffer buffer(&job.data);

    buffer.open(QIODevice::ReadOnly);

    query.bindVariable(QLatin1String("src"), &buffer);

    query.setQuery(job.namespaces + job.query);

    query.evaluateTo(&r);

    //always need a single root element

    QByteArray xml = "<dummy:items xmlns:dummy=\"http://qtsotware.com/dummy\">\n" + r.toUtf8() + "</dummy:items>";

    QBuffer b(&xml);

    b.open(QIODevice::ReadOnly);

    QString namespaces = QLatin1String("declare namespace dummy=\"http://qtsotware.com/dummy\";\n") + job.namespaces;

    QString prefix = QLatin1String("doc($inputDocument)/dummy:items") +

                     job.query.mid(job.query.lastIndexOf(QLatin1Char('/')));

    //figure out how many items we are dealing with

    int count = -1;

    {

        QXmlResultItems result;

        QXmlQuery countquery;

        countquery.bindVariable(QLatin1String("inputDocument"), &b);

        countquery.setQuery(namespaces + QLatin1String("count(") + prefix + QLatin1Char(')'));

        countquery.evaluateTo(&result);

        QXmlItem item(result.next());

        if (item.isAtomicValue())

            count = item.toAtomicValue().toInt();

    }

    job.data = xml;

    m_prefix = namespaces + prefix + QLatin1Char('/');

    m_size = 0;

    if (count > 0)

        m_size = count;

}

void QDeclarativeXmlQuery::getValuesOfKeyRoles(QStringList *values, QXmlQuery *query) const

{

    Q_ASSERT(!m_jobs.isEmpty());

    const QStringList &keysQueries = m_jobs.head().keyRoleQueries;

    QString keysQuery;

    if (keysQueries.count() == 1)

        keysQuery = m_prefix + keysQueries[0];

    else if (keysQueries.count() > 1)

        keysQuery = m_prefix + QLatin1String("concat(") + keysQueries.join(QLatin1String(",")) + QLatin1String(")");

    if (!keysQuery.isEmpty()) {

        query->setQuery(keysQuery);

        QXmlResultItems resultItems;

        query->evaluateTo(&resultItems);

        QXmlItem item(resultItems.next());

        while (!item.isNull()) {

            values->append(item.toAtomicValue().toString());

            item = resultItems.next();

        }

    }

}

void QDeclarativeXmlQuery::addIndexToRangeList(QList<QDeclarativeXmlListRange> *ranges, int index) const {

    if (ranges->isEmpty())

        ranges->append(qMakePair(index, 1));

    else if (ranges->last().first + ranges->last().second == index)

        ranges->last().second += 1;

    else

        ranges->append(qMakePair(index, 1));

}

void QDeclarativeXmlQuery::doSubQueryJob()

{

    Q_ASSERT(!m_jobs.isEmpty());

    XmlQueryJob &job = m_jobs.head();

    m_modelData.clear();

    QBuffer b(&job.data);

    b.open(QIODevice::ReadOnly);

    QXmlQuery subquery;

    subquery.bindVariable(QLatin1String("inputDocument"), &b);

    QStringList keyRoleResults;

    getValuesOfKeyRoles(&keyRoleResults, &subquery);

    // See if any values of key roles have been inserted or removed.

    m_insertedItemRanges.clear();

    m_removedItemRanges.clear();

    if (job.keyRoleResultsCache.isEmpty()) {

        m_insertedItemRanges << qMakePair(0, m_size);

    } else {

        if (keyRoleResults != job.keyRoleResultsCache) {

            QStringList temp;

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

                if (!keyRoleResults.contains(job.keyRoleResultsCache[i]))

                    addIndexToRangeList(&m_removedItemRanges, i);

                else 

                    temp << job.keyRoleResultsCache[i];

            }

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

                if (temp.count() == i || keyRoleResults[i] != temp[i]) {

                    temp.insert(i, keyRoleResults[i]);

                    addIndexToRangeList(&m_insertedItemRanges, i);

                }

            }

        }

    }

    job.keyRoleResultsCache = keyRoleResults;

    // Get the new values for each role.

    //### we might be able to condense even further (query for everything in one go)

    const QStringList &queries = job.roleQueries;

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

        QList<QVariant> resultList;

        if (!queries[i].isEmpty()) {

            subquery.setQuery(m_prefix + QLatin1String("(let $v := ") + queries[i] + QLatin1String(" return if ($v) then ") + queries[i] + QLatin1String(" else \"\")"));

            if (subquery.isValid()) {

                QXmlResultItems resultItems;

                subquery.evaluateTo(&resultItems);

                QXmlItem item(resultItems.next());

                while (!item.isNull()) {

                    resultList << item.toAtomicValue(); //### we used to trim strings

                    item = resultItems.next();

                }

            } else {

                emit error(job.roleQueryErrorId.at(i), queries[i]);

            }

        }

        //### should warn here if things have gone wrong.

        while (resultList.count() < m_size)

            resultList << QVariant();

        m_modelData << resultList;

        b.seek(0);

    }

    //this method is much slower, but works better for incremental loading

    /*for (int j = 0; j < m_size; ++j) {

        QList<QVariant> resultList;

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

            QDeclarativeXmlListModelRole *role = m_roleObjects->at(i);

            subquery.setQuery(m_prefix.arg(j+1) + role->query());

            if (role->isStringList()) {

                QStringList data;

                subquery.evaluateTo(&data);

                resultList << QVariant(data);

                //qDebug() << data;

            } else {

                QString s;

                subquery.evaluateTo(&s);

                if (role->isCData()) {

                    //un-escape

                    s.replace(QLatin1String("&lt;"), QLatin1String("<"));

                    s.replace(QLatin1String(">"), QLatin1String(">"));

                    s.replace(QLatin1String("&"), QLatin1String("&"));

                }

                resultList << s.trimmed();

                //qDebug() << s;

            }

            b.seek(0);

        }

        m_modelData << resultList;

    }*/

}

class QDeclarativeXmlListModelPrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeXmlListModel)

public:

    QDeclarativeXmlListModelPrivate()

        : isComponentComplete(true), size(-1), highestRole(Qt::UserRole)

        , reply(0), status(QDeclarativeXmlListModel::Null), progress(0.0)

        , queryId(-1), roleObjects(), redirectCount(0) {}

    void notifyQueryStarted(bool remoteSource) {

        Q_Q(QDeclarativeXmlListModel);

        progress = remoteSource ? 0.0 : 1.0;

        status = QDeclarativeXmlListModel::Loading;

        errorString.clear();

        emit q->progressChanged(progress);

        emit q->statusChanged(status);

    }

    bool isComponentComplete;

    QUrl src;

    QString xml;

    QString query;

    QString namespaces;

    int size;

    QList<int> roles;

    QStringList roleNames;

    int highestRole;

    QNetworkReply *reply;

    QDeclarativeXmlListModel::Status status;

    QString errorString;

    qreal progress;

    int queryId;

    QStringList keyRoleResultsCache;

    QList<QDeclarativeXmlListModelRole *> roleObjects;

    static void append_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list, QDeclarativeXmlListModelRole *role);

    static void clear_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list);

    static void removeAt_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list, int i);

    static void insert_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list, int i, QDeclarativeXmlListModelRole *role);

    QList<QList<QVariant> > data;

    int redirectCount;

};

void QDeclarativeXmlListModelPrivate::append_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list, QDeclarativeXmlListModelRole *role)

{

    QDeclarativeXmlListModel *_this = qobject_cast<QDeclarativeXmlListModel *>(list->object);

    if (_this) {

        int i = _this->d_func()->roleObjects.count();

        _this->d_func()->roleObjects.append(role);

        if (_this->d_func()->roleNames.contains(role->name())) {

            qmlInfo(role) << QObject::tr("\"%1\" duplicates a previous role name and will be disabled.").arg(role->name());

            return;

        }

        _this->d_func()->roles.insert(i, _this->d_func()->highestRole);

        _this->d_func()->roleNames.insert(i, role->name());

        ++_this->d_func()->highestRole;

    }

}

//### clear needs to invalidate any cached data (in data table) as well

//    (and the model should emit the appropriate signals)

void QDeclarativeXmlListModelPrivate::clear_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list)

{

    QDeclarativeXmlListModel *_this = static_cast<QDeclarativeXmlListModel *>(list->object);

    _this->d_func()->roles.clear();

    _this->d_func()->roleNames.clear();

    _this->d_func()->roleObjects.clear();

}

/*!

    \class QDeclarativeXmlListModel

    \internal

*/

/*!

    \qmlclass XmlListModel QDeclarativeXmlListModel

  \since 4.7

    \brief The XmlListModel element is used to specify a model using XPath expressions.

    XmlListModel is used to create a model from XML data. XmlListModel can be used as a data source

    for the view classes (such as ListView, PathView, GridView) and other classes that interact with model

    data (such as \l Repeater).

    For example, if there is a XML document at http://www.mysite.com/feed.xml like this:

    \code

    <?xml version="1.0" encoding="utf-8"?>

    <rss version="2.0">

        ...

        <channel>

            <item>

                <title>Item A</title>

                <pubDate>Sat, 07 Sep 2010 10:00:01 GMT</pubDate>

            </item>

            <item>

                <title>Item B</title>

                <pubDate>Sat, 07 Sep 2010 15:35:01 GMT</pubDate>

            </item>

        </channel>

    </rss>

    \endcode

    A XmlListModel could create a model from this data, like this:

    \qml

    XmlListModel {

        id: xmlModel

        source: "http://www.mysite.com/feed.xml"

        query: "/rss/channel/item"

        XmlRole { name: "title"; query: "title/string()" }

        XmlRole { name: "pubDate"; query: "pubDate/string()" }

    }

    \endqml

    The \l {XmlListModel::query}{query} value of "/rss/channel/item" specifies that the XmlListModel should generate

    a model item for each \c <item> in the XML document. The XmlRole objects define the

    model item attributes; here, each model item will have \c title and \c pubDate 

    attributes that match the \c title and \c pubDate values of its corresponding \c <item>.

    The model could be used in a ListView, like this: