/*

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.sun.org.apache.xerces.internal.impl.xs.traversers;

import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;

import com.sun.org.apache.xerces.internal.impl.dv.XSFacets;

import com.sun.org.apache.xerces.internal.impl.dv.XSSimpleType;

import com.sun.org.apache.xerces.internal.impl.validation.ValidationState;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaGrammar;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaSymbols;

import com.sun.org.apache.xerces.internal.impl.xs.XSAnnotationImpl;

import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeGroupDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeUseImpl;

import com.sun.org.apache.xerces.internal.impl.xs.XSComplexTypeDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSElementDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSParticleDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSWildcardDecl;

import com.sun.org.apache.xerces.internal.impl.xs.util.XInt;

import com.sun.org.apache.xerces.internal.impl.xs.util.XSObjectListImpl;

import com.sun.org.apache.xerces.internal.util.DOMUtil;

import com.sun.org.apache.xerces.internal.util.NamespaceSupport;

import com.sun.org.apache.xerces.internal.util.SymbolTable;

import com.sun.org.apache.xerces.internal.xni.QName;

import com.sun.org.apache.xerces.internal.xs.XSAttributeUse;

import com.sun.org.apache.xerces.internal.xs.XSObjectList;

import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;

import org.w3c.dom.Element;

/**

 * Class <code>XSDAbstractTraverser</code> serves as the base class for all

 * other <code>XSD???Traverser</code>s. It holds the common data and provide

 * a unified way to initialize these data.

 *

 * @xerces.internal

 *

 * @author Elena Litani, IBM

 * @author Rahul Srivastava, Sun Microsystems Inc.

 * @author Neeraj Bajaj, Sun Microsystems Inc.

 *

 */

abstract class XSDAbstractTraverser {

    protected static final String NO_NAME      = "(no name)";

    // Flags for checkOccurrences to indicate any special

    // restrictions on minOccurs and maxOccurs relating to "all".

    //    NOT_ALL_CONTEXT    - not processing an <all>

    //    PROCESSING_ALL_EL  - processing an <element> in an <all>

    //    GROUP_REF_WITH_ALL - processing <group> reference that contained <all>

    //    CHILD_OF_GROUP     - processing a child of a model group definition

    //    PROCESSING_ALL_GP  - processing an <all> group itself

    protected static final int NOT_ALL_CONTEXT    = 0;

    protected static final int PROCESSING_ALL_EL  = 1;

    protected static final int GROUP_REF_WITH_ALL = 2;

    protected static final int CHILD_OF_GROUP     = 4;

    protected static final int PROCESSING_ALL_GP  = 8;

    //Shared data

    protected XSDHandler            fSchemaHandler = null;

    protected SymbolTable           fSymbolTable = null;

    protected XSAttributeChecker    fAttrChecker = null;

    protected boolean               fValidateAnnotations = false;

    // used to validate default/fixed attribute values

    ValidationState fValidationState = new ValidationState();

    XSDAbstractTraverser (XSDHandler handler,

            XSAttributeChecker attrChecker) {

        fSchemaHandler = handler;

        fAttrChecker = attrChecker;

    }

    void reset(SymbolTable symbolTable, boolean validateAnnotations, Locale locale) {

        fSymbolTable = symbolTable;

        fValidateAnnotations = validateAnnotations;

        fValidationState.setExtraChecking(false);

        fValidationState.setSymbolTable(symbolTable);

        fValidationState.setLocale(locale);

    }

    // traverse the annotation declaration

    // REVISIT: how to pass the parentAttrs? as DOM attributes?

    //          as name/value pairs (string)? in parsed form?

    // @return XSAnnotationImpl object

