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

**

** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the QtXmlPatterns 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 "qxsdvalidatinginstancereader_p.h"

#include "qabstractdatetime_p.h"

#include "qacceltreeresourceloader_p.h"

#include "qbase64binary_p.h"

#include "qboolean_p.h"

#include "qcommonnamespaces_p.h"

#include "qderivedinteger_p.h"

#include "qduration_p.h"

#include "qgenericstaticcontext_p.h"

#include "qhexbinary_p.h"

#include "qnamespaceresolver_p.h"

#include "qpatternplatform_p.h"

#include "qqnamevalue_p.h"

#include "qsourcelocationreflection_p.h"

#include "qvaluefactory_p.h"

#include "qxmlnamepool.h"

#include "qxmlquery_p.h"

#include "qxmlschema_p.h"

#include "qxsdschemahelper_p.h"

#include "qxsdschemamerger_p.h"

#include "qxsdstatemachine_p.h"

#include "qxsdstatemachinebuilder_p.h"

#include "qxsdtypechecker_p.h"

#include "qxsdschemadebugger_p.h"

#include <QtCore/QFile>

#include <QtXmlPatterns/QXmlQuery>

#include <QtXmlPatterns/QXmlResultItems>

QT_BEGIN_NAMESPACE

using namespace QPatternist;

namespace QPatternist

{

    template <>

    template <>

    bool XsdStateMachine<XsdTerm::Ptr>::inputEqualsTransition<QXmlName>(QXmlName name, XsdTerm::Ptr term) const

    {

        if (term->isElement()) {

            return (XsdElement::Ptr(term)->name(m_namePool) == name);

        } else if (term->isWildcard()) {

            // wildcards using XsdWildcard::absentNamespace, so we have to fix that here

            if (name.namespaceURI() == StandardNamespaces::empty) {

                name.setNamespaceURI(m_namePool->allocateNamespace(XsdWildcard::absentNamespace()));

            }

            return XsdSchemaHelper::wildcardAllowsExpandedName(name, XsdWildcard::Ptr(term), m_namePool);

        }

        return false;

    }

}

XsdValidatingInstanceReader::XsdValidatingInstanceReader(XsdValidatedXmlNodeModel *model, const QUrl &documentUri, const XsdSchemaContext::Ptr &context)

    : XsdInstanceReader(model, context)

    , m_model(model)

    , m_namePool(m_context->namePool())

    , m_xsiNilName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("nil")))

    , m_xsiTypeName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("type")))

    , m_xsiSchemaLocationName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("schemaLocation")))

    , m_xsiNoNamespaceSchemaLocationName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("noNamespaceSchemaLocation")))

    , m_documentUri(documentUri)

{

    m_idRefsType = m_context->schemaTypeFactory()->createSchemaType(m_namePool->allocateQName(CommonNamespaces::WXS, QLatin1String("IDREFS")));

}

void XsdValidatingInstanceReader::addSchema(const XsdSchema::Ptr &schema, const QUrl &locationUrl)

{

    if (!m_mergedSchemas.contains(locationUrl)) {

        m_mergedSchemas.insert(locationUrl, QStringList() << schema->targetNamespace());

    } else {

        QStringList &targetNamespaces = m_mergedSchemas[locationUrl];

        if (targetNamespaces.contains(schema->targetNamespace()))

            return;

        targetNamespaces.append(schema->targetNamespace());

    }

    const XsdSchemaMerger merger(m_schema, schema);

    m_schema = merger.mergedSchema();

/*

    XsdSchemaDebugger dbg(m_namePool);

    dbg.dumpSchema(m_schema);

*/

}

bool XsdValidatingInstanceReader::read()

{

    while (!atEnd()) {

        readNext();

        if (isEndElement())

            return true;

        if (isStartElement()) {

            const QXmlName elementName = name();

            const QXmlItem currentItem = item();

            bool hasStateMachine = false;

            XsdElement::Ptr processedElement;

            if (!validate(hasStateMachine, processedElement))

                return false;

            read();

            if (processedElement) { // for wildcard with 'skip' we have no element

                m_model->setAssignedElement(currentItem.toNodeModelIndex(), processedElement);

                // check identity constraints after all child nodes have been

                // validated, so that we know there assigned types

                validateIdentityConstraint(processedElement, currentItem);

            }

            if (!m_stateMachines.isEmpty() && hasStateMachine) {

                if (!m_stateMachines.top().inEndState()) {

                    error(QtXmlPatterns::tr("Element %1 is missing child element.").arg(formatKeyword(m_namePool->displayName(elementName))));

                    return false;

                }

                m_stateMachines.pop();

            }

        }

    }

    // final validations

    // check IDREF occurrences

    const QStringList ids = m_model->idIdRefBindingIds();

    QSetIterator<QString> it(m_idRefs);

    while (it.hasNext()) {

        const QString id = it.next();

        if (!ids.contains(id)) {

            error(QtXmlPatterns::tr("There is one IDREF value with no corresponding ID: %1.").arg(formatKeyword(id)));

            return false;

        }

    }

    return true;

}

