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

**

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

#include "qderivedinteger_p.h"

#include "qderivedstring_p.h"

#include "qqnamevalue_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"

QT_BEGIN_NAMESPACE

using namespace QPatternist;

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

    : m_context(context)

    , m_checker(parserContext->checker())

    , m_namePool(parserContext->namePool())

    , m_schema(parserContext->schema())

{

    m_keyReferences.reserve(20);

    m_simpleRestrictionBases.reserve(20);

    m_simpleListTypes.reserve(20);

    m_simpleUnionTypes.reserve(20);

    m_elementTypes.reserve(20);

    m_complexBaseTypes.reserve(20);

    m_attributeTypes.reserve(20);

    m_alternativeTypes.reserve(20);

    m_alternativeTypeElements.reserve(20);

    m_substitutionGroupAffiliations.reserve(20);

    m_predefinedSchemaTypes = m_context->schemaTypeFactory()->types().values();

}

XsdSchemaResolver::~XsdSchemaResolver()

{

}

void XsdSchemaResolver::resolve()

{

    m_checker->addComponentLocationHash(m_componentLocationHash);

    // resolve the base types for all types

    resolveSimpleRestrictionBaseTypes();

    resolveComplexBaseTypes();

    // do the basic checks which depend on having a base type available

    m_checker->basicCheck();

    // resolve further types that only map a type name to a type object

    resolveSimpleListType();

    resolveSimpleUnionTypes();

    resolveElementTypes();

    resolveAttributeTypes();

    resolveAlternativeTypes();

    // resolve objects that do not need information about inheritance

    resolveKeyReferences();

    resolveSubstitutionGroupAffiliations();

    // resolve objects that do need information about inheritance

    resolveSimpleRestrictions();

    resolveSimpleContentComplexTypes();

    // resolve objects which replace place holders

    resolveTermReferences();

    resolveAttributeTermReferences();

    // resolve additional objects that do need information about inheritance

    resolveAttributeInheritance();

    resolveComplexContentComplexTypes();

    resolveSubstitutionGroups();

    resolveEnumerationFacetValues();

    checkRedefinedGroups();

    checkRedefinedAttributeGroups();

    // check the constraining facets before we resolve them

    m_checker->checkConstrainingFacets();

    // add it again, as we may have added new components in the meantime

    m_checker->addComponentLocationHash(m_componentLocationHash);

    m_checker->check();

}

void XsdSchemaResolver::addKeyReference(const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &keyRef, const QXmlName &reference, const QSourceLocation &location)

{

    KeyReference item;

    item.element = element;

    item.keyRef = keyRef;

    item.reference = reference;

    item.location = location;

    m_keyReferences.append(item);

}

void XsdSchemaResolver::addSimpleRestrictionBase(const XsdSimpleType::Ptr &simpleType, const QXmlName &baseName, const QSourceLocation &location)

{

    SimpleRestrictionBase item;

    item.simpleType = simpleType;

    item.baseName = baseName;

    item.location = location;

    m_simpleRestrictionBases.append(item);

}

void XsdSchemaResolver::removeSimpleRestrictionBase(const XsdSimpleType::Ptr &type)

{

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

        if (m_simpleRestrictionBases.at(i).simpleType == type) {

            m_simpleRestrictionBases.remove(i);

            break;

        }

    }

}

void XsdSchemaResolver::addSimpleListType(const XsdSimpleType::Ptr &simpleType, const QXmlName &typeName, const QSourceLocation &location)

{

    SimpleListType item;

    item.simpleType = simpleType;

    item.typeName = typeName;

    item.location = location;

    m_simpleListTypes.append(item);

}

void XsdSchemaResolver::addSimpleUnionTypes(const XsdSimpleType::Ptr &simpleType, const QList<QXmlName> &typeNames, const QSourceLocation &location)

{

    SimpleUnionType item;

    item.simpleType = simpleType;

    item.typeNames = typeNames;

    item.location = location;

    m_simpleUnionTypes.append(item);

}

