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

**

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

#include "qderivedinteger_p.h"

#include "qderivedstring_p.h"

#include "qpatternplatform_p.h"

#include "qqnamevalue_p.h"

#include "qsourcelocationreflection_p.h"

#include "qvaluefactory_p.h"

#include "qxsdattributereference_p.h"

#include "qxsdparticlechecker_p.h"

#include "qxsdreference_p.h"

#include "qxsdschemacontext_p.h"

#include "qxsdschemahelper_p.h"

#include "qxsdschemaparsercontext_p.h"

#include "qxsdschematypesfactory_p.h"

#include "qxsdtypechecker_p.h"

#include "qxsdschemachecker_helper.cpp"

QT_BEGIN_NAMESPACE

using namespace QPatternist;

XsdSchemaChecker::XsdSchemaChecker(const QExplicitlySharedDataPointer<XsdSchemaContext> &context, const XsdSchemaParserContext *parserContext)

    : m_context(context)

    , m_namePool(parserContext->namePool())

    , m_schema(parserContext->schema())

{

    setupAllowedAtomicFacets();

}

XsdSchemaChecker::~XsdSchemaChecker()

{

}

/*

 * This method is called after the resolver has set the base type for every

 * type and information about deriavtion and 'is simple type vs. is complex type'

 * are available.

 */

void XsdSchemaChecker::basicCheck()

{

    // first check that there is no circular inheritance, only the

    // wxsSuperType is used here

    checkBasicCircularInheritances();

    // check the basic constraints like simple type can not inherit from complex type etc.

    checkBasicSimpleTypeConstraints();

    checkBasicComplexTypeConstraints();

}

void XsdSchemaChecker::check()

{

    checkCircularInheritances();

    checkInheritanceRestrictions();

    checkSimpleDerivationRestrictions();

    checkSimpleTypeConstraints();

    checkComplexTypeConstraints();

    checkDuplicatedAttributeUses();

    checkElementConstraints();

    checkAttributeConstraints();

    checkAttributeUseConstraints();

//    checkElementDuplicates();

}

void XsdSchemaChecker::addComponentLocationHash(const ComponentLocationHash &hash)

{

    m_componentLocationHash.unite(hash);

}

/**

 * Checks whether the @p otherType is the same as @p myType or if one of its

 * ancestors is the same as @p myType.

 */

static bool matchesType(const SchemaType::Ptr &myType, const SchemaType::Ptr &otherType, QSet<SchemaType::Ptr> visitedTypes)

{

    bool retval = false;

    if (otherType) {

        if (visitedTypes.contains(otherType)) {

            return true;

        } else {

            visitedTypes.insert(otherType);

        }

        // simple types can have different varieties, so we have to check each of them

        if (otherType->isSimpleType()) {

            const XsdSimpleType::Ptr simpleType = otherType;

            if (simpleType->category() == XsdSimpleType::SimpleTypeAtomic) {

                // for atomic type we use the same test as in SchemaType::wxsTypeMatches

                retval = (myType == simpleType ? true : matchesType(myType, simpleType->wxsSuperType(), visitedTypes));

            } else if (simpleType->category() == XsdSimpleType::SimpleTypeList) {

                // for list type we test against the itemType property

                retval = (myType == simpleType->itemType() ? true : matchesType(myType, simpleType->itemType()->wxsSuperType(), visitedTypes));

            } else if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

                // for union type we test against each member type

                const XsdSimpleType::List members = simpleType->memberTypes();

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

                    if (myType == members.at(i) ? true : matchesType(myType, members.at(i)->wxsSuperType(), visitedTypes)) {

                        retval = true;

                        break;

                    }

                }

            } else {

                // reached xsAnySimple type whichs category is None

                retval = false;

            }

        } else {

            // if no simple type we handle it like in SchemaType::wxsTypeMatches

            retval = (myType == otherType ? true : matchesType(myType, otherType->wxsSuperType(), visitedTypes));

        }

    } else // if otherType is null it doesn't match

        retval = false;

    return retval;

}

/**

 * Checks whether there is a circular inheritance for the union inheritance.

 */

static bool hasCircularUnionInheritance(const XsdSimpleType::Ptr &type, const SchemaType::Ptr &otherType, NamePool::Ptr &namePool)