void XsdValidatingInstanceReader::error(const QString &msg) const

{

    m_context.data()->error(msg, XsdSchemaContext::XSDError, sourceLocation());

}

bool XsdValidatingInstanceReader::loadSchema(const QString &targetNamespace, const QUrl &location)

{

    const AutoPtr<QNetworkReply> reply(AccelTreeResourceLoader::load(location, m_context->networkAccessManager(),

                                                                     m_context, AccelTreeResourceLoader::ContinueOnError));

    if (!reply)

        return true;

    // we have to create a separated schema context here, that however shares the type factory

    XsdSchemaContext::Ptr context(new XsdSchemaContext(m_namePool));

    context->m_schemaTypeFactory = m_context->m_schemaTypeFactory;

    QXmlSchemaPrivate schema(context);

    schema.load(reply.data(), location, targetNamespace);

    if (!schema.isValid()) {

        error(QtXmlPatterns::tr("Loaded schema file is invalid."));

        return false;

    }

    addSchema(schema.m_schemaParserContext->schema(), location);

    return true;

}

bool XsdValidatingInstanceReader::validate(bool &hasStateMachine, XsdElement::Ptr &processedElement)

{

    // first check if a custom schema is defined

    if (hasAttribute(m_xsiSchemaLocationName)) {

        const QString schemaLocation = attribute(m_xsiSchemaLocationName);

        const QStringList parts = schemaLocation.split(QLatin1Char(' '), QString::SkipEmptyParts);

        if ((parts.count()%2) == 1) {

            error(QtXmlPatterns::tr("%1 contains invalid data.").arg(formatKeyword(m_namePool, m_xsiSchemaLocationName)));

            return false;

        }

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

            const QString identifier = QString::fromLatin1("%1 %2").arg(parts.at(i)).arg(parts.at(i + 1));

            if (m_processedSchemaLocations.contains(identifier))

                continue;

            else

                m_processedSchemaLocations.insert(identifier);

            // check constraint 4) from http://www.w3.org/TR/xmlschema-1/#schema-loc (only valid for XML Schema 1.0?)

            if (m_processedNamespaces.contains(parts.at(i))) {

                error(QtXmlPatterns::tr("xsi:schemaLocation namespace %1 has already appeared earlier in the instance document.").arg(formatKeyword(parts.at(i))));

                return false;

            }

            QUrl url(parts.at(i + 1));

            if (url.isRelative()) {

                Q_ASSERT(m_documentUri.isValid());

                url = m_documentUri.resolved(url);

            }

            loadSchema(parts.at(i), url);

        }

    }

    if (hasAttribute(m_xsiNoNamespaceSchemaLocationName)) {

        const QString schemaLocation = attribute(m_xsiNoNamespaceSchemaLocationName);

        if (!m_processedSchemaLocations.contains(schemaLocation)) {

            m_processedSchemaLocations.insert(schemaLocation);

            if (m_processedNamespaces.contains(QString())) {

                error(QtXmlPatterns::tr("xsi:noNamespaceSchemaLocation cannot appear after the first no-namespace element or attribute."));

                return false;

            }

            QUrl url(schemaLocation);

            if (url.isRelative()) {

                Q_ASSERT(m_documentUri.isValid());

                url = m_documentUri.resolved(url);

            }

            loadSchema(QString(), url);

        }

    }

    m_processedNamespaces.insert(m_namePool->stringForNamespace(name().namespaceURI()));

    if (!m_schema) {

        error(QtXmlPatterns::tr("No schema defined for validation."));

        return false;

    }

    // check if we are 'inside' a type definition

    if (m_stateMachines.isEmpty()) {

        // find out the type of the top-level element

        XsdElement::Ptr element = elementByName(name());

        if (!element) {

            if (!hasAttribute(m_xsiTypeName)) {

                error(QtXmlPatterns::tr("No definition for element %1 available.").arg(formatKeyword(m_namePool, name())));

                return false;

            }

            // This instance document has an element with no definition in the schema

            // but an explicitly given type, that is fine according to the spec.

            // We will create an element definition manually here and continue the

            // normal validation process

            element = XsdElement::Ptr(new XsdElement());

            element->setName(name());

            element->setIsAbstract(false);

            element->setIsNillable(hasAttribute(m_xsiNilName));

            const QString type = qNameAttribute(m_xsiTypeName);

            const QXmlName typeName = convertToQName(type);

            const SchemaType::Ptr elementType = typeByName(typeName);

            if (!elementType) {

                error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));

                return false;

            }

            element->setType(elementType);

        }

        // rememeber the element we process

        processedElement = element;

        if (!validateElement(element, hasStateMachine)) {

            return false;

        }

    } else {

        if (!m_stateMachines.top().proceed<QXmlName>(name())) {

            error(QtXmlPatterns::tr("Element %1 is not defined in this scope.").arg(formatKeyword(m_namePool, name())));

            return false;

        }

        const XsdTerm::Ptr term = m_stateMachines.top().lastTransition();

        if (term->isElement()) {

            const XsdElement::Ptr element(term);

            // rememeber the element we process

            processedElement = element;

            if (!validateElement(element, hasStateMachine))

                return false;

        } else {

            const XsdWildcard::Ptr wildcard(term);

            if (wildcard->processContents() != XsdWildcard::Skip) {

                XsdElement::Ptr elementDeclaration = elementByName(name());

                if (!elementDeclaration) {

                    if (hasAttribute(m_xsiTypeName)) {

                        // This instance document has an element with no definition in the schema

                        // but an explicitly given type, that is fine according to the spec.

                        // We will create an element definition manually here and continue the

                        // normal validation process

                        elementDeclaration = XsdElement::Ptr(new XsdElement());

                        elementDeclaration->setName(name());

                        elementDeclaration->setIsAbstract(false);

                        elementDeclaration->setIsNillable(hasAttribute(m_xsiNilName));

                        const QString type = qNameAttribute(m_xsiTypeName);

                        const QXmlName typeName = convertToQName(type);

                        const SchemaType::Ptr elementType = typeByName(typeName);

                        if (!elementType) {

                            error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));

                            return false;

                        }

                        elementDeclaration->setType(elementType);

                    }

                }

                if (!elementDeclaration) {

                    if (wildcard->processContents() == XsdWildcard::Strict) {

                        error(QtXmlPatterns::tr("Declaration for element %1 does not exist.").arg(formatKeyword(m_namePool->displayName(name()))));

                        return false;

                    } else {

                        // in this case we put a state machine for the xs:anyType on the statemachine stack,

                        // so we accept every content of this element

                        createAndPushStateMachine(anyType()->contentType()->particle());

                        hasStateMachine = true;

                    }

                } else {

                    if (!validateElement(elementDeclaration, hasStateMachine)) {

                        if (wildcard->processContents() == XsdWildcard::Strict) {

                            error(QtXmlPatterns::tr("Element %1 contains invalid content.").arg(formatKeyword(m_namePool->displayName(name()))));

                            return false;

                        }

                    }

                    // rememeber the type of that element node

                    m_model->setAssignedType(item().toNodeModelIndex(), elementDeclaration->type());

                }

            } else { // wildcard process contents type is Skip

                // in this case we put a state machine for the xs:anyType on the statemachine stack,

                // so we accept every content of this element

                const XsdWildcard::Ptr wildcard(new XsdWildcard());

                wildcard->namespaceConstraint()->setVariety(XsdWildcard::NamespaceConstraint::Any);

                wildcard->setProcessContents(XsdWildcard::Skip);

                const XsdParticle::Ptr outerParticle(new XsdParticle());

                outerParticle->setMinimumOccurs(1);

                outerParticle->setMaximumOccurs(1);

                const XsdParticle::Ptr innerParticle(new XsdParticle());

                innerParticle->setMinimumOccurs(0);

                innerParticle->setMaximumOccursUnbounded(true);

                innerParticle->setTerm(wildcard);

                const XsdModelGroup::Ptr outerModelGroup(new XsdModelGroup());

                outerModelGroup->setCompositor(XsdModelGroup::SequenceCompositor);

                outerModelGroup->setParticles(XsdParticle::List() << innerParticle);

                outerParticle->setTerm(outerModelGroup);

                createAndPushStateMachine(outerParticle);

                hasStateMachine = true;

            }

        }

    }

    return true;

}