    XSAnnotationImpl traverseAnnotationDecl(Element annotationDecl, Object[] parentAttrs,

            boolean isGlobal, XSDocumentInfo schemaDoc) {

        // General Attribute Checking

        Object[] attrValues = fAttrChecker.checkAttributes(annotationDecl, isGlobal, schemaDoc);

        fAttrChecker.returnAttrArray(attrValues, schemaDoc);

        String contents = DOMUtil.getAnnotation(annotationDecl);

        Element child = DOMUtil.getFirstChildElement(annotationDecl);

        if (child != null) {

            do {

                String name = DOMUtil.getLocalName(child);

                // the only valid children of "annotation" are

                // "appinfo" and "documentation"

                if (!((name.equals(SchemaSymbols.ELT_APPINFO)) ||

                        (name.equals(SchemaSymbols.ELT_DOCUMENTATION)))) {

                    reportSchemaError("src-annotation", new Object[]{name}, child);

                }

                else {

                    // General Attribute Checking

                    // There is no difference between global or local appinfo/documentation,

                    // so we assume it's always global.

                    attrValues = fAttrChecker.checkAttributes(child, true, schemaDoc);

                    fAttrChecker.returnAttrArray(attrValues, schemaDoc);

                }

                child = DOMUtil.getNextSiblingElement(child);

            }

            while (child != null);

        }

        // if contents was null, must have been some kind of error;

        // nothing to contribute to PSVI

        if (contents == null) return null;

        // find the grammar; fSchemaHandler must be known!

        SchemaGrammar grammar = fSchemaHandler.getGrammar(schemaDoc.fTargetNamespace);

        // fish out local attributes passed from parent

        // optimize for case where there are no local attributes

        if(annotationLocalAttrs != null && !annotationLocalAttrs.isEmpty()) {

            localStrBuffer.append(" ");

            int i = 0;

            while (i < annotationLocalAttrs.size()) {

                int colonIndex = rawname.indexOf(':');

                String prefix, localpart;

                if (colonIndex == -1) {

                    prefix = "";

                    localpart = rawname;

                }

                else {

                    prefix = rawname.substring(0,colonIndex);

                    localpart = rawname.substring(colonIndex+1);

                }

                String uri = schemaDoc.fNamespaceSupport.getURI(fSymbolTable.addSymbol(prefix));

                if (annotationDecl.getAttributeNS(uri, localpart).length() != 0) {

                    i++; // skip the next value, too

                    continue;

                }

                localStrBuffer.append(rawname)

                .append("=\"");

                // search for pesky "s and <s within attr value:

                value = processAttValue(value);

                localStrBuffer.append(value)

                .append("\" ");

            }

            // and now splice it into place; immediately after the annotation token, for simplicity's sake

            int annotationTokenEnd = contents.indexOf(SchemaSymbols.ELT_ANNOTATION);

            // annotation must occur somewhere or we're in big trouble...

            if(annotationTokenEnd == -1) return null;

            annotationTokenEnd += SchemaSymbols.ELT_ANNOTATION.length();

            contentBuffer.append(contents.substring(0,annotationTokenEnd));

            contentBuffer.append(localStrBuffer.toString());

            contentBuffer.append(contents.substring(annotationTokenEnd, contents.length()));

            final String annotation = contentBuffer.toString();

            if (fValidateAnnotations) {

                schemaDoc.addAnnotation(new XSAnnotationInfo(annotation, annotationDecl));

            }

            return new XSAnnotationImpl(annotation, grammar);

        } else {

            if (fValidateAnnotations) {

                schemaDoc.addAnnotation(new XSAnnotationInfo(contents, annotationDecl));

            }

            return new XSAnnotationImpl(contents, grammar);

        }

    }

