/*
 * Copyright 2001-2004 The Apache Software Foundation.
 *
 * Licensed 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 org.apache.axis.encoding;

import org.apache.axis.MessageContext;
import org.apache.axis.Constants;
import org.apache.axis.Message;
import org.apache.axis.AxisFault;
import org.apache.axis.constants.Use;
import org.apache.axis.attachments.Attachments;
import org.apache.axis.description.TypeDesc;
import org.apache.axis.soap.SOAPConstants;
import org.apache.axis.utils.NSStack;
import org.apache.axis.utils.XMLUtils;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.Messages;
import org.apache.axis.utils.cache.MethodCache;
import org.apache.axis.schema.SchemaVersion;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.message.IDResolver;
import org.apache.axis.message.MessageElement;
import org.apache.axis.message.SAX2EventRecorder;
import org.apache.axis.message.SOAPEnvelope;
import org.apache.axis.message.SOAPHandler;
import org.apache.axis.message.EnvelopeBuilder;
import org.apache.axis.message.EnvelopeHandler;
import org.apache.axis.message.NullAttributes;
import org.apache.commons.logging.Log;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.Locator;
import org.xml.sax.InputSource;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;

import javax.xml.namespace.QName;
import javax.xml.parsers.SAXParser;
import javax.xml.rpc.JAXRPCException;
import java.util.ArrayList;
import java.util.HashMap;
import java.io.IOException;
import java.lang.reflect.Method;

/**
 * This interface describes the AXIS DeserializationContext, note that
 * an AXIS compliant DeserializationContext must extend the org.xml.sax.helpers.DefaultHandler.
 */