void XsdValidatingInstanceReader::createAndPushStateMachine(const XsdParticle::Ptr &particle)

{

    XsdStateMachine<XsdTerm::Ptr> stateMachine(m_namePool);

    XsdStateMachineBuilder builder(&stateMachine, m_namePool, XsdStateMachineBuilder::ValidatingMode);

    const XsdStateMachine<XsdTerm::Ptr>::StateId endState = builder.reset();

    const XsdStateMachine<XsdTerm::Ptr>::StateId startState = builder.buildParticle(particle, endState);

    builder.addStartState(startState);

/*

    QString fileName = QString("/tmp/foo_%1.dot").arg(m_namePool->displayName(complexType->name(m_namePool)));

    QString pngFileName = QString("/tmp/foo_%1.png").arg(m_namePool->displayName(complexType->name(m_namePool)));

    QFile file(fileName);

    file.open(QIODevice::WriteOnly);

    stateMachine.outputGraph(&file, "Hello");

    file.close();

    ::system(QString("dot -Tpng %1 -o%2").arg(fileName).arg(pngFileName).toLatin1().data());

*/

    stateMachine = stateMachine.toDFA();

    m_stateMachines.push(stateMachine);

}

bool XsdValidatingInstanceReader::validateElement(const XsdElement::Ptr &declaration, bool &hasStateMachine)