    XSAnnotationImpl traverseSyntheticAnnotation(Element annotationParent, String initialContent,

            Object[] parentAttrs, boolean isGlobal, XSDocumentInfo schemaDoc) {

        String contents = initialContent;

        // find the grammar; fSchemaHandler must be known!

        SchemaGrammar grammar = fSchemaHandler.getGrammar(schemaDoc.fTargetNamespace);

        // fish out local attributes passed from parent

        // optimize for case where there are no local attributes

        if (annotationLocalAttrs != null && !annotationLocalAttrs.isEmpty()) {

            localStrBuffer.append(" ");

            int i = 0;

            while (i < annotationLocalAttrs.size()) {

                int colonIndex = rawname.indexOf(':');

                String prefix, localpart;

                if (colonIndex == -1) {

                    prefix = "";

                    localpart = rawname;

                }

                else {

                    prefix = rawname.substring(0,colonIndex);

                    localpart = rawname.substring(colonIndex+1);

                }

                String uri = schemaDoc.fNamespaceSupport.getURI(fSymbolTable.addSymbol(prefix));

                localStrBuffer.append(rawname)

                .append("=\"");

                // search for pesky "s and <s within attr value:

                value = processAttValue(value);

                localStrBuffer.append(value)

                .append("\" ");

            }

            // and now splice it into place; immediately after the annotation token, for simplicity's sake

            int annotationTokenEnd = contents.indexOf(SchemaSymbols.ELT_ANNOTATION);

            // annotation must occur somewhere or we're in big trouble...

            if(annotationTokenEnd == -1) return null;

            annotationTokenEnd += SchemaSymbols.ELT_ANNOTATION.length();

            contentBuffer.append(contents.substring(0,annotationTokenEnd));

            contentBuffer.append(localStrBuffer.toString());

            contentBuffer.append(contents.substring(annotationTokenEnd, contents.length()));

            final String annotation = contentBuffer.toString();

            if (fValidateAnnotations) {

                schemaDoc.addAnnotation(new XSAnnotationInfo(annotation, annotationParent));

            }

            return new XSAnnotationImpl(annotation, grammar);

        } else {

            if (fValidateAnnotations) {

                schemaDoc.addAnnotation(new XSAnnotationInfo(contents, annotationParent));

            }

            return new XSAnnotationImpl(contents, grammar);

        }

    }

    // the QName simple type used to resolve qnames

    private static final XSSimpleType fQNameDV = (XSSimpleType)SchemaGrammar.SG_SchemaNS.getGlobalTypeDecl(SchemaSymbols.ATTVAL_QNAME);

    // Temp data structures to be re-used in traversing facets

    private final XSFacets xsFacets = new XSFacets();

    static final class FacetInfo {

        final XSFacets facetdata;

        final Element nodeAfterFacets;

        final short fPresentFacets;

        final short fFixedFacets;

        FacetInfo(XSFacets facets, Element nodeAfterFacets, short presentFacets, short fixedFacets) {

            facetdata = facets;

            this.nodeAfterFacets = nodeAfterFacets;

            fPresentFacets = presentFacets;

            fFixedFacets = fixedFacets;

        }

    }

    FacetInfo traverseFacets(Element content,

            XSSimpleType baseValidator,

            XSDocumentInfo schemaDoc) {

        short facetsPresent = 0 ;

        short facetsFixed = 0; // facets that have fixed="true"

        String facet;

        boolean hasQName = containsQName(baseValidator);

        XSObjectListImpl enumAnnotations = null;

        XSObjectListImpl patternAnnotations = null;

        int currentFacet = 0;

        xsFacets.reset();

        while (content != null) {

            // General Attribute Checking

            Object[] attrs = null;

            facet = DOMUtil.getLocalName(content);

            if (facet.equals(SchemaSymbols.ELT_ENUMERATION)) {

                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc, hasQName);

                String enumVal = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                // The facet can't be used if the value is missing. Ignore

                // this facet element.

                if (enumVal == null) {

                    reportSchemaError("s4s-att-must-appear", new Object[]{SchemaSymbols.ELT_ENUMERATION, SchemaSymbols.ATT_VALUE}, content);

                    fAttrChecker.returnAttrArray (attrs, schemaDoc);

                    content = DOMUtil.getNextSiblingElement(content);

                    continue;

                }

                NamespaceSupport nsDecls = (NamespaceSupport)attrs[XSAttributeChecker.ATTIDX_ENUMNSDECLS];

                // for NOTATION types, need to check whether there is a notation

                // declared with the same name as the enumeration value.

                if (baseValidator.getVariety() == XSSimpleType.VARIETY_ATOMIC &&

                        baseValidator.getPrimitiveKind() == XSSimpleType.PRIMITIVE_NOTATION) {

                    // need to use the namespace context returned from checkAttributes

                    schemaDoc.fValidationContext.setNamespaceSupport(nsDecls);

                    Object notation = null;

                    try{

                        QName temp = (QName)fQNameDV.validate(enumVal, schemaDoc.fValidationContext, null);

                        // try to get the notation decl. if failed, getGlobalDecl

                        // reports an error, so we don't need to report one again.

                        notation = fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.NOTATION_TYPE, temp, content);

                    }catch(InvalidDatatypeValueException ex){

                        reportSchemaError(ex.getKey(), ex.getArgs(), content);

                    }

                    if (notation == null) {

                        // Either the QName value is invalid, or it doens't

                        // resolve to a notation declaration.

                        // Ignore this facet, to avoid instance validation problems

                        fAttrChecker.returnAttrArray (attrs, schemaDoc);

                        content = DOMUtil.getNextSiblingElement(content);

                        continue;

                    }

                    // restore to the normal namespace context

                    schemaDoc.fValidationContext.setNamespaceSupport(schemaDoc.fNamespaceSupport);

                }

                if (enumData == null){

                    enumAnnotations = new XSObjectListImpl();

                }

                enumAnnotations.addXSObject(null);

                if (hasQName)

                Element child = DOMUtil.getFirstChildElement( content );

                if (child != null &&

                    DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {

                    // traverse annotation if any

                    enumAnnotations.addXSObject(enumAnnotations.getLength()-1,traverseAnnotationDecl(child, attrs, false, schemaDoc));

                    child = DOMUtil.getNextSiblingElement(child);

                }

                else {

                    String text = DOMUtil.getSyntheticAnnotation(content);

                    if (text != null) {

                        enumAnnotations.addXSObject(enumAnnotations.getLength()-1, traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc));

                    }

                }

                if (child !=null) {

                    reportSchemaError("s4s-elt-must-match.1", new Object[]{"enumeration", "(annotation?)", DOMUtil.getLocalName(child)}, child);

                }

            }