void XsdSchemaResolver::addElementType(const XsdElement::Ptr &element, const QXmlName &typeName, const QSourceLocation &location)

{

    ElementType item;

    item.element = element;

    item.typeName = typeName;

    item.location = location;

    m_elementTypes.append(item);

}

void XsdSchemaResolver::addComplexBaseType(const XsdComplexType::Ptr &complexType, const QXmlName &baseName, const QSourceLocation &location, const XsdFacet::Hash &facets)

{

    ComplexBaseType item;

    item.complexType = complexType;

    item.baseName = baseName;

    item.location = location;

    item.facets = facets;

    m_complexBaseTypes.append(item);

}

void XsdSchemaResolver::removeComplexBaseType(const XsdComplexType::Ptr &type)

{

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

        if (m_complexBaseTypes.at(i).complexType == type) {

            m_complexBaseTypes.remove(i);

            break;

        }

    }

}

void XsdSchemaResolver::addComplexContentType(const XsdComplexType::Ptr &complexType, const XsdParticle::Ptr &content, bool mixed)

{

    ComplexContentType item;

    item.complexType = complexType;

    item.explicitContent = content;

    item.effectiveMixed = mixed;

    m_complexContentTypes.append(item);

}

void XsdSchemaResolver::addAttributeType(const XsdAttribute::Ptr &attribute, const QXmlName &typeName, const QSourceLocation &location)

{

    AttributeType item;

    item.attribute = attribute;

    item.typeName = typeName;

    item.location = location;

    m_attributeTypes.append(item);

}

void XsdSchemaResolver::addAlternativeType(const XsdAlternative::Ptr &alternative, const QXmlName &typeName, const QSourceLocation &location)

{

    AlternativeType item;

    item.alternative = alternative;

    item.typeName = typeName;

    item.location = location;

    m_alternativeTypes.append(item);

}

void XsdSchemaResolver::addAlternativeType(const XsdAlternative::Ptr &alternative, const XsdElement::Ptr &element)

{

    AlternativeTypeElement item;

    item.alternative = alternative;

    item.element = element;

    m_alternativeTypeElements.append(item);

}

void XsdSchemaResolver::addSubstitutionGroupAffiliation(const XsdElement::Ptr &element, const QList<QXmlName> &elementNames, const QSourceLocation &location)

{

    SubstitutionGroupAffiliation item;

    item.element = element;

    item.elementNames = elementNames;

    item.location = location;

    m_substitutionGroupAffiliations.append(item);

}

void XsdSchemaResolver::addSubstitutionGroupType(const XsdElement::Ptr &element)

{

    m_substitutionGroupTypes.append(element);

}

void XsdSchemaResolver::addComponentLocationHash(const ComponentLocationHash &hash)

{

    m_componentLocationHash.unite(hash);

}

void XsdSchemaResolver::addEnumerationFacetValue(const AtomicValue::Ptr &facetValue, const NamespaceSupport &namespaceSupport)

{

    m_enumerationFacetValues.insert(facetValue, namespaceSupport);

}

void XsdSchemaResolver::addRedefinedGroups(const XsdModelGroup::Ptr &redefinedGroup, const XsdModelGroup::Ptr &group)

{

    RedefinedGroups item;

    item.redefinedGroup = redefinedGroup;

    item.group = group;

    m_redefinedGroups.append(item);

}

void XsdSchemaResolver::addRedefinedAttributeGroups(const XsdAttributeGroup::Ptr &redefinedGroup, const XsdAttributeGroup::Ptr &group)

{

    RedefinedAttributeGroups item;

    item.redefinedGroup = redefinedGroup;

    item.group = group;

    m_redefinedAttributeGroups.append(item);

}

void XsdSchemaResolver::addAllGroupCheck(const XsdReference::Ptr &reference)

{

    m_allGroups.insert(reference);

}

void XsdSchemaResolver::copyDataTo(const XsdSchemaResolver::Ptr &other) const

