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

**

** 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/qdeclarativexmlhttprequest_p.h"

#include "qdeclarativeengine.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativerefcount_p.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativeexpression_p.h"

#include "qdeclarativeglobal_p.h"

#include <QtCore/qobject.h>

#include <QtScript/qscriptvalue.h>

#include <QtScript/qscriptcontext.h>

#include <QtScript/qscriptengine.h>

#include <QtNetwork/qnetworkreply.h>

#include <QtCore/qtextcodec.h>

#include <QtCore/qxmlstream.h>

#include <QtCore/qstack.h>

#include <QtCore/qdebug.h>

// From DOM-Level-3-Core spec

// http://www.w3.org/TR/DOM-Level-3-Core/core.html

#define INDEX_SIZE_ERR 1

#define DOMSTRING_SIZE_ERR 2

#define HIERARCHY_REQUEST_ERR 3

#define WRONG_DOCUMENT_ERR 4

#define INVALID_CHARACTER_ERR 5

#define NO_DATA_ALLOWED_ERR 6

#define NO_MODIFICATION_ALLOWED_ERR 7

#define NOT_FOUND_ERR 8

#define NOT_SUPPORTED_ERR 9

#define INUSE_ATTRIBUTE_ERR 10

#define INVALID_STATE_ERR 11

#define SYNTAX_ERR 12

#define INVALID_MODIFICATION_ERR 13

#define NAMESPACE_ERR 14

#define INVALID_ACCESS_ERR 15

#define VALIDATION_ERR 16

#define TYPE_MISMATCH_ERR 17

#define THROW_DOM(error, desc) \

{ \

    QScriptValue errorValue = context->throwError(QLatin1String(desc)); \

    errorValue.setProperty(QLatin1String("code"), error); \

    return errorValue; \

} 

#define THROW_SYNTAX(desc) \

    return context->throwError(QScriptContext::SyntaxError, QLatin1String(desc));

#define THROW_REFERENCE(desc) \

    return context->throwError(QScriptContext::ReferenceError, QLatin1String(desc));

#define D(arg) (arg)->release()

#define A(arg) (arg)->addref()

QT_BEGIN_NAMESPACE

DEFINE_BOOL_CONFIG_OPTION(xhrDump, QML_XHR_DUMP);

class DocumentImpl;

class NodeImpl 

{

public:

    NodeImpl() : type(Element), document(0), parent(0) {}

    virtual ~NodeImpl() { 

        for (int ii = 0; ii < children.count(); ++ii)

            delete children.at(ii);

        for (int ii = 0; ii < attributes.count(); ++ii)

            delete attributes.at(ii);

    }

    // These numbers are copied from the Node IDL definition

    enum Type { 

        Attr = 2, 

        CDATA = 4, 

        Comment = 8, 

        Document = 9, 

        DocumentFragment = 11, 

        DocumentType = 10,

        Element = 1, 

        Entity = 6, 

        EntityReference = 5,

        Notation = 12, 

        ProcessingInstruction = 7, 

        Text = 3

    };

    Type type;

    QString namespaceUri;

    QString name;

    QString data;

    void addref();

    void release();

    DocumentImpl *document;

    NodeImpl *parent;

    QList<NodeImpl *> children;

    QList<NodeImpl *> attributes;

};

class DocumentImpl : public QDeclarativeRefCount, public NodeImpl

{

public:

    DocumentImpl() : root(0) { type = Document; }

    virtual ~DocumentImpl() {

        if (root) delete root;

    }

    QString version;

    QString encoding;

    bool isStandalone;

    NodeImpl *root;

    void addref() { QDeclarativeRefCount::addref(); }

    void release() { QDeclarativeRefCount::release(); }

};

class NamedNodeMap

{

public:

    // JS API

    static QScriptValue length(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

    static QScriptValue create(QScriptEngine *, NodeImpl *, QList<NodeImpl *> *);

    NamedNodeMap();

    NamedNodeMap(const NamedNodeMap &);

    ~NamedNodeMap();

    bool isNull();

    NodeImpl *d;

    QList<NodeImpl *> *list;

private:

    NamedNodeMap &operator=(const NamedNodeMap &);

};

class NamedNodeMapClass : public QScriptClass

{

public:

    NamedNodeMapClass(QScriptEngine *engine) : QScriptClass(engine) {}

    virtual QueryFlags queryProperty(const QScriptValue &object, const QScriptString &name, QueryFlags flags, uint *id);

    virtual QScriptValue property(const QScriptValue &object, const QScriptString &name, uint id);

};

class NodeList 

{

public:

    // JS API

    static QScriptValue length(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

    static QScriptValue create(QScriptEngine *, NodeImpl *);

    NodeList();

    NodeList(const NodeList &);

    ~NodeList();

    bool isNull();

    NodeImpl *d;

private:

    NodeList &operator=(const NodeList &);

};

class NodeListClass : public QScriptClass

{

public:

    NodeListClass(QScriptEngine *engine) : QScriptClass(engine) {}

    virtual QueryFlags queryProperty(const QScriptValue &object, const QScriptString &name, QueryFlags flags, uint *id);

    virtual QScriptValue property(const QScriptValue &object, const QScriptString &name, uint id);

};

class Node

{

public:

    // JS API

    static QScriptValue nodeName(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue nodeValue(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue nodeType(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue parentNode(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue childNodes(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue firstChild(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue lastChild(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue previousSibling(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue nextSibling(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue attributes(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue ownerDocument(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue namespaceURI(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue prefix(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue localName(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue baseURI(QScriptContext *context, QScriptEngine *engine);

    //static QScriptValue textContent(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

    static QScriptValue create(QScriptEngine *, NodeImpl *);

    Node();

    Node(const Node &o);

    ~Node();

    bool isNull() const;

    NodeImpl *d;

private:

    Node &operator=(const Node &);

};

class Element : public Node

{

public:

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

};

class Attr : public Node

{

public:

    // JS API

    static QScriptValue name(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue specified(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue value(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue ownerElement(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue schemaTypeInfo(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue isId(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

};

class CharacterData : public Node

{

public:

    // JS API

    static QScriptValue length(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

};

class Text : public CharacterData

{

public:

    // JS API

    static QScriptValue isElementContentWhitespace(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue wholeText(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

};

class CDATA : public Text

{

public:

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

};

class Document : public Node

{

public:

    // JS API

    static QScriptValue xmlVersion(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue xmlEncoding(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue xmlStandalone(QScriptContext *context, QScriptEngine *engine);

    static QScriptValue documentElement(QScriptContext *context, QScriptEngine *engine);

    // C++ API

    static QScriptValue prototype(QScriptEngine *);

    static QScriptValue load(QScriptEngine *engine, const QByteArray &data);

};

QT_END_NAMESPACE

Q_DECLARE_METATYPE(Node)

Q_DECLARE_METATYPE(NodeList)

Q_DECLARE_METATYPE(NamedNodeMap)

QT_BEGIN_NAMESPACE

void NodeImpl::addref() 

{

    A(document);

}

void NodeImpl::release()

{

    D(document);

}

QScriptValue Node::nodeName(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    switch (node.d->type) {

    case NodeImpl::Document:

        return QScriptValue(QLatin1String("#document"));

    case NodeImpl::CDATA:

        return QScriptValue(QLatin1String("#cdata-section"));

    case NodeImpl::Text:

        return QScriptValue(QLatin1String("#text"));

    default:

        return QScriptValue(node.d->name);

    }

}

QScriptValue Node::nodeValue(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (node.d->type == NodeImpl::Document ||

        node.d->type == NodeImpl::DocumentFragment ||

        node.d->type == NodeImpl::DocumentType ||

        node.d->type == NodeImpl::Element ||

        node.d->type == NodeImpl::Entity ||

        node.d->type == NodeImpl::EntityReference ||

        node.d->type == NodeImpl::Notation)

        return engine->nullValue();

    return QScriptValue(node.d->data);

}

QScriptValue Node::nodeType(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    return QScriptValue(node.d->type);

}

QScriptValue Node::parentNode(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (node.d->parent) return Node::create(engine, node.d->parent);

    else return engine->nullValue();

}

QScriptValue Node::childNodes(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    return NodeList::create(engine, node.d);

}

QScriptValue Node::firstChild(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (node.d->children.isEmpty()) return engine->nullValue();

    else return Node::create(engine, node.d->children.first());

}

QScriptValue Node::lastChild(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (node.d->children.isEmpty()) return engine->nullValue();

    else return Node::create(engine, node.d->children.last());

}

QScriptValue Node::previousSibling(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (!node.d->parent) return engine->nullValue();

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

        if (node.d->parent->children.at(ii) == node.d) {

            if (ii == 0) return engine->nullValue();

            else return Node::create(engine, node.d->parent->children.at(ii - 1));

        }

    }

    return engine->nullValue();

}

QScriptValue Node::nextSibling(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (!node.d->parent) return engine->nullValue();

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

        if (node.d->parent->children.at(ii) == node.d) {

            if ((ii + 1) == node.d->parent->children.count()) return engine->nullValue();

            else return Node::create(engine, node.d->parent->children.at(ii + 1)); 

        }

    }

    return engine->nullValue();

}

QScriptValue Node::attributes(QScriptContext *context, QScriptEngine *engine)

{

    Node node = qscriptvalue_cast<Node>(context->thisObject());

    if (node.isNull()) return engine->undefinedValue();

    if (node.d->type != NodeImpl::Element)

        return engine->nullValue();

    else

        return NamedNodeMap::create(engine, node.d, &node.d->attributes);

}

QScriptValue Node::prototype(QScriptEngine *engine)

{

    QScriptValue proto = engine->newObject();

    proto.setProperty(QLatin1String("nodeName"), engine->newFunction(nodeName), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("nodeValue"), engine->newFunction(nodeValue), QScriptValue::ReadOnly | QScriptValue::PropertyGetter | QScriptValue::PropertySetter);

    proto.setProperty(QLatin1String("nodeType"), engine->newFunction(nodeType), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("parentNode"), engine->newFunction(parentNode), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("childNodes"), engine->newFunction(childNodes), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("firstChild"), engine->newFunction(firstChild), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("lastChild"), engine->newFunction(lastChild), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("previousSibling"), engine->newFunction(previousSibling), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("nextSibling"), engine->newFunction(nextSibling), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    proto.setProperty(QLatin1String("attributes"), engine->newFunction(attributes), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    return proto;

}

QScriptValue Node::create(QScriptEngine *engine, NodeImpl *data)

{

    QScriptValue instance = engine->newObject();

    switch (data->type) {

    case NodeImpl::Attr:

        instance.setPrototype(Attr::prototype(engine));

        break;

    case NodeImpl::Comment:

    case NodeImpl::Document:

    case NodeImpl::DocumentFragment:

    case NodeImpl::DocumentType:

    case NodeImpl::Entity:

    case NodeImpl::EntityReference:

    case NodeImpl::Notation:

    case NodeImpl::ProcessingInstruction:

        return QScriptValue();

    case NodeImpl::CDATA:

        instance.setPrototype(CDATA::prototype(engine));

        break;

    case NodeImpl::Text:

        instance.setPrototype(Text::prototype(engine));

        break;

    case NodeImpl::Element:

        instance.setPrototype(Element::prototype(engine));

        break;

    }

    Node node;

    node.d = data;

    if (data) A(data);

    return engine->newVariant(instance, qVariantFromValue(node));

}

QScriptValue Element::prototype(QScriptEngine *engine)

{

    QScriptValue proto = engine->newObject();

    proto.setPrototype(Node::prototype(engine));

    proto.setProperty(QLatin1String("tagName"), engine->newFunction(nodeName), QScriptValue::ReadOnly | QScriptValue::PropertyGetter);

    return proto;

}

QScriptValue Attr::prototype(QScriptEngine *engine)

{

    QScriptValue proto = engine->newObject();