            else if (facet.equals(SchemaSymbols.ELT_PATTERN)) {

                facetsPresent |= XSSimpleType.FACET_PATTERN;

                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc);

                String patternVal = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                // The facet can't be used if the value is missing. Ignore

                // this facet element.

                if (patternVal == null) {

                    reportSchemaError("s4s-att-must-appear", new Object[]{SchemaSymbols.ELT_PATTERN, SchemaSymbols.ATT_VALUE}, content);

                    fAttrChecker.returnAttrArray (attrs, schemaDoc);

                    content = DOMUtil.getNextSiblingElement(content);

                    continue;

                }

                if (fPattern.length() == 0) {

                    fPattern.append(patternVal);

                } else {

                    // ---------------------------------------------

                    //datatypes: 5.2.4 pattern: src-multiple-pattern

                    // ---------------------------------------------

                    fPattern.append("|");

                    fPattern.append(patternVal);

                }

                Element child = DOMUtil.getFirstChildElement( content );

                if (child != null &&

                        DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {

                    // traverse annotation if any

                    if (patternAnnotations == null){

                        patternAnnotations = new XSObjectListImpl();

                    }

                    patternAnnotations.addXSObject(traverseAnnotationDecl(child, attrs, false, schemaDoc));

                    child = DOMUtil.getNextSiblingElement(child);

                }

                else {

                    String text = DOMUtil.getSyntheticAnnotation(content);

                    if (text != null) {

                        if (patternAnnotations == null){

                            patternAnnotations = new XSObjectListImpl();

                        }

                        patternAnnotations.addXSObject(traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc));

                    }

                }