public class DeserializationContext extends DefaultHandler
        implements javax.xml.rpc.encoding.DeserializationContext, LexicalHandler {
    protected static Log log =
            LogFactory.getLog(DeserializationContext.class.getName());

    // invariant member variable to track low-level logging requirements
    // we cache this once per instance lifecycle to avoid repeated lookups
    // in heavily used code.
    private final boolean debugEnabled = log.isDebugEnabled();

    static final SchemaVersion schemaVersions[] = new SchemaVersion [] {
        SchemaVersion.SCHEMA_1999,
        SchemaVersion.SCHEMA_2000,
        SchemaVersion.SCHEMA_2001,
    };

    private NSStack namespaces = new NSStack();

    private Locator locator;

    // Class used for deserialization using class metadata from
    // downstream deserializers
    private Class destClass;

    // for performance reasons, keep the top of the stack separate from
    // the remainder of the handlers, and therefore readily available.
    private SOAPHandler topHandler = null;
    private ArrayList pushedDownHandlers = new ArrayList();

    //private SAX2EventRecorder recorder = new SAX2EventRecorder();
    private SAX2EventRecorder recorder = null;
    private SOAPEnvelope envelope;

    /* A map of IDs -> IDResolvers */
    private HashMap idMap;
    private LocalIDResolver localIDs;

    private HashMap fixups;

    static final SOAPHandler nullHandler = new SOAPHandler();

    protected MessageContext msgContext;

    private boolean doneParsing = false;
    protected InputSource inputSource = null;

    private MessageElement curElement;

    protected int startOfMappingsPos = -1;

    private static final Class[] DESERIALIZER_CLASSES =
            new Class[] {String.class, Class.class, QName.class};
    private static final String DESERIALIZER_METHOD = "getDeserializer";

    // This is a hack to associate the first schema namespace we see with
    // the correct SchemaVersion.  It assumes people won't often be mixing
    // schema versions in a given document, which I think is OK. --Glen
    protected boolean haveSeenSchemaNS = false;

    public void deserializing(boolean isDeserializing) {
        doneParsing = isDeserializing;
    }

    /**
     * Construct Deserializer using MessageContext and EnvelopeBuilder handler
     * @param ctx is the MessageContext
     * @param initialHandler is the EnvelopeBuilder handler
     */
    public DeserializationContext(MessageContext ctx,
                                  SOAPHandler initialHandler)
    {
        msgContext = ctx;

        // If high fidelity is required, record the whole damn thing.
        if (ctx == null || ctx.isHighFidelity())
            recorder = new SAX2EventRecorder();

        if (initialHandler instanceof EnvelopeBuilder) {
            envelope = ((EnvelopeBuilder)initialHandler).getEnvelope();
            envelope.setRecorder(recorder);
        }

        pushElementHandler(new EnvelopeHandler(initialHandler));
    }

    /**
     * Construct Deserializer
     * @param is is the InputSource
     * @param ctx is the MessageContext
     * @param messageType is the MessageType to construct an EnvelopeBuilder
     */
    public DeserializationContext(InputSource is,
                                  MessageContext ctx,
                                  String messageType)
    {
        msgContext = ctx;
        EnvelopeBuilder builder = new EnvelopeBuilder(messageType, null);
        // If high fidelity is required, record the whole damn thing.
        if (ctx == null || ctx.isHighFidelity())
            recorder = new SAX2EventRecorder();

        envelope = builder.getEnvelope();
        envelope.setRecorder(recorder);

        pushElementHandler(new EnvelopeHandler(builder));

        inputSource = is;
    }

    private SOAPConstants soapConstants = null;

    /**
     * returns the soap constants.
     */
    public SOAPConstants getSOAPConstants(){
        if (soapConstants != null)
            return soapConstants;
        if (msgContext != null) {
            soapConstants = msgContext.getSOAPConstants();
            return soapConstants;
        } else {
            return Constants.DEFAULT_SOAP_VERSION;
        }
    }

    /**
     * Construct Deserializer
     * @param is is the InputSource
     * @param ctx is the MessageContext
     * @param messageType is the MessageType to construct an EnvelopeBuilder
     * @param env is the SOAPEnvelope to construct an EnvelopeBuilder
     */
    public DeserializationContext(InputSource is,
                                  MessageContext ctx,
                                  String messageType,
                                  SOAPEnvelope env)
    {
        EnvelopeBuilder builder = new EnvelopeBuilder(env, messageType);

        msgContext = ctx;

        // If high fidelity is required, record the whole damn thing.
        if (ctx == null || ctx.isHighFidelity())
            recorder = new SAX2EventRecorder();

        envelope = builder.getEnvelope();
        envelope.setRecorder(recorder);

        pushElementHandler(new EnvelopeHandler(builder));

        inputSource = is;
    }

    /**
     * Create a parser and parse the inputSource
     */
    public void parse() throws SAXException
    {
        if (inputSource != null) {
            SAXParser parser = XMLUtils.getSAXParser();
            try {
                parser.setProperty("http://xml.org/sax/properties/lexical-handler", this);
                parser.parse(inputSource, this);

                try {
                    // cleanup - so that the parser can be reused.
                    parser.setProperty("http://xml.org/sax/properties/lexical-handler", nullLexicalHandler);
                } catch (Exception e){
                    // Ignore.
                }

                // only release the parser for reuse if there wasn't an
                // error.  While parsers should be reusable, don't trust
                // parsers that died to clean up appropriately.
                XMLUtils.releaseSAXParser(parser);
            } catch (IOException e) {
                throw new SAXException(e);
            }
            inputSource = null;
        }
    }

    /**
     * Get current MessageElement
     **/
    public MessageElement getCurElement() {
        return curElement;
    }

    /**
     * Set current MessageElement
     **/
    public void setCurElement(MessageElement el)
    {
        curElement = el;
        if (curElement != null && curElement.getRecorder() != recorder) {
            recorder = curElement.getRecorder();
        }
    }


    /**
     * Get MessageContext
     */
    public MessageContext getMessageContext()
    {
        return msgContext;
    }

    /**
     * Returns this context's encoding style.  If we've got a message
     * context then we'll get the style from that; otherwise we'll
     * return a default.
     *
     * @return a <code>String</code> value
     */
    public String getEncodingStyle() 
    {
        return msgContext == null ?
                Use.ENCODED.getEncoding() : msgContext.getEncodingStyle();
    }    

    /**
     * Get Envelope
     */
    public SOAPEnvelope getEnvelope()
    {
        return envelope;
    }

    /**
     * Get Event Recorder
     */
    public SAX2EventRecorder getRecorder()
    {
        return recorder;
    }

    /**
     * Set Event Recorder
     */
    public void setRecorder(SAX2EventRecorder recorder)
    {
        this.recorder = recorder;
    }

    /**
     * Get the Namespace Mappings.  Returns null if none are present.
     **/
    public ArrayList getCurrentNSMappings()
    {
        return namespaces.cloneFrame();
    }

    /**
     * Get the Namespace for a particular prefix
     */
    public String getNamespaceURI(String prefix)
    {
        String result = namespaces.getNamespaceURI(prefix);
        if (result != null)
            return result;

        if (curElement != null)
            return curElement.getNamespaceURI(prefix);

        return null;
    }

    /**
     * Construct a QName from a string of the form <prefix>:<localName>
     * @param qNameStr is the prefixed name from the xml text
     * @return QName
     */
    public QName getQNameFromString(String qNameStr)
    {
        if (qNameStr == null)
            return null;

        // OK, this is a QName, so look up the prefix in our current mappings.
        int i = qNameStr.indexOf(':');
        String nsURI;
        if (i == -1) {
            nsURI = getNamespaceURI("");
        } else {
            nsURI = getNamespaceURI(qNameStr.substring(0, i));
        }

        return new QName(nsURI, qNameStr.substring(i + 1));
    }

    /**
     * Create a QName for the type of the element defined by localName and
     * namespace from the XSI type.
     * @param namespace of the element
     * @param localName is the local name of the element
     * @param attrs are the attributes on the element
     */
    public QName getTypeFromXSITypeAttr(String namespace, String localName,
                                          Attributes attrs) {
        // Check for type
        String type = Constants.getValue(attrs, Constants.URIS_SCHEMA_XSI,
                                         "type");
        if (type != null) {
            // Return the type attribute value converted to a QName
            return getQNameFromString(type);
        }
        return null;
    }

    /**
     * Create a QName for the type of the element defined by localName and
     * namespace with the specified attributes.
     * @param namespace of the element
     * @param localName is the local name of the element
     * @param attrs are the attributes on the element
     */
    public QName getTypeFromAttributes(String namespace, String localName,
                                       Attributes attrs)
    {
        QName typeQName = getTypeFromXSITypeAttr(namespace, localName, attrs);
        if ( (typeQName == null) && Constants.isSOAP_ENC(namespace) ) {

            // If the element is a SOAP-ENC element, the name of the element is the type.
            // If the default type mapping accepts SOAP 1.2, then use then set
            // the typeQName to the SOAP-ENC type.
            // Else if the default type mapping accepts SOAP 1.1, then
            // convert the SOAP-ENC type to the appropriate XSD Schema Type.
            if (namespace.equals(Constants.URI_SOAP12_ENC)) {
                typeQName = new QName(namespace, localName);
            } else if (localName.equals(Constants.SOAP_ARRAY.getLocalPart())) {
                typeQName = Constants.SOAP_ARRAY;
            } else if (localName.equals(Constants.SOAP_STRING.getLocalPart())) {
                typeQName = Constants.SOAP_STRING;
            } else if (localName.equals(Constants.SOAP_BOOLEAN.getLocalPart())) {
                typeQName = Constants.SOAP_BOOLEAN;
            } else if (localName.equals(Constants.SOAP_DOUBLE.getLocalPart())) {
                typeQName = Constants.SOAP_DOUBLE;
            } else if (localName.equals(Constants.SOAP_FLOAT.getLocalPart())) {
                typeQName = Constants.SOAP_FLOAT;
            } else if (localName.equals(Constants.SOAP_INT.getLocalPart())) {
                typeQName = Constants.SOAP_INT;
            } else if (localName.equals(Constants.SOAP_LONG.getLocalPart())) {
                typeQName = Constants.SOAP_LONG;
            } else if (localName.equals(Constants.SOAP_SHORT.getLocalPart())) {
                typeQName = Constants.SOAP_SHORT;
            } else if (localName.equals(Constants.SOAP_BYTE.getLocalPart())) {
                typeQName = Constants.SOAP_BYTE;
            }
        }

        // If we still have no luck, check to see if there's an arrayType
        // (itemType for SOAP 1.2) attribute, in which case this is almost
        // certainly an array.

        if (typeQName == null && attrs != null) {
            String encURI = getSOAPConstants().getEncodingURI();
            String itemType = getSOAPConstants().getAttrItemType();
            for (int i = 0; i < attrs.getLength(); i++) {
                if (encURI.equals(attrs.getURI(i)) &&
                        itemType.equals(attrs.getLocalName(i))) {
                    return new QName(encURI, "Array");
                }
            }
        }

        return typeQName;
    }

    /**
     * Convenenience method that returns true if the value is nil
     * (due to the xsi:nil) attribute.
     * @param attrs are the element attributes.
     * @return true if xsi:nil is true
     */
    public boolean isNil(Attributes attrs) {
        return JavaUtils.isTrueExplicitly(
                    Constants.getValue(attrs, Constants.QNAMES_NIL),
                    false);
    }

    /**
     * Get a Deserializer which can turn a given xml type into a given
     * Java type
     */
    public final Deserializer getDeserializer(Class cls, QName xmlType) {
        if (xmlType == null)
            return null;

        DeserializerFactory dserF = null;
        Deserializer dser = null;
        try {
            dserF = (DeserializerFactory) getTypeMapping().
                    getDeserializer(cls, xmlType);
        } catch (JAXRPCException e) {
            log.error(Messages.getMessage("noFactory00", xmlType.toString()));
        }
        if (dserF != null) {
            try {
                dser = (Deserializer) dserF.getDeserializerAs(Constants.AXIS_SAX);
            } catch (JAXRPCException e) {
                log.error(Messages.getMessage("noDeser00", xmlType.toString()));
            }
        }
        return dser;
    }

    /**
     * Convenience method to get the Deserializer for a specific
     * java class from its meta data.
     * @param cls is the Class used to find the deserializer
     * @return Deserializer
     */
    public Deserializer getDeserializerForClass(Class cls) {
        if (cls == null) {
           cls = destClass;
        }
        if (cls == null) {
            return null;
        }
//        if (cls.isArray()) {
//            cls = cls.getComponentType();
//        }
        if (javax.xml.rpc.holders.Holder.class.isAssignableFrom(cls)) {
            try {
                cls = cls.getField("value").getType();
            } catch (Exception e) {
            }
        }

        Deserializer dser = null;

        QName type = getTypeMapping().getTypeQName(cls);
        dser = getDeserializer(cls, type);
        if (dser != null)
            return dser;

        try {
            Method method = 
                MethodCache.getInstance().getMethod(cls,
                                                    DESERIALIZER_METHOD, 
                                                    DESERIALIZER_CLASSES);     
            if (method != null) {
                TypeDesc typedesc = TypeDesc.getTypeDescForClass(cls);
                if (typedesc != null) {
                    dser = (Deserializer) method.invoke(null,
                        new Object[] {getEncodingStyle(), cls, typedesc.getXmlType()});
                }
            }
        } catch (Exception e) {
            log.error(Messages.getMessage("noDeser00", cls.getName()));
        }
        return dser;
    }

     /**
     * Allows the destination class to be set so that downstream
     * deserializers like ArrayDeserializer can pick it up when
     * deserializing its components using getDeserializerForClass
     * @param destClass is the Class of the component to be deserialized
     */
    public void setDestinationClass(Class destClass) {
        this.destClass = destClass;
    }

    /**
     * Allows the destination class to be retrieved so that downstream
     * deserializers like ArrayDeserializer can pick it up when
     * deserializing its components using getDeserializerForClass
     * @return the Class of the component to be deserialized
     */
    public Class getDestinationClass() {
        return destClass;
    }

    /**
     * Convenience method to get the Deserializer for a specific
     * xmlType.
     * @param xmlType is QName for a type to deserialize
     * @return Deserializer
     */
    public final Deserializer getDeserializerForType(QName xmlType) {
        return getDeserializer(null, xmlType);
    }

    /**
     * Get the TypeMapping for this DeserializationContext
     */
    public TypeMapping getTypeMapping()
    {
        if (msgContext == null || msgContext.getTypeMappingRegistry() == null) {
            return (TypeMapping) new org.apache.axis.encoding.TypeMappingRegistryImpl().getTypeMapping(
                    null);
        }
        TypeMappingRegistry tmr = msgContext.getTypeMappingRegistry();
        return (TypeMapping) tmr.getTypeMapping(getEncodingStyle());
    }

    /**
     * Get the TypeMappingRegistry we're using.
     * @return TypeMapping or null
     */
    public TypeMappingRegistry getTypeMappingRegistry() {
        return msgContext.getTypeMappingRegistry();
    }

    /**
     * Get the MessageElement for the indicated id (where id is the #value of an href)
     * If the MessageElement has not been processed, the MessageElement will
     * be returned.  If the MessageElement has been processed, the actual object
     * value is stored with the id and this routine will return null.
     * @param id is the value of an href attribute
     * @return MessageElement or null
     */
    public MessageElement getElementByID(String id)
    {
        if((idMap !=  null)) {
            IDResolver resolver = (IDResolver)idMap.get(id);
            if(resolver != null) {
                Object ret = resolver.getReferencedObject(id);
                if (ret instanceof MessageElement)
                    return (MessageElement)ret;
            }
        }

        return null;
    }

    /**
     * Gets the MessageElement or actual Object value associated with the href value.
     * The return of a MessageElement indicates that the referenced element has
     * not been processed.  If it is not a MessageElement, the Object is the
     * actual deserialized value.
     * In addition, this method is invoked to get Object values via Attachments.
     * @param href is the value of an href attribute (or an Attachment id)
     * @return MessageElement other Object or null
     */
    public Object getObjectByRef(String href) {
        Object ret= null;
        if(href != null){
            if((idMap !=  null)){
                IDResolver resolver = (IDResolver)idMap.get(href);
                if(resolver != null)
                   ret = resolver.getReferencedObject(href);
            }
            if( null == ret && !href.startsWith("#")){
                //Could this be an attachment?
                Message msg= null;
                if(null != (msg=msgContext.getCurrentMessage())){
                    Attachments attch= null;
                    if( null != (attch= msg.getAttachmentsImpl())){
                        try{
                        ret= attch.getAttachmentByReference(href);
                        }catch(AxisFault e){
                            throw new RuntimeException(e.toString() + JavaUtils.stackToString(e));
                        }
                    }
                }
            }
        }

        return ret;
    }

    /**
     * Add the object associated with this id (where id is the value of an id= attribute,
     * i.e. it does not start with #).
     * This routine is called to associate the deserialized object
     * with the id specified on the XML element.
     * @param id (id name without the #)
     * @param obj is the deserialized object for this id.
     */
    public void addObjectById(String id, Object obj)
    {
        // The resolver uses the href syntax as the key.
        String idStr = '#' + id;
        if ((idMap == null) || (id == null))
            return ;

        IDResolver resolver = (IDResolver)idMap.get(idStr);
        if (resolver == null)
            return ;

        resolver.addReferencedObject(idStr, obj);
        return;
    }

    /**
     * During deserialization, an element with an href=#id<int>
     * may be encountered before the element defining id=id<int> is
     * read.  In these cases, the getObjectByRef method above will
     * return null.  The deserializer is placed in a table keyed
     * by href (a fixup table). After the element id is processed,
     * the deserializer is informed of the value so that it can
     * update its target(s) with the value.
     * @param href (#id syntax)
     * @param dser is the deserializer of the element
     */
    public void registerFixup(String href, Deserializer dser)
    {
        if (fixups == null)
            fixups = new HashMap();

        Deserializer prev = (Deserializer) fixups.put(href, dser);

        // There could already be a deserializer in the fixup list
        // for this href.  If so, the easiest way to get all of the
        // targets updated is to move the previous deserializers
        // targets to dser.
        if (prev != null && prev != dser) {
            dser.moveValueTargets(prev);
            if (dser.getDefaultType() == null) {
                dser.setDefaultType(prev.getDefaultType());
            }
        }
    }

    /**
     * Register the MessageElement with this id (where id is id= form without the #)
     * This routine is called when the MessageElement with an id is read.
     * If there is a Deserializer in our fixup list (described above),
     * the 'fixup' deserializer is given to the MessageElement.  When the
     * MessageElement is completed, the 'fixup' deserializer is informed and
     * it can set its targets.
     * @param id (id name without the #)
     * @param elem is the MessageElement
     */
    public void registerElementByID(String id, MessageElement elem)
    {
        if (localIDs == null)
            localIDs = new LocalIDResolver();

        String absID = '#' + id;

        localIDs.addReferencedObject(absID, elem);

        registerResolverForID(absID, localIDs);

        if (fixups != null) {
            Deserializer dser = (Deserializer)fixups.get(absID);
            if (dser != null) {
                elem.setFixupDeserializer(dser);
            }
        }
    }

    /**
     * Each id can have its own kind of resolver.  This registers a
     * resolver for the id.
     */
    public void registerResolverForID(String id, IDResolver resolver)
    {
        if ((id == null) || (resolver == null)) {
            // ??? Throw nullPointerException?
            return;
        }

        if (idMap == null)
            idMap = new HashMap();

        idMap.put(id, resolver);
    }

    /**
     * Return true if any ids are being tracked by this DeserializationContext
     *
     * @return true if any ides are being tracked by this DeserializationContext
     */
    public boolean hasElementsByID()
    {
        return idMap == null ? false : idMap.size() > 0;
    }

    /**
     * Get the current position in the record.
     */
    public int getCurrentRecordPos()
    {
        if (recorder == null) return -1;
        return recorder.getLength() - 1;
    }

    /**
     * Get the start of the mapping position
     */
    public int getStartOfMappingsPos()
    {
        if (startOfMappingsPos == -1) {
            return getCurrentRecordPos() + 1;
        }

        return startOfMappingsPos;
    }

    /**
     * Push the MessageElement into the recorder
     */
    public void pushNewElement(MessageElement elem)
    {
        if (debugEnabled) {
            log.debug("Pushing element " + elem.getName());
        }

        if (!doneParsing && (recorder != null)) {
            recorder.newElement(elem);
        }

        try {
            if(curElement != null)
                elem.setParentElement(curElement);
        } catch (Exception e) {
            /*
             * The only checked exception that may be thrown from setParent
             * occurs if the parent already has an explicit object value,
             * which should never occur during deserialization.
             */
            log.fatal(Messages.getMessage("exception00"), e);
        }
        curElement = elem;

        if (elem.getRecorder() != recorder)
            recorder = elem.getRecorder();
    }

    /****************************************************************
     * Management of sub-handlers (deserializers)
     */

    public void pushElementHandler(SOAPHandler handler)
    {
        if (debugEnabled) {
            log.debug(Messages.getMessage("pushHandler00", "" + handler));
        }

        if (topHandler != null) pushedDownHandlers.add(topHandler);
        topHandler = handler;
    }

    /** Replace the handler at the top of the stack.
     *
     * This is only used when we have a placeholder Deserializer
     * for a referenced object which doesn't know its type until we
     * hit the referent.
     */
    public void replaceElementHandler(SOAPHandler handler)
    {
        topHandler = handler;
    }

    public SOAPHandler popElementHandler()
    {
        SOAPHandler result = topHandler;

        int size = pushedDownHandlers.size();
        if (size > 0) {
            topHandler = (SOAPHandler) pushedDownHandlers.remove(size-1);
        } else {
            topHandler = null;
        }

        if (debugEnabled) {
            if (result == null) {
                log.debug(Messages.getMessage("popHandler00", "(null)"));
            } else {
                log.debug(Messages.getMessage("popHandler00", "" + result));
            }
        }

        return result;
    }

    boolean processingRef = false;
    public void setProcessingRef(boolean ref) {
        processingRef = ref;
    }
    public boolean isProcessingRef() {
        return processingRef;
    }

    /****************************************************************
     * SAX event handlers
     */
    public void startDocument() throws SAXException {
        // Should never receive this in the midst of a parse.
        if (!doneParsing && (recorder != null))
            recorder.startDocument();
    }

    /**
     * endDocument is invoked at the end of the document.
     */
    public void endDocument() throws SAXException {
        if (debugEnabled) {
            log.debug("Enter: DeserializationContext::endDocument()");
        }
        if (!doneParsing && (recorder != null))
            recorder.endDocument();

        doneParsing = true;

        if (debugEnabled) {
            log.debug("Exit: DeserializationContext::endDocument()");
        }
    }
    /**
     * Return if done parsing document.
     */
    public boolean isDoneParsing() {return doneParsing;}

    /** Record the current set of prefix mappings in the nsMappings table.
     *
     * !!! We probably want to have this mapping be associated with the
     *     MessageElements, since they may potentially need access to them
     *     long after the end of the prefix mapping here.  (example:
     *     when we need to record a long string of events scanning forward
     *     in the document to find an element with a particular ID.)
     */
    public void startPrefixMapping(String prefix, String uri)
        throws SAXException
    {
        if (debugEnabled) {
            log.debug("Enter: DeserializationContext::startPrefixMapping(" + prefix + ", " + uri + ")");
        }

        if (!doneParsing && (recorder != null)) {
            recorder.startPrefixMapping(prefix, uri);
        }

        if (startOfMappingsPos == -1) {
            namespaces.push();
            startOfMappingsPos = getCurrentRecordPos();
        }

        if (prefix != null) {
            namespaces.add(uri, prefix);
        } else {
            namespaces.add(uri, "");
        }

        if (!haveSeenSchemaNS && msgContext != null) {
            // If we haven't yet seen a schema namespace, check if this
            // is one.  If so, set the SchemaVersion appropriately.
            // Hopefully the schema def is on the outermost element so we
            // get this over with quickly.
            for (int i = 0; !haveSeenSchemaNS && i < schemaVersions.length;
                 i++) {
                SchemaVersion schemaVersion = schemaVersions[i];
                if (uri.equals(schemaVersion.getXsdURI()) ||
                        uri.equals(schemaVersion.getXsiURI())) {
                    msgContext.setSchemaVersion(schemaVersion);
                    haveSeenSchemaNS = true;
                }
            }
        }

        if (topHandler != null) {
            topHandler.startPrefixMapping(prefix, uri);
        }

        if (debugEnabled) {
            log.debug("Exit: DeserializationContext::startPrefixMapping()");
        }
    }

    public void endPrefixMapping(String prefix)
        throws SAXException
    {
        if (debugEnabled) {
            log.debug("Enter: DeserializationContext::endPrefixMapping(" + prefix + ")");
        }

        if (!doneParsing && (recorder != null)) {
            recorder.endPrefixMapping(prefix);
        }

        if (topHandler != null) {
            topHandler.endPrefixMapping(prefix);
        }

        if (debugEnabled) {
            log.debug("Exit: DeserializationContext::endPrefixMapping()");
        }
    }

    public void setDocumentLocator(Locator locator)
    {
        if (!doneParsing && (recorder != null)) {
            recorder.setDocumentLocator(locator);
        }
        this.locator = locator;
    }

    public Locator getDocumentLocator() {
        return locator;
    }

    public void characters(char[] p1, int p2, int p3) throws SAXException {
        if (!doneParsing && (recorder != null)) {
            recorder.characters(p1, p2, p3);
        }
        if (topHandler != null) {
            topHandler.characters(p1, p2, p3);
        }
    }

    public void ignorableWhitespace(char[] p1, int p2, int p3) throws SAXException {
        if (!doneParsing && (recorder != null)) {
            recorder.ignorableWhitespace(p1, p2, p3);
        }
        if (topHandler != null) {
            topHandler.ignorableWhitespace(p1, p2, p3);
        }
    }

    public void processingInstruction(String p1, String p2) throws SAXException {
        // must throw an error since SOAP 1.1 doesn't allow
        // processing instructions anywhere in the message
        throw new SAXException(Messages.getMessage("noInstructions00"));
    }

    public void skippedEntity(String p1) throws SAXException {
        if (!doneParsing && (recorder != null)) {
            recorder.skippedEntity(p1);
        }
        topHandler.skippedEntity(p1);
    }

    /**
     * startElement is called when an element is read.  This is the big work-horse.
     *
     * This guy also handles monitoring the recording depth if we're recording
     * (so we know when to stop).
     */
    public void startElement(String namespace, String localName,
                             String qName, Attributes attributes)
        throws SAXException
    {
        if (debugEnabled) {
            log.debug("Enter: DeserializationContext::startElement(" + namespace + ", " + localName + ")");
        }

        if (attributes == null || attributes.getLength() == 0) {
            attributes = NullAttributes.singleton;
        } else {
            attributes = new AttributesImpl(attributes);

            SOAPConstants soapConstants = getSOAPConstants();
            if (soapConstants == SOAPConstants.SOAP12_CONSTANTS) {
                if (attributes.getValue(soapConstants.getAttrHref()) != null &&
                    attributes.getValue(Constants.ATTR_ID) != null) {

                    AxisFault fault = new AxisFault(Constants.FAULT_SOAP12_SENDER,
                        null, Messages.getMessage("noIDandHREFonSameElement"), null, null, null);

                    throw new SAXException(fault);

                }
            }

        }

        SOAPHandler nextHandler = null;

        String prefix = "";
        int idx = qName.indexOf(':');
        if (idx > 0) {
            prefix = qName.substring(0, idx);
        }

        if (topHandler != null) {
            nextHandler = topHandler.onStartChild(namespace,
                                                       localName,
                                                       prefix,
                                                       attributes,
                                                       this);
        }

        if (nextHandler == null) {
            nextHandler = new SOAPHandler();
        }

        pushElementHandler(nextHandler);

        nextHandler.startElement(namespace, localName, prefix,
                                 attributes, this);

        if (!doneParsing && (recorder != null)) {
            recorder.startElement(namespace, localName, qName,
                                  attributes);
            if (!doneParsing) {
                curElement.setContentsIndex(recorder.getLength());
            }
        }

        if (startOfMappingsPos != -1) {
            startOfMappingsPos = -1;
        } else {
            // Push an empty frame if there are no mappings
            namespaces.push();
        }

        if (debugEnabled) {
            log.debug("Exit: DeserializationContext::startElement()");
        }
    }

    /**
     * endElement is called at the end tag of an element
     */
    public void endElement(String namespace, String localName, String qName)
        throws SAXException
    {
        if (debugEnabled) {
            log.debug("Enter: DeserializationContext::endElement(" + namespace + ", " + localName + ")");
        }

        if (!doneParsing && (recorder != null)) {
            recorder.endElement(namespace, localName, qName);
        }

        try {
            SOAPHandler handler = popElementHandler();
            handler.endElement(namespace, localName, this);

            if (topHandler != null) {
                topHandler.onEndChild(namespace, localName, this);
            } else {
                // We should be done!
            }

        } finally {
            if (curElement != null) {
                curElement = (MessageElement)curElement.getParentElement();
            }

            namespaces.pop();

            if (debugEnabled) {
                String name = curElement != null ?
                        curElement.getClass().getName() + ":" +
                        curElement.getName() : null;
                log.debug("Popped element stack to " + name);
                log.debug("Exit: DeserializationContext::endElement()");
            }
        }
    }

    /**
     * This class is used to map ID's to an actual value Object or Message
     */
    private static class LocalIDResolver implements IDResolver
    {
        HashMap idMap = null;

        /**
         * Add object associated with id
         */
        public void addReferencedObject(String id, Object referent)
        {
            if (idMap == null) {
                idMap = new HashMap();
            }

            idMap.put(id, referent);
        }

        /**
         * Get object referenced by href
         */
        public Object getReferencedObject(String href)
        {
            if ((idMap == null) || (href == null)) {
                return null;
            }
            return idMap.get(href);
        }
    }

    public void startDTD(java.lang.String name,
                     java.lang.String publicId,
                     java.lang.String systemId)
              throws SAXException
    {
        /* It is possible for a malicious user to send us bad stuff in
           the <!DOCTYPE ../> tag that will cause a denial of service
           Example:
           <?xml version="1.0" ?>
            <!DOCTYPE foobar [
                <!ENTITY x0 "hello">
                <!ENTITY x1 "&x0;&x0;">
                <!ENTITY x2 "&x1;&x1;">
                  ...
                <!ENTITY x99 "&x98;&x98;">
                <!ENTITY x100 "&x99;&x99;">
            ]>
        */
        throw new SAXException(Messages.getMessage("noInstructions00"));
        /* if (recorder != null)
            recorder.startDTD(name, publicId, systemId);
        */
    }

    public void endDTD()
            throws SAXException
    {
        if (recorder != null)
            recorder.endDTD();
    }

    public void startEntity(java.lang.String name)
                 throws SAXException
    {
        if (recorder != null)
            recorder.startEntity(name);
    }

    public void endEntity(java.lang.String name)
               throws SAXException
    {
        if (recorder != null)
            recorder.endEntity(name);
    }

    public void startCDATA()
                throws SAXException
    {
        if (recorder != null)
            recorder.startCDATA();
    }

    public void endCDATA()
              throws SAXException
    {
        if (recorder != null)
            recorder.endCDATA();
    }

    public void comment(char[] ch,
                    int start,
                    int length)
             throws SAXException
    {
        if (recorder != null)
            recorder.comment(ch, start, length);
    }

    public InputSource resolveEntity(String publicId, String systemId)
    {
        return XMLUtils.getEmptyInputSource();
    }


    /** We only need one instance of this dummy handler to set into the parsers. */
    private static final NullLexicalHandler nullLexicalHandler = new NullLexicalHandler();

    /**
     * It is illegal to set the lexical-handler property to null. To facilitate
     * discarding the heavily loaded instance of DeserializationContextImpl from
     * the SAXParser instance that is kept in the Stack maintained by XMLUtils
     * we use this class.
     */
    private static class NullLexicalHandler implements LexicalHandler {
    	public void startDTD(String arg0, String arg1, String arg2) throws SAXException {}
    	public void endDTD() throws SAXException {}
    	public void startEntity(String arg0) throws SAXException {}
    	public void endEntity(String arg0) throws SAXException {}
    	public void startCDATA() throws SAXException {}
    	public void endCDATA() throws SAXException {}
    	public void comment(char[] arg0, int arg1, int arg2) throws SAXException {}
    }
}