/*

 */

/*

 * 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.dom;

import com.sun.org.apache.xerces.internal.impl.Constants;

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

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

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

import com.sun.org.apache.xerces.internal.utils.ObjectFactory;

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

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamField;

import java.lang.reflect.Constructor;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Map;

import jdk.xml.internal.SecuritySupport;

import org.w3c.dom.Attr;

import org.w3c.dom.CDATASection;

import org.w3c.dom.Comment;

import org.w3c.dom.DOMConfiguration;

import org.w3c.dom.DOMException;

import org.w3c.dom.DOMImplementation;

import org.w3c.dom.Document;

import org.w3c.dom.DocumentFragment;

import org.w3c.dom.DocumentType;

import org.w3c.dom.Element;

import org.w3c.dom.Entity;

import org.w3c.dom.EntityReference;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Notation;

import org.w3c.dom.ProcessingInstruction;

import org.w3c.dom.Text;

import org.w3c.dom.UserDataHandler;

import org.w3c.dom.events.Event;

import org.w3c.dom.events.EventListener;

import org.w3c.dom.ls.DOMImplementationLS;

import org.w3c.dom.ls.LSSerializer;

/**

 * The Document interface represents the entire HTML or XML document.

 * Conceptually, it is the root of the document tree, and provides the

 * primary access to the document's data.

 * <P>

 * Since elements, text nodes, comments, processing instructions,

 * etc. cannot exist outside the context of a Document, the Document

 * interface also contains the factory methods needed to create these

 * objects. The Node objects created have a ownerDocument attribute

 * which associates them with the Document within whose context they

 * were created.

 * <p>

 * The CoreDocumentImpl class only implements the DOM Core. Additional modules

 * are supported by the more complete DocumentImpl subclass.

 * <p>

 * <b>Note:</b> When any node in the document is serialized, the

 * entire document is serialized along with it.

 *

 * @xerces.internal

 *

 * @author Arnaud  Le Hors, IBM

 * @author Joe Kesselman, IBM

 * @author Andy Clark, IBM

 * @author Ralf Pfeiffer, IBM

 * @since  PR-DOM-Level-1-19980818.

 */