{

    other->m_keyReferences << m_keyReferences;

    other->m_simpleRestrictionBases << m_simpleRestrictionBases;

    other->m_simpleListTypes << m_simpleListTypes;

    other->m_simpleUnionTypes << m_simpleUnionTypes;

    other->m_elementTypes << m_elementTypes;

    other->m_complexBaseTypes << m_complexBaseTypes;

    other->m_complexContentTypes << m_complexContentTypes;

    other->m_attributeTypes << m_attributeTypes;

    other->m_alternativeTypes << m_alternativeTypes;

    other->m_alternativeTypeElements << m_alternativeTypeElements;

    other->m_substitutionGroupAffiliations << m_substitutionGroupAffiliations;

    other->m_substitutionGroupTypes << m_substitutionGroupTypes;

}

QXmlName XsdSchemaResolver::baseTypeNameOfType(const SchemaType::Ptr &type) const

{

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

        if (m_simpleRestrictionBases.at(i).simpleType == type)

            return m_simpleRestrictionBases.at(i).baseName;

    }

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

        if (m_complexBaseTypes.at(i).complexType == type)

            return m_complexBaseTypes.at(i).baseName;

    }

    return QXmlName();

}

QXmlName XsdSchemaResolver::typeNameOfAttribute(const XsdAttribute::Ptr &attribute) const

{

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

        if (m_attributeTypes.at(i).attribute == attribute)

            return m_attributeTypes.at(i).typeName;

    }

    return QXmlName();

}

void XsdSchemaResolver::setDefaultOpenContent(const XsdComplexType::OpenContent::Ptr &openContent, bool appliesToEmpty)

{

    m_defaultOpenContent = openContent;

    m_defaultOpenContentAppliesToEmpty = appliesToEmpty;

}

void XsdSchemaResolver::resolveKeyReferences()

{

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

        const KeyReference ref = m_keyReferences.at(i);

        const XsdIdentityConstraint::Ptr constraint = m_schema->identityConstraint(ref.reference);

        if (!constraint) {

            m_context->error(QtXmlPatterns::tr("%1 references unknown %2 or %3 element %4.")

                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

                                              .arg(formatElement("key"))

                                              .arg(formatElement("unique"))

                                              .arg(formatKeyword(m_namePool, ref.reference)),

                             XsdSchemaContext::XSDError, ref.location);

            return;

        }

        if (constraint->category() != XsdIdentityConstraint::Key && constraint->category() != XsdIdentityConstraint::Unique) { // only key and unique can be referenced

            m_context->error(QtXmlPatterns::tr("%1 references identity constraint %2 that is no %3 or %4 element.")

                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

                                              .arg(formatKeyword(m_namePool, ref.reference))

                                              .arg(formatElement("key"))

                                              .arg(formatElement("unique")),

                             XsdSchemaContext::XSDError, ref.location);

            return;

        }

        if (constraint->fields().count() != ref.keyRef->fields().count()) {

            m_context->error(QtXmlPatterns::tr("%1 has a different number of fields from the identity constraint %2 that it references.")

                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

                                              .arg(formatKeyword(m_namePool, ref.reference)),

                             XsdSchemaContext::XSDError, ref.location);

            return;

        }

        ref.keyRef->setReferencedKey(constraint);

    }

}

void XsdSchemaResolver::resolveSimpleRestrictionBaseTypes()

{

    // iterate over all simple types that are derived by restriction

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

        const SimpleRestrictionBase item = m_simpleRestrictionBases.at(i);

        // find the base type

        SchemaType::Ptr type = m_schema->type(item.baseName);

        if (!type) {

            // maybe it's a basic type...

            type = m_context->schemaTypeFactory()->createSchemaType(item.baseName);

            if (!type) {

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

                                                  .arg(formatType(m_namePool, item.baseName))

                                                  .arg(formatElement("restriction")),

                                 XsdSchemaContext::XSDError, item.location);

                return;

            }

        }

        item.simpleType->setWxsSuperType(type);

    }

}