                if (child !=null) {

                    reportSchemaError("s4s-elt-must-match.1", new Object[]{"pattern", "(annotation?)", DOMUtil.getLocalName(child)}, child);

                }

            }

            else {

                if (facet.equals(SchemaSymbols.ELT_MINLENGTH)) {

                    currentFacet = XSSimpleType.FACET_MINLENGTH;

                }

                else if (facet.equals(SchemaSymbols.ELT_MAXLENGTH)) {

                    currentFacet = XSSimpleType.FACET_MAXLENGTH;

                }

                else if (facet.equals(SchemaSymbols.ELT_MAXEXCLUSIVE)) {

                    currentFacet = XSSimpleType.FACET_MAXEXCLUSIVE;

                }

                else if (facet.equals(SchemaSymbols.ELT_MAXINCLUSIVE)) {

                    currentFacet = XSSimpleType.FACET_MAXINCLUSIVE;

                }

                else if (facet.equals(SchemaSymbols.ELT_MINEXCLUSIVE)) {

                    currentFacet = XSSimpleType.FACET_MINEXCLUSIVE;

                }

                else if (facet.equals(SchemaSymbols.ELT_MININCLUSIVE)) {

                    currentFacet = XSSimpleType.FACET_MININCLUSIVE;

                }

                else if (facet.equals(SchemaSymbols.ELT_TOTALDIGITS)) {

                    currentFacet = XSSimpleType.FACET_TOTALDIGITS;

                }

                else if (facet.equals(SchemaSymbols.ELT_FRACTIONDIGITS)) {

                    currentFacet = XSSimpleType.FACET_FRACTIONDIGITS;

                }

                else if (facet.equals(SchemaSymbols.ELT_WHITESPACE)) {

                    currentFacet = XSSimpleType.FACET_WHITESPACE;

                }

                else if (facet.equals(SchemaSymbols.ELT_LENGTH)) {

                    currentFacet = XSSimpleType.FACET_LENGTH;

                }

                else {

                    break;   // a non-facet

                }

                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc);

                // check for duplicate facets

                if ((facetsPresent & currentFacet) != 0) {

                    // Ignore this facet, to avoid corrupting the previous facet

                    reportSchemaError("src-single-facet-value", new Object[]{facet}, content);

                    fAttrChecker.returnAttrArray (attrs, schemaDoc);

                    content = DOMUtil.getNextSiblingElement(content);

                    continue;

                }

                // The facet can't be used if the value is missing. Ignore

                // this facet element.

                if (attrs[XSAttributeChecker.ATTIDX_VALUE] == null) {

                    // Report an error if the "value" attribute is missing.

                    // If it's not missing, then its value is invalid, and an

                    // error should have already been reported by the

                    // attribute checker.

                    if (content.getAttributeNodeNS(null, "value") == null) {

                        reportSchemaError("s4s-att-must-appear", new Object[]{content.getLocalName(), SchemaSymbols.ATT_VALUE}, content);

                    }

                    fAttrChecker.returnAttrArray (attrs, schemaDoc);

                    content = DOMUtil.getNextSiblingElement(content);

                    continue;

                }

                facetsPresent |= currentFacet;

                // check for fixed facet

                if (((Boolean)attrs[XSAttributeChecker.ATTIDX_FIXED]).booleanValue()) {

                    facetsFixed |= currentFacet;

                }

                switch (currentFacet) {

                case XSSimpleType.FACET_MINLENGTH:

                    xsFacets.minLength = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();

                    break;

                case XSSimpleType.FACET_MAXLENGTH:

                    xsFacets.maxLength = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();

                    break;

                case XSSimpleType.FACET_MAXEXCLUSIVE:

                    xsFacets.maxExclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                    break;

                case XSSimpleType.FACET_MAXINCLUSIVE:

                    xsFacets.maxInclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                    break;

                case XSSimpleType.FACET_MINEXCLUSIVE:

                    xsFacets.minExclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                    break;

                case XSSimpleType.FACET_MININCLUSIVE:

                    xsFacets.minInclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];

                    break;

                case XSSimpleType.FACET_TOTALDIGITS:

                    xsFacets.totalDigits = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();

                    break;

                case XSSimpleType.FACET_FRACTIONDIGITS:

                    xsFacets.fractionDigits = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();

                    break;

                case XSSimpleType.FACET_WHITESPACE:

                    xsFacets.whiteSpace = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).shortValue();

                    break;

                case XSSimpleType.FACET_LENGTH:

                    xsFacets.length = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();

                    break;

                }

                Element child = DOMUtil.getFirstChildElement( content );

                XSAnnotationImpl annotation = null;

                if (child != null &&

                    DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {

                    // traverse annotation if any

                    annotation = traverseAnnotationDecl(child, attrs, false, schemaDoc);

                    child = DOMUtil.getNextSiblingElement(child);

                }

                else {

                    String text = DOMUtil.getSyntheticAnnotation(content);

                    if (text != null) {

                        annotation = traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc);

                    }

               }