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

**

** 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 test suite 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 <QFile>

#include <QStack>

#ifdef QTEST_XMLPATTERNS

#include <QXmlNamePool>

#include <QXmlStreamReader>

#include <QtDebug>

#include <QTest>

#include "LoadingModel.h"

LoadingModel::LoadingModel(const Node::Vector &content,

                           const QXmlNamePool &np) : QSimpleXmlNodeModel(np)

                                                   , m_nodes(content)

{

    Q_ASSERT(!content.isEmpty());

    /*

    foreach(const Node *n, content)

        qDebug() << "this:" << n

                 << "kind:" << n->kind

                 << "parent: " << n->parent

                 << "preceding: " << n->precedingSibling

                 << "following: " << n->followingSibling

                 << "firstChild: " << n->firstChild

                 << "value: " << n->value;

                 */

}

LoadingModel::~LoadingModel()

{

     qDeleteAll(m_nodes);

}

const LoadingModel::Node *LoadingModel::toInternal(const QXmlNodeModelIndex &ni) const

{

    return static_cast<const Node *>(ni.internalPointer());

}

QXmlNodeModelIndex LoadingModel::createIndex(const Node *const internal) const

{

    Q_ASSERT_X(internal, Q_FUNC_INFO,

               "We shouldn't construct from null pointers.");

    return QAbstractXmlNodeModel::createIndex(const_cast<Node *>(internal));

}

QUrl LoadingModel::documentUri(const QXmlNodeModelIndex &) const

{

    Q_ASSERT(false);

    return QUrl();

}

QXmlNodeModelIndex::NodeKind LoadingModel::kind(const QXmlNodeModelIndex &ni) const

{

    Q_ASSERT(!ni.isNull());

    return toInternal(ni)->kind;

}

QXmlNodeModelIndex::DocumentOrder LoadingModel::compareOrder(const QXmlNodeModelIndex &n1, const QXmlNodeModelIndex &n2) const

{

    const Node *const in1 = toInternal(n1);

    const Node *const in2 = toInternal(n2);

    Q_ASSERT(m_nodes.indexOf(in1) != -1);

    Q_ASSERT(m_nodes.indexOf(in2) != -1);

    if(in1 == in2)

        return QXmlNodeModelIndex::Is;

    else if(m_nodes.indexOf(in1) < m_nodes.indexOf(in2))

        return QXmlNodeModelIndex::Precedes;

    else

        return QXmlNodeModelIndex::Follows;

}

QXmlNodeModelIndex LoadingModel::root(const QXmlNodeModelIndex &) const

{

    Q_ASSERT(kind(createIndex(m_nodes.first())) == QXmlNodeModelIndex::Document);

    return createIndex(m_nodes.first());

}

QXmlName LoadingModel::name(const QXmlNodeModelIndex &ni) const

{

    return toInternal(ni)->name;

}

QVariant LoadingModel::typedValue(const QXmlNodeModelIndex &ni) const

{

    const Node *const internal = toInternal(ni);

    Q_ASSERT(internal->kind == QXmlNodeModelIndex::Attribute

             || internal->kind == QXmlNodeModelIndex::Element);

    return internal->value;

}

QString LoadingModel::stringValue(const QXmlNodeModelIndex &ni) const

{

    const Node *const internal = toInternal(ni);

    switch(internal->kind)

    {

        case QXmlNodeModelIndex::Text:

        /* Fallthrough. */

        case QXmlNodeModelIndex::ProcessingInstruction:

        /* Fallthrough. */

        case QXmlNodeModelIndex::Comment:

        /* Fallthrough. */

        case QXmlNodeModelIndex::Attribute:

            return internal->value;

        default:

            return QString();

    }

}

QXmlNodeModelIndex LoadingModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis axis,

                                                    const QXmlNodeModelIndex &ni) const

{

    const Node *const internal = toInternal(ni);

    /* Note that a QXmlNodeModelIndex containing a null pointer is not a null node. */

    switch(axis)

    {

        case Parent:

            return internal->parent ? createIndex(internal->parent) : QXmlNodeModelIndex();

        case FirstChild:

            return internal->firstChild ? createIndex(internal->firstChild) : QXmlNodeModelIndex();

        case PreviousSibling:

            return internal->precedingSibling ? createIndex(internal->precedingSibling) : QXmlNodeModelIndex();

        case NextSibling:

            return internal->followingSibling ? createIndex(internal->followingSibling) : QXmlNodeModelIndex();

    }

    Q_ASSERT(false);

    return QXmlNodeModelIndex();

}

QVector<QXmlNodeModelIndex> LoadingModel::attributes(const QXmlNodeModelIndex &ni) const

{

    QVector<QXmlNodeModelIndex> retval;

    foreach(const Node *n, toInternal(ni)->attributes)

        retval.append(createIndex(n));

    return retval;

}

class Loader

{

public:

    inline Loader(const QXmlNamePool &namePool) : m_namePool(namePool)

                                                , m_currentNode(0)

    {

        m_parentStack.push(0);

    }

private:

    inline void adjustSiblings(LoadingModel::Node *const justBorn);