public class CoreDocumentImpl

        extends ParentNode implements Document {

    /**

     * TODO:: 1. Change XML11Char method names similar to XMLChar. That will

     * prevent lot of dirty version checking code.

     *

     * 2. IMO during cloneNode qname/isXMLName check should not be made.

     */

    //

    // Constants

    //

    /** Serialization version. */

    static final long serialVersionUID = 0;

    //

    // Data

    //

    // document information

    /** Document type. */

    protected DocumentTypeImpl docType;

    /** Document element. */

    protected ElementImpl docElement;

    /** NodeListCache free list */

    transient NodeListCache fFreeNLCache;

    /**Experimental DOM Level 3 feature: Document encoding */

    protected String encoding;

    /**Experimental DOM Level 3 feature: Document actualEncoding */

    protected String actualEncoding;

    /**Experimental DOM Level 3 feature: Document version */

    protected String version;

    /**Experimental DOM Level 3 feature: Document standalone */

    protected boolean standalone;

    /**Experimental DOM Level 3 feature: documentURI */

    protected String fDocumentURI;

    //Revisit :: change to a better data structure.

    /** Table for user data attached to this document nodes. */

    private Map<Node, Map<String, UserDataRecord>> nodeUserData;

    /** Identifiers. */

    protected Map<String, Node> identifiers;

    // DOM Level 3: normalizeDocument

    transient DOMNormalizer domNormalizer = null;

    transient DOMConfigurationImpl fConfiguration = null;

    // support of XPath API

    transient Object fXPathEvaluator = null;

    /** Table for quick check of child insertion. */

    private final static int[] kidOK;

    /**

     * Number of alterations made to this document since its creation.

     * Serves as a "dirty bit" so that live objects such as NodeList can

     * recognize when an alteration has been made and discard its cached

     * state information.

     * <p>

     * Any method that alters the tree structure MUST cause or be

     * accompanied by a call to changed(), to inform it that any outstanding

     * NodeLists may have to be updated.

     * <p>

     * (Required because NodeList is simultaneously "live" and integer-

     * indexed -- a bad decision in the DOM's design.)

     * <p>

     * Note that changes which do not affect the tree's structure -- changing

     * the node's name, for example -- do _not_ have to call changed().

     * <p>

     * Alternative implementation would be to use a cryptographic

     * Digest value rather than a count. This would have the advantage that

     * "harmless" changes (those producing equal() trees) would not force

     * NodeList to resynchronize. Disadvantage is that it's slightly more prone

     * to "false negatives", though that's the difference between "wildly

     * unlikely" and "absurdly unlikely". IF we start maintaining digests,

     * we should consider taking advantage of them.

     *

     * Note: This used to be done a node basis, so that we knew what

     * subtree changed. But since only DeepNodeList really use this today,

     * the gain appears to be really small compared to the cost of having

     * an int on every (parent) node plus having to walk up the tree all the

     * way to the root to mark the branch as changed everytime a node is

     * changed.

     * So we now have a single counter global to the document. It means that

     * some objects may flush their cache more often than necessary, but this

     * makes nodes smaller and only the document needs to be marked as changed.

     */

    protected int changes = 0;

    // experimental

    /** Allow grammar access. */

    protected boolean allowGrammarAccess;

    /** Bypass error checking. */

    protected boolean errorChecking = true;

    /** Ancestor checking */

    protected boolean ancestorChecking = true;

    //Did version change at any point when the document was created ?

    //this field helps us to optimize when normalizingDocument.

    protected boolean xmlVersionChanged = false ;

    /** The following are required for compareDocumentPosition

     */

    // Document number.   Documents are ordered across the implementation using

    // positive integer values.  Documents are assigned numbers on demand.

    private int documentNumber=0;

    // Node counter and table.  Used to assign numbers to nodes for this

    // document.  Node number values are negative integers.  Nodes are

    // assigned numbers on demand.

    private int nodeCounter = 0;

    private Map<Node, Integer> nodeTable;

    private boolean xml11Version = false; //by default 1.0

    //

    // Static initialization

    //

    static {

        kidOK = new int[13];

        kidOK[DOCUMENT_NODE] =

        1 << ELEMENT_NODE | 1 << PROCESSING_INSTRUCTION_NODE |

        1 << COMMENT_NODE | 1 << DOCUMENT_TYPE_NODE;

        kidOK[DOCUMENT_FRAGMENT_NODE] =

        kidOK[ENTITY_NODE] =

        kidOK[ENTITY_REFERENCE_NODE] =

        kidOK[ELEMENT_NODE] =

        1 << ELEMENT_NODE | 1 << PROCESSING_INSTRUCTION_NODE |

        1 << COMMENT_NODE | 1 << TEXT_NODE |

        1 << CDATA_SECTION_NODE | 1 << ENTITY_REFERENCE_NODE ;

        kidOK[ATTRIBUTE_NODE] =

        1 << TEXT_NODE | 1 << ENTITY_REFERENCE_NODE;

        kidOK[DOCUMENT_TYPE_NODE] =

        kidOK[PROCESSING_INSTRUCTION_NODE] =

        kidOK[COMMENT_NODE] =

        kidOK[TEXT_NODE] =

        kidOK[CDATA_SECTION_NODE] =

        kidOK[NOTATION_NODE] =

        0;

    } // static

    /**

     * @serialField docType DocumentTypeImpl document type

     * @serialField docElement ElementImpl document element

     * @serialField fFreeNLCache NodeListCache NodeListCache free list

     * @serialField encoding String Document encoding

     * @serialField actualEncoding String Document actualEncoding

     * @serialField version String Document version

     * @serialField standalone boolean Document standalone

     * @serialField fDocumentURI String Document URI

     * @serialField userData Hashtable user data attached to the nodes. Note that

     * it was original called "userData". It has been changed to nodeUserData to

     * avoid confusion with those that are actually values of the map.

     * @serialField identifiers Hashtable identifiers

     * @serialField changes int flag indicates whether the node has changed

     * @serialField allowGrammarAccess boolean Allow grammar access

     * @serialField errorChecking boolean Bypass error checking

     * @serialField ancestorChecking boolean Ancestor checking

     * @serialField xmlVersionChanged boolean Indicate whether the version has changed

     * @serialField documentNumber int Document number

     * @serialField nodeCounter int Node counter

     * @serialField nodeTable Hashtable Node table

     * @serialField xml11Version boolean XML version

     */

    private static final ObjectStreamField[] serialPersistentFields =

        new ObjectStreamField[] {

            new ObjectStreamField("docType", DocumentTypeImpl.class),

            new ObjectStreamField("docElement", ElementImpl.class),

            new ObjectStreamField("fFreeNLCache", NodeListCache.class),

            new ObjectStreamField("encoding", String.class),

            new ObjectStreamField("actualEncoding", String.class),

            new ObjectStreamField("version", String.class),

            new ObjectStreamField("standalone", boolean.class),

            new ObjectStreamField("fDocumentURI", String.class),

            new ObjectStreamField("userData", Hashtable.class),

            new ObjectStreamField("identifiers", Hashtable.class),

            new ObjectStreamField("changes", int.class),

            new ObjectStreamField("allowGrammarAccess", boolean.class),

            new ObjectStreamField("errorChecking", boolean.class),

            new ObjectStreamField("ancestorChecking", boolean.class),

            new ObjectStreamField("xmlVersionChanged", boolean.class),

            new ObjectStreamField("documentNumber", int.class),

            new ObjectStreamField("nodeCounter", int.class),

            new ObjectStreamField("nodeTable", Hashtable.class),

            new ObjectStreamField("xml11Version", boolean.class),

        };

    //

    // Constructors

    //

    /**

     * NON-DOM: Actually creating a Document is outside the DOM's spec,

     * since it has to operate in terms of a particular implementation.

     */

    public CoreDocumentImpl() {

        this(false);

    }

    /** Constructor. */

    public CoreDocumentImpl(boolean grammarAccess) {

        super(null);

        ownerDocument = this;

        allowGrammarAccess = grammarAccess;

        String systemProp = SecuritySupport.getSystemProperty(Constants.SUN_DOM_PROPERTY_PREFIX+Constants.SUN_DOM_ANCESTOR_CHECCK);

        if (systemProp != null) {

            if (systemProp.equalsIgnoreCase("false")) {

                ancestorChecking = false;

            }

        }

    }

    /**

     * For DOM2 support.

     * The createDocument factory method is in DOMImplementation.

     */

    public CoreDocumentImpl(DocumentType doctype) {

        this(doctype, false);

    }

    /** For DOM2 support. */

    public CoreDocumentImpl(DocumentType doctype, boolean grammarAccess) {

        this(grammarAccess);

        if (doctype != null) {

            DocumentTypeImpl doctypeImpl;

            try {

                doctypeImpl = (DocumentTypeImpl) doctype;

            } catch (ClassCastException e) {

                String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "WRONG_DOCUMENT_ERR", null);

                throw new DOMException(DOMException.WRONG_DOCUMENT_ERR, msg);

            }

            doctypeImpl.ownerDocument = this;

            appendChild(doctype);

        }

    }

    //

    // Node methods

    //

    // even though ownerDocument refers to this in this implementation

    // the DOM Level 2 spec says it must be null, so make it appear so

    final public Document getOwnerDocument() {

        return null;

    }

    /** Returns the node type. */

    public short getNodeType() {

        return Node.DOCUMENT_NODE;

    }

    /** Returns the node name. */

    public String getNodeName() {

        return "#document";

    }

    /**

     * Deep-clone a document, including fixing ownerDoc for the cloned

     * children. Note that this requires bypassing the WRONG_DOCUMENT_ERR

     * protection. I've chosen to implement it by calling importNode

     * which is DOM Level 2.

     *

     * @return org.w3c.dom.Node

     * @param deep boolean, iff true replicate children

     */

    public Node cloneNode(boolean deep) {

        CoreDocumentImpl newdoc = new CoreDocumentImpl();

        callUserDataHandlers(this, newdoc, UserDataHandler.NODE_CLONED);

        cloneNode(newdoc, deep);

        return newdoc;

    } // cloneNode(boolean):Node

    /**

     * internal method to share code with subclass

     **/

    protected void cloneNode(CoreDocumentImpl newdoc, boolean deep) {

        // clone the children by importing them

        if (needsSyncChildren()) {

            synchronizeChildren();

        }

        if (deep) {

            Map<Node, String> reversedIdentifiers = null;

            if (identifiers != null) {

                // Build a reverse mapping from element to identifier.

                reversedIdentifiers = new HashMap<>(identifiers.size());

                for (String elementId : identifiers.keySet()) {

                    reversedIdentifiers.put(identifiers.get(elementId), elementId);

                }

            }

            // Copy children into new document.

            for (ChildNode kid = firstChild; kid != null;

                    kid = kid.nextSibling) {

                newdoc.appendChild(newdoc.importNode(kid, true, true,

                        reversedIdentifiers));

            }

        }

        // experimental

        newdoc.allowGrammarAccess = allowGrammarAccess;

        newdoc.errorChecking = errorChecking;

    } // cloneNode(CoreDocumentImpl,boolean):void

    /**

     * Since a Document may contain at most one top-level Element child,

     * and at most one DocumentType declaraction, we need to subclass our

     * add-children methods to implement this constraint.

     * Since appendChild() is implemented as insertBefore(,null),

     * altering the latter fixes both.

     * <p>

     * While I'm doing so, I've taken advantage of the opportunity to

     * cache documentElement and docType so we don't have to

     * search for them.

     *

     * REVISIT: According to the spec it is not allowed to alter neither the

     * document element nor the document type in any way

     */

    public Node insertBefore(Node newChild, Node refChild)

            throws DOMException {

        // Only one such child permitted

        int type = newChild.getNodeType();

        if (errorChecking) {

            if((type == Node.ELEMENT_NODE && docElement != null) ||

            (type == Node.DOCUMENT_TYPE_NODE && docType != null)) {

                String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null);

                throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, msg);

            }

        }

        // Adopt orphan doctypes

        if (newChild.getOwnerDocument() == null &&

        newChild instanceof DocumentTypeImpl) {

            ((DocumentTypeImpl) newChild).ownerDocument = this;

        }

        super.insertBefore(newChild,refChild);

        // If insert succeeded, cache the kid appropriately

        if (type == Node.ELEMENT_NODE) {

            docElement = (ElementImpl)newChild;

        }

        else if (type == Node.DOCUMENT_TYPE_NODE) {

            docType = (DocumentTypeImpl)newChild;

        }

        return newChild;

    } // insertBefore(Node,Node):Node

    /**

     * Since insertBefore caches the docElement (and, currently, docType),

     * removeChild has to know how to undo the cache

     *

     * REVISIT: According to the spec it is not allowed to alter neither the

     * document element nor the document type in any way

     */

    public Node removeChild(Node oldChild) throws DOMException {

        super.removeChild(oldChild);

        // If remove succeeded, un-cache the kid appropriately

        int type = oldChild.getNodeType();

        if(type == Node.ELEMENT_NODE) {

            docElement = null;

        }

        else if (type == Node.DOCUMENT_TYPE_NODE) {

            docType = null;

        }

        return oldChild;

    }   // removeChild(Node):Node

    /**

     * Since we cache the docElement (and, currently, docType),

     * replaceChild has to update the cache

     *

     * REVISIT: According to the spec it is not allowed to alter neither the

     * document element nor the document type in any way

     */

    public Node replaceChild(Node newChild, Node oldChild)

            throws DOMException {

        // Adopt orphan doctypes

        if (newChild.getOwnerDocument() == null &&

        newChild instanceof DocumentTypeImpl) {

            ((DocumentTypeImpl) newChild).ownerDocument = this;

        }

        if (errorChecking &&((docType != null &&

            oldChild.getNodeType() != Node.DOCUMENT_TYPE_NODE &&

            newChild.getNodeType() == Node.DOCUMENT_TYPE_NODE)

            || (docElement != null &&

            oldChild.getNodeType() != Node.ELEMENT_NODE &&

            newChild.getNodeType() == Node.ELEMENT_NODE))) {

            throw new DOMException(

                    DOMException.HIERARCHY_REQUEST_ERR,

                    DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));

        }

        super.replaceChild(newChild, oldChild);

        int type = oldChild.getNodeType();

        if(type == Node.ELEMENT_NODE) {

            docElement = (ElementImpl)newChild;

        }

        else if (type == Node.DOCUMENT_TYPE_NODE) {

            docType = (DocumentTypeImpl)newChild;