void XsdSchemaResolver::resolveSimpleRestrictions()

{

    XsdSimpleType::List simpleTypes;

    // first collect the global simple types

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

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

        if (types.at(i)->isSimpleType() && (types.at(i)->derivationMethod() == SchemaType::DerivationRestriction))

            simpleTypes.append(types.at(i));

    }

    // then collect all anonymous simple types

    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();

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

        if (anonymousTypes.at(i)->isSimpleType() && (anonymousTypes.at(i)->derivationMethod() == SchemaType::DerivationRestriction))

            simpleTypes.append(anonymousTypes.at(i));

    }

    QSet<XsdSimpleType::Ptr> visitedTypes;

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

        resolveSimpleRestrictions(simpleTypes.at(i), visitedTypes);

    }

}

void XsdSchemaResolver::resolveSimpleRestrictions(const XsdSimpleType::Ptr &simpleType, QSet<XsdSimpleType::Ptr> &visitedTypes)

{

    if (visitedTypes.contains(simpleType))

        return;

    else

        visitedTypes.insert(simpleType);

    if (simpleType->derivationMethod() != XsdSimpleType::DerivationRestriction)

        return;

    // as xs:NMTOKENS, xs:ENTITIES and xs:IDREFS are provided by our XsdSchemaTypesFactory, they are

    // setup correctly already and shouldn't be handled here

    if (m_predefinedSchemaTypes.contains(simpleType))

        return;

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

    Q_ASSERT(baseType);

    if (baseType->isDefinedBySchema())

        resolveSimpleRestrictions(XsdSimpleType::Ptr(baseType), visitedTypes);

    simpleType->setCategory(baseType->category());

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

        QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;

        const AnySimpleType::Ptr primitiveType = findPrimitiveType(baseType, visitedPrimitiveTypes);

        simpleType->setPrimitiveType(primitiveType);

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

        const XsdSimpleType::Ptr simpleBaseType = baseType;

        simpleType->setItemType(simpleBaseType->itemType());

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

        const XsdSimpleType::Ptr simpleBaseType = baseType;

        simpleType->setMemberTypes(simpleBaseType->memberTypes());

    }

}

void XsdSchemaResolver::resolveSimpleListType()

{

    // iterate over all simple types where the item type shall be resolved

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

        const SimpleListType item = m_simpleListTypes.at(i);

        // try to resolve the name

        SchemaType::Ptr type = m_schema->type(item.typeName);

        if (!type) {

            // maybe it's a basic type...

            type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);

            if (!type) {

                m_context->error(QtXmlPatterns::tr("Item type %1 of %2 element cannot be resolved.")

                                                  .arg(formatType(m_namePool, item.typeName))

                                                  .arg(formatElement("list")),

                                 XsdSchemaContext::XSDError, item.location);

                return;

            }

        }

        item.simpleType->setItemType(type);

    }

}

void XsdSchemaResolver::resolveSimpleUnionTypes()

{

    // iterate over all simple types where the union member types shall be resolved

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

        const SimpleUnionType item = m_simpleUnionTypes.at(i);

        AnySimpleType::List memberTypes;

        // iterate over all union member type names

        const QList<QXmlName> typeNames = item.typeNames;

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

            const QXmlName typeName = typeNames.at(j);

            // try to resolve the name

            SchemaType::Ptr type = m_schema->type(typeName);

            if (!type) {

                // maybe it's a basic type...

                type = m_context->schemaTypeFactory()->createSchemaType(typeName);

                if (!type) {

                    m_context->error(QtXmlPatterns::tr("Member type %1 of %2 element cannot be resolved.")

                                                      .arg(formatType(m_namePool, typeName))

                                                      .arg(formatElement("union")),

                                     XsdSchemaContext::XSDError, item.location);

                    return;

                }

            }

            memberTypes.append(type);

        }

        // append the types that have been defined as <simpleType> children

        memberTypes << item.simpleType->memberTypes();

        item.simpleType->setMemberTypes(memberTypes);

    }

}