    friend class LoadingModel;

    Q_DISABLE_COPY(Loader);

    void load();

    QXmlNamePool                        m_namePool;

    QXmlStreamReader                    m_reader;

    LoadingModel::Node::Vector          m_result;

    LoadingModel::Node *                m_currentNode;

    QStack<LoadingModel::Node *>        m_parentStack;

};

inline void Loader::adjustSiblings(LoadingModel::Node *const justBorn)

{

    if(m_currentNode)

    {

        if(m_currentNode->parent == justBorn->parent)

            justBorn->precedingSibling = m_currentNode;

        m_currentNode->followingSibling = justBorn;

    }

    m_currentNode = justBorn;

    /* Otherwise we're the first child, and our precedingSibling should remain null. */

    if(m_parentStack.top() && !m_parentStack.top()->firstChild)

        m_parentStack.top()->firstChild = justBorn;

}

void Loader::load()

{

    QFile in(QLatin1String("tree.xml"));

    /* LoadingModel::m_result will be null, signalling failure. */

    if(!in.open(QIODevice::ReadOnly))

        return;

    QXmlStreamReader reader(&in);

    while(!reader.atEnd())

    {

        reader.readNext();

        switch(reader.tokenType())

        {

            case QXmlStreamReader::StartDocument:

            /* Fallthrough. */

            case QXmlStreamReader::StartElement:

            {

                QXmlName name;

                if(reader.tokenType() == QXmlStreamReader::StartElement)

                {

                    name = QXmlName(m_namePool,

                                    reader.name().toString(),

                                    reader.namespaceUri().toString(),

                                    reader.prefix().toString());

                }

                /* Else, the name is null. */

                LoadingModel::Node *const tmp = new LoadingModel::Node(reader.tokenType() == QXmlStreamReader::StartElement

                                                                       ? QXmlNodeModelIndex::Element

                                                                       : QXmlNodeModelIndex::Document,

                                                                       m_parentStack.top(),

                                                                       QString(),

                                                                       name);

                m_result.append(tmp);

                if(m_currentNode)

                {

                    if(m_currentNode->parent == m_parentStack.top())

                        m_currentNode->followingSibling = tmp;

                }

                const QXmlStreamAttributes attributes(reader.attributes());

                const int len = attributes.count();

                for(int i = 0; i < len; ++i)

                {

                    const QXmlStreamAttribute &attr = attributes.at(i);

                    const LoadingModel::Node *const a = new LoadingModel::Node(QXmlNodeModelIndex::Attribute,

                                                                               m_parentStack.top(),

                                                                               attr.value().toString(),

                                                                               QXmlName(m_namePool,

                                                                                       attr.name().toString(),

                                                                                       attr.namespaceUri().toString(),

                                                                                       attr.prefix().toString()));

                    /* We add it also to m_result such that compareOrder() is correct

                     * for attributes. m_result owns a. */

                    tmp->attributes.append(a);

                    m_result.append(a);

                }

                adjustSiblings(tmp);

                m_parentStack.push(m_currentNode);

                break;

            }

            case QXmlStreamReader::EndDocument:

            /* Fallthrough. */

            case QXmlStreamReader::EndElement:

            {

                m_currentNode->followingSibling = 0;

                m_currentNode = m_parentStack.pop();

                if(reader.tokenType() == QXmlStreamReader::EndDocument)

                    const_cast<LoadingModel::Node *>(m_result.first())->followingSibling = 0;

                break;

            }

            case QXmlStreamReader::Characters:

            {

                LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::Text, m_parentStack.top(), reader.text().toString());

                m_result.append(tmp);

                adjustSiblings(tmp);

                break;

            }

            case QXmlStreamReader::ProcessingInstruction:

            {

                LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::ProcessingInstruction,

                                                                       m_parentStack.top(),

                                                                       reader.processingInstructionData().toString(),

                                                                       QXmlName(m_namePool, reader.processingInstructionTarget().toString()));

                m_result.append(tmp);

                adjustSiblings(tmp);

                break;

            }

            case QXmlStreamReader::Comment:

            {

                LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::Comment, m_parentStack.top(), reader.text().toString());

                m_result.append(tmp);

                adjustSiblings(tmp);

                break;

            }

            case QXmlStreamReader::DTD:

            /* Fallthrough. */

            case QXmlStreamReader::EntityReference:

            {

                Q_ASSERT_X(false, Q_FUNC_INFO,

                           "We don't support this.");

                /* Fallthrough. */

            }

            case QXmlStreamReader::NoToken:

            /* Fallthrough. */

            case QXmlStreamReader::Invalid:

            {

                qWarning(qPrintable(reader.errorString()));

                m_result.clear();

                return;

            }

        }

    }

    if(reader.hasError())

    {

        qWarning(qPrintable(reader.errorString()));

        m_result.clear();

    }

}

QAbstractXmlNodeModel::Ptr LoadingModel::create(const QXmlNamePool &np)

{

    Loader loader(np);

    loader.load();

    return Ptr(new LoadingModel(loader.m_result, np));

}

#endif //QTEST_XMLPATTERNS