{

    if (type == otherType) {

        return true;

    }

    if (!otherType->isSimpleType() || !otherType->isDefinedBySchema()) {

        return false;

    }

    const XsdSimpleType::Ptr simpleOtherType = otherType;

    if (simpleOtherType->category() == XsdSimpleType::SimpleTypeUnion) {

        const XsdSimpleType::List memberTypes = simpleOtherType->memberTypes();

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

            if (otherType->wxsSuperType() == type) {

                return true;

            }

            if (hasCircularUnionInheritance(type, memberTypes.at(i), namePool)) {

                return true;

            }

        }

    }

    return false;

}

static inline bool wxsTypeMatches(const SchemaType::Ptr &type, const SchemaType::Ptr &otherType, QSet<SchemaType::Ptr> &visitedTypes, SchemaType::Ptr &conflictingType)

{

    if (!otherType)

        return false;

    if (visitedTypes.contains(otherType)) { // inheritance loop detected

        conflictingType = otherType;

        return true;

    } else {

        visitedTypes.insert(otherType);

    }

    if (type == otherType)

        return true;

    return wxsTypeMatches(type, otherType->wxsSuperType(), visitedTypes, conflictingType);

}

void XsdSchemaChecker::checkBasicCircularInheritances()

{

    // check all global types...

    SchemaType::List types = m_schema->types();

    // .. and anonymous types

    types << m_schema->anonymousTypes();

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

        const SchemaType::Ptr type = types.at(i);

        const QSourceLocation location = sourceLocationForType(type);

        // @see http://www.w3.org/TR/xmlschema11-1/#ct-props-correct 3)

        // check normal base type inheritance

        QSet<SchemaType::Ptr> visitedTypes;

        SchemaType::Ptr conflictingType;

        if (wxsTypeMatches(type, type->wxsSuperType(), visitedTypes, conflictingType)) {

            if (conflictingType)

                m_context->error(QtXmlPatterns::tr("%1 has inheritance loop in its base type %2.")

                                                  .arg(formatType(m_namePool, type))

                                                  .arg(formatType(m_namePool, conflictingType)),

                                 XsdSchemaContext::XSDError, location);

            else

                m_context->error(QtXmlPatterns::tr("Circular inheritance of base type %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

            return;

        }

    }

}

void XsdSchemaChecker::checkCircularInheritances()

{

    // check all global types...

    SchemaType::List types = m_schema->types();

    // .. and anonymous types

    types << m_schema->anonymousTypes();

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

        const SchemaType::Ptr type = types.at(i);

        const QSourceLocation location = sourceLocationForType(type);

        // @see http://www.w3.org/TR/xmlschema11-1/#ct-props-correct 3)

        // check normal base type inheritance

        QSet<SchemaType::Ptr> visitedTypes;

        if (matchesType(type, type->wxsSuperType(), visitedTypes)) {

            m_context->error(QtXmlPatterns::tr("Circular inheritance of base type %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

            return;

        }

        // check union member inheritance

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

            const XsdSimpleType::Ptr simpleType = type;

            if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

                const XsdSimpleType::List memberTypes = simpleType->memberTypes();

                for (int j = 0; j < memberTypes.count(); ++j) {

                    if (hasCircularUnionInheritance(simpleType, memberTypes.at(j), m_namePool)) {

                        m_context->error(QtXmlPatterns::tr("Circular inheritance of union %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

                        return;

                    }

                }

            }

        }

    }

}

void XsdSchemaChecker::checkInheritanceRestrictions()

{

    // check all global types...

    SchemaType::List types = m_schema->types();

    // .. and anonymous types

    types << m_schema->anonymousTypes();

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

        const SchemaType::Ptr type = types.at(i);

        const QSourceLocation location = sourceLocationForType(type);

        // check inheritance restrictions given by final property of base class

        const SchemaType::Ptr baseType = type->wxsSuperType();

        if (baseType->isDefinedBySchema()) {

            if ((type->derivationMethod() == SchemaType::DerivationRestriction) && (baseType->derivationConstraints() & SchemaType::RestrictionConstraint)) {

                m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by restriction as the latter defines it as final.")

                                                  .arg(formatType(m_namePool, type))

                                                  .arg(formatType(m_namePool, baseType)), XsdSchemaContext::XSDError, location);

                return;

            } else if ((type->derivationMethod() == SchemaType::DerivationExtension) && (baseType->derivationConstraints() & SchemaType::ExtensionConstraint)) {

                m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by extension as the latter defines it as final.")

                                                  .arg(formatType(m_namePool, type))

                                                  .arg(formatType(m_namePool, baseType)), XsdSchemaContext::XSDError, location);

                return;

            }

        }

    }

}

void XsdSchemaChecker::checkBasicSimpleTypeConstraints()