{

    // http://www.w3.org/TR/xmlschema11-1/#d0e10998

    bool isNilled = false;

    // 1 tested already, 'declaration' corresponds D

    // 2

    if (declaration->isAbstract()) {

        error(QtXmlPatterns::tr("Element %1 is declared as abstract.").arg(formatKeyword(declaration->displayName(m_namePool))));

        return false;

    }

    // 3

    if (!declaration->isNillable()) {

        if (hasAttribute(m_xsiNilName)) {

            error(QtXmlPatterns::tr("Element %1 is not nillable.").arg(formatKeyword(declaration->displayName(m_namePool))));

            return false; // 3.1

        }

    } else {

        if (hasAttribute(m_xsiNilName)) {

            const QString value = attribute(m_xsiNilName);

            const Boolean::Ptr nil = Boolean::fromLexical(value);

            if (nil->hasError()) {

                error(QtXmlPatterns::tr("Attribute %1 contains invalid data: %2").arg(formatKeyword(QLatin1String("nil."))).arg(formatData(value)));

                return false;

            }

            // 3.2.3

            if (nil->as<Boolean>()->value() == true) {

                // 3.2.3.1

                if (hasChildElement() || hasChildText()) {

                    error(QtXmlPatterns::tr("Element contains content although it is nillable."));

                    return false;

                }

                // 3.2.3.2

                if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdElement::ValueConstraint::Fixed) {

                    error(QtXmlPatterns::tr("Fixed value constraint not allowed if element is nillable."));

                    return false;

                }

            }

            isNilled = nil->as<Boolean>()->value();

        }

    }

    SchemaType::Ptr finalElementType = declaration->type();

    // 4

    if (hasAttribute(m_xsiTypeName)) {

        const QString type = qNameAttribute(m_xsiTypeName);

        const QXmlName typeName = convertToQName(type);

        const SchemaType::Ptr elementType = typeByName(typeName);

        // 4.1

        if (!elementType) {

            error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));

            return false;

        }

        // 4.2

        SchemaType::DerivationConstraints constraints = 0;

        if (declaration->disallowedSubstitutions() & NamedSchemaComponent::ExtensionConstraint)

            constraints |= SchemaType::ExtensionConstraint;

        if (declaration->disallowedSubstitutions() & NamedSchemaComponent::RestrictionConstraint)

            constraints |= SchemaType::RestrictionConstraint;

        if (!XsdSchemaHelper::isValidlySubstitutable(elementType, declaration->type(), constraints)) {

            if (declaration->type()->name(m_namePool) != BuiltinTypes::xsAnyType->name(m_namePool)) { // xs:anyType is a valid substitutable type here

                error(QtXmlPatterns::tr("Specified type %1 is not validly substitutable with element type %2.").arg(formatType(m_namePool, elementType)).arg(formatType(m_namePool, declaration->type())));

                return false;

            }

        }

        finalElementType = elementType;

    }

    if (!validateElementType(declaration, finalElementType, isNilled, hasStateMachine))

        return false;

    return true;

}

bool XsdValidatingInstanceReader::validateElementType(const XsdElement::Ptr &declaration, const SchemaType::Ptr &type, bool isNilled, bool &hasStateMachine)

{

    // @see http://www.w3.org/TR/xmlschema11-1/#d0e11749

    // 1 checked already

    // 2

    if (type->isComplexType() && type->isDefinedBySchema()) {

        if (XsdComplexType::Ptr(type)->isAbstract()) {

            error(QtXmlPatterns::tr("Complex type %1 is not allowed to be abstract.").arg(formatType(m_namePool, type)));

            return false;