{

    // check all global types...

    SchemaType::List types = m_schema->types();

    // .. and anonymous types

    types << m_schema->anonymousTypes();

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

        const SchemaType::Ptr type = types.at(i);

        if (!type->isSimpleType())

            continue;

        const XsdSimpleType::Ptr simpleType = type;

        const QSourceLocation location = sourceLocation(simpleType);

        // check inheritance restrictions of simple type defined by schema constraints

        const SchemaType::Ptr baseType = simpleType->wxsSuperType();

        if (baseType->isComplexType() && (simpleType->name(m_namePool) != BuiltinTypes::xsAnySimpleType->name(m_namePool))) {

            m_context->error(QtXmlPatterns::tr("Base type of simple type %1 cannot be complex type %2.")

                                              .arg(formatType(m_namePool, simpleType))

                                              .arg(formatType(m_namePool, baseType)),

                             XsdSchemaContext::XSDError, location);

            return;

        }

        if (baseType == BuiltinTypes::xsAnyType) {

            if (type->name(m_namePool) != BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

                m_context->error(QtXmlPatterns::tr("Simple type %1 cannot have direct base type %2.")

                                                  .arg(formatType(m_namePool, simpleType))

                                                  .arg(formatType(m_namePool, BuiltinTypes::xsAnyType)),

                                 XsdSchemaContext::XSDError, location);

                return;

            }

        }

    }

}

void XsdSchemaChecker::checkSimpleTypeConstraints()

{

    // check all global types...

    SchemaType::List types = m_schema->types();

    // .. and anonymous types

    types << m_schema->anonymousTypes();

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

        const SchemaType::Ptr type = types.at(i);

        if (!type->isSimpleType())

            continue;

        const XsdSimpleType::Ptr simpleType = type;

        const QSourceLocation location = sourceLocation(simpleType);

        if (simpleType->category() == XsdSimpleType::None) {

            // additional checks

            // check that no user defined type has xs:AnySimpleType as base type (except xs:AnyAtomicType)

            if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

                if (simpleType->name(m_namePool) != BuiltinTypes::xsAnyAtomicType->name(m_namePool)) {

                    m_context->error(QtXmlPatterns::tr("Simple type %1 is not allowed to have base type %2.")

                                                      .arg(formatType(m_namePool, simpleType))

                                                      .arg(formatType(m_namePool, simpleType->wxsSuperType())),

                                     XsdSchemaContext::XSDError, location);

                    return;

                }

            }

            // check that no user defined type has xs:AnyAtomicType as base type

            if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnyAtomicType->name(m_namePool)) {

                m_context->error(QtXmlPatterns::tr("Simple type %1 is not allowed to have base type %2.")

                                                  .arg(formatType(m_namePool, simpleType))

                                                  .arg(formatType(m_namePool, simpleType->wxsSuperType())),

                                 XsdSchemaContext::XSDError, location);

                return;

            }

        }

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

        if (simpleType->category() == XsdSimpleType::SimpleTypeAtomic) {

            // 1.1

            if ((simpleType->wxsSuperType()->category() != XsdSimpleType::SimpleTypeAtomic) && (simpleType->name(m_namePool) != BuiltinTypes::xsAnyAtomicType->name(m_namePool))) {

                m_context->error(QtXmlPatterns::tr("Simple type %1 can only have simple atomic type as base type.")

                                                  .arg(formatType(m_namePool, simpleType)),

                                 XsdSchemaContext::XSDError, location);

            }

            // 1.2

            if (simpleType->wxsSuperType()->derivationConstraints() & SchemaType::RestrictionConstraint) {

                m_context->error(QtXmlPatterns::tr("Simple type %1 cannot derive from %2 as the latter defines restriction as final.")

                                                  .arg(formatType(m_namePool, simpleType->wxsSuperType()))

                                                  .arg(formatType(m_namePool, simpleType)),

                                 XsdSchemaContext::XSDError, location);

            }

            // 1.3

            // checked by checkConstrainingFacets  already

        } else if (simpleType->category() == XsdSimpleType::SimpleTypeList) {

            const AnySimpleType::Ptr itemType = simpleType->itemType();

            // 2.1 or @see http://www.w3.org/TR/xmlschema-2/#cos-list-of-atomic

            if (itemType->category() != SchemaType::SimpleTypeAtomic && itemType->category() != SchemaType::SimpleTypeUnion) {

                m_context->error(QtXmlPatterns::tr("Variety of item type of %1 must be either atomic or union.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

                return;

            }

            // 2.1 second part

            if (itemType->category() == SchemaType::SimpleTypeUnion && itemType->isDefinedBySchema()) {

                const XsdSimpleType::Ptr simpleItemType = itemType;

                const AnySimpleType::List memberTypes = simpleItemType->memberTypes();

                for (int j = 0; j < memberTypes.count(); ++j) {

                    if (memberTypes.at(j)->category() != SchemaType::SimpleTypeAtomic) {

                        m_context->error(QtXmlPatterns::tr("Variety of member types of %1 must be atomic.").arg(formatType(m_namePool, simpleItemType)), XsdSchemaContext::XSDError, location);

                        return;

                    }

                }

            }

            // 2.2.1

            if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

                if (itemType->isSimpleType() && itemType->isDefinedBySchema()) {

                    const XsdSimpleType::Ptr simpleItemType = itemType;

                    // 2.2.1.1

                    if (simpleItemType->derivationConstraints() & XsdSimpleType::ListConstraint) {

                        m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by list as the latter defines it as final.")

                                                          .arg(formatType(m_namePool, simpleType))

                                                          .arg(formatType(m_namePool, simpleItemType)), XsdSchemaContext::XSDError, location);

                        return;

                    }

                    // 2.2.1.2

                    const XsdFacet::Hash facets = simpleType->facets();

                    XsdFacet::HashIterator it(facets);

                    bool invalidFacetFound = false;

                    while (it.hasNext()) {

                        it.next();

                        if (it.key() != XsdFacet::WhiteSpace) {

                            invalidFacetFound = true;

                            break;

                        }

                    }

                    if (invalidFacetFound) {

                        m_context->error(QtXmlPatterns::tr("Simple type %1 is only allowed to have %2 facet.")

                                                          .arg(formatType(m_namePool, simpleType))

                                                          .arg(formatKeyword("whiteSpace")),

                                         XsdSchemaContext::XSDError, location);

                        return;

                    }

                }

            } else { // 2.2.2

                // 2.2.2.1

                if (simpleType->wxsSuperType()->category() != XsdSimpleType::SimpleTypeList) {

                    m_context->error(QtXmlPatterns::tr("Base type of simple type %1 must have variety of type list.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

                    return;

                }

                // 2.2.2.2

                if (simpleType->wxsSuperType()->derivationConstraints() & SchemaType::RestrictionConstraint) {

                    m_context->error(QtXmlPatterns::tr("Base type of simple type %1 has defined derivation by restriction as final.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

                    return;

                }

                // 2.2.2.3

                if (!XsdSchemaHelper::isSimpleDerivationOk(itemType, XsdSimpleType::Ptr(simpleType->wxsSuperType())->itemType(), SchemaType::DerivationConstraints())) {

                    m_context->error(QtXmlPatterns::tr("Item type of base type does not match item type of %1.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

                    return;

                }

                // 2.2.2.4

                const XsdFacet::Hash facets = simpleType->facets();

                XsdFacet::HashIterator it(facets);

                bool invalidFacetFound = false;

                XsdFacet::Type invalidFacetType = XsdFacet::None;

                while (it.hasNext()) {

                    it.next();

                    const XsdFacet::Type facetType = it.key();

                    if (facetType != XsdFacet::Length &&

                        facetType != XsdFacet::MinimumLength &&

                        facetType != XsdFacet::MaximumLength &&

                        facetType != XsdFacet::WhiteSpace &&

                        facetType != XsdFacet::Pattern &&

                        facetType != XsdFacet::Enumeration) {

                        invalidFacetType = facetType;

                        invalidFacetFound = true;

                        break;

                    }

                }

                if (invalidFacetFound) {

                    m_context->error(QtXmlPatterns::tr("Simple type %1 contains not allowed facet type %2.")

                                                      .arg(formatType(m_namePool, simpleType))

                                                      .arg(formatKeyword(XsdFacet::typeName(invalidFacetType))),

                                     XsdSchemaContext::XSDError, location);

                    return;

                }

                // 2.2.2.5

                // TODO: check value constraints

            }

        } else if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

            const AnySimpleType::List memberTypes = simpleType->memberTypes();

            if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) { // 3.1.1

                // 3.3.1.1

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

                    const AnySimpleType::Ptr memberType = memberTypes.at(i);

                    if (memberType->derivationConstraints() & XsdSimpleType::UnionConstraint) {

                        m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by union as the latter defines it as final.")

                                                          .arg(formatType(m_namePool, simpleType))

                                                          .arg(formatType(m_namePool, memberType)), XsdSchemaContext::XSDError, location);

                        return;

                    }

                }