/*

 */

/*

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

import com.sun.org.apache.xerces.internal.dom.events.MutationEventImpl;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamField;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.w3c.dom.Attr;

import org.w3c.dom.DOMException;

import org.w3c.dom.DOMImplementation;

import org.w3c.dom.DocumentType;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.UserDataHandler;

import org.w3c.dom.events.DocumentEvent;

import org.w3c.dom.events.Event;

import org.w3c.dom.events.EventException;

import org.w3c.dom.events.EventListener;

import org.w3c.dom.events.MutationEvent;

import org.w3c.dom.ranges.DocumentRange;

import org.w3c.dom.ranges.Range;

import org.w3c.dom.traversal.DocumentTraversal;

import org.w3c.dom.traversal.NodeFilter;

import org.w3c.dom.traversal.NodeIterator;

import org.w3c.dom.traversal.TreeWalker;

/**

 * 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 DocumentImpl class also implements the DOM Level 2 DocumentTraversal

 * interface. This interface is comprised of factory methods needed to

 * create NodeIterators and TreeWalkers. The process of creating NodeIterator

 * objects also adds these references to this document.

 * After finishing with an iterator it is important to remove the object

 * using the remove methods in this implementation. This allows the release of

 * the references from the iterator objects to the DOM Nodes.

 * <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 DocumentImpl

    extends CoreDocumentImpl

    implements DocumentTraversal, DocumentEvent, DocumentRange {

    //

    // Constants

    //

    /** Serialization version. */

    static final long serialVersionUID = 515687835542616694L;

    //

    // Data

    //

    /** Iterators */

    // REVISIT: Should this be transient? -Ac

    protected List<NodeIterator> iterators;

     /** Ranges */

    // REVISIT: Should this be transient? -Ac

    protected List<Range> ranges;

    /** Table for event listeners registered to this document nodes. */

    protected Map<NodeImpl, List<LEntry>> eventListeners;

    /** Bypass mutation events firing. */

    protected boolean mutationEvents = false;

    /**

     * @serialField iterators Vector Node iterators

     * @serialField ranges Vector ranges

     * @serialField eventListeners Hashtable Event listeners

     * @serialField mutationEvents boolean Bypass mutation events firing

     */

    private static final ObjectStreamField[] serialPersistentFields =

        new ObjectStreamField[] {

            new ObjectStreamField("iterators", Vector.class),

            new ObjectStreamField("ranges", Vector.class),

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

            new ObjectStreamField("mutationEvents", 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 DocumentImpl() {

        super();

    }

    /** Constructor. */

    public DocumentImpl(boolean grammarAccess) {

        super(grammarAccess);

    }

    /**

     * For DOM2 support.

     * The createDocument factory method is in DOMImplementation.

     */

    public DocumentImpl(DocumentType doctype)

    {

        super(doctype);

    }

    /** For DOM2 support. */

    public DocumentImpl(DocumentType doctype, boolean grammarAccess) {

        super(doctype, grammarAccess);

    }

    //

    // Node methods

    //

    /**

     * 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) {

        DocumentImpl newdoc = new DocumentImpl();

        callUserDataHandlers(this, newdoc, UserDataHandler.NODE_CLONED);

        cloneNode(newdoc, deep);

        // experimental

        newdoc.mutationEvents = mutationEvents;

        return newdoc;

    } // cloneNode(boolean):Node

    /**

     * Retrieve information describing the abilities of this particular

     * DOM implementation. Intended to support applications that may be

     * using DOMs retrieved from several different sources, potentially

     * with different underlying representations.

     */

    public DOMImplementation getImplementation() {

        // Currently implemented as a singleton, since it's hardcoded

        // information anyway.

        return DOMImplementationImpl.getDOMImplementation();

    }

    //

    // DocumentTraversal methods

    //

    /**

     * NON-DOM extension:

     * Create and return a NodeIterator. The NodeIterator is

     * added to a list of NodeIterators so that it can be

     * removed to free up the DOM Nodes it references.

     *

     * @param root The root of the iterator.

     * @param whatToShow The whatToShow mask.

     * @param filter The NodeFilter installed. Null means no filter.

     */

    public NodeIterator createNodeIterator(Node root,

                                           short whatToShow,

                                           NodeFilter filter)

    {

        return createNodeIterator(root, whatToShow, filter, true);

    }

    /**

     * Create and return a NodeIterator. The NodeIterator is

     * added to a list of NodeIterators so that it can be

     * removed to free up the DOM Nodes it references.

     *

     * @param root The root of the iterator.

     * @param whatToShow The whatToShow mask.

     * @param filter The NodeFilter installed. Null means no filter.

     * @param entityReferenceExpansion true to expand the contents of

     *                                 EntityReference nodes

     * @since WD-DOM-Level-2-19990923

     */

    public NodeIterator createNodeIterator(Node root,

                                           int whatToShow,

                                           NodeFilter filter,

                                           boolean entityReferenceExpansion)

    {

        if (root == null) {

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

                  throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

        }

        NodeIterator iterator = new NodeIteratorImpl(this,

                                                     root,

                                                     whatToShow,

                                                     filter,

                                                     entityReferenceExpansion);

        if (iterators == null) {

            iterators = new ArrayList<>();

        }

        iterators.add(iterator);

        return iterator;

    }

    /**

     * NON-DOM extension:

     * Create and return a TreeWalker.

     *

     * @param root The root of the iterator.

     * @param whatToShow The whatToShow mask.

     * @param filter The NodeFilter installed. Null means no filter.

     */

    public TreeWalker createTreeWalker(Node root,

                                       short whatToShow,

                                       NodeFilter filter)

    {

        return createTreeWalker(root, whatToShow, filter, true);

    }

    /**

     * Create and return a TreeWalker.

     *

     * @param root The root of the iterator.

     * @param whatToShow The whatToShow mask.

     * @param filter The NodeFilter installed. Null means no filter.

     * @param entityReferenceExpansion true to expand the contents of

     *                                 EntityReference nodes

     * @since WD-DOM-Level-2-19990923

     */

    public TreeWalker createTreeWalker(Node root,

                                       int whatToShow,

                                       NodeFilter filter,

                                       boolean entityReferenceExpansion)

    {

        if (root == null) {

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

            throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

        }

        return new TreeWalkerImpl(root, whatToShow, filter,

                                  entityReferenceExpansion);

    }

    //

    // Not DOM Level 2. Support DocumentTraversal methods.

    //

    /** This is not called by the developer client. The

     *  developer client uses the detach() function on the

     *  NodeIterator itself. <p>

     *

     *  This function is called from the NodeIterator#detach().

     */

     void removeNodeIterator(NodeIterator nodeIterator) {

        if (nodeIterator == null) return;

        if (iterators == null) return;

        iterators.remove(nodeIterator);

    }

    //

    // DocumentRange methods

    //

    /**

     */

    public Range createRange() {

        if (ranges == null) {

            ranges = new ArrayList<>();

        }

        Range range = new RangeImpl(this);

        ranges.add(range);

        return range;

    }

    /** Not a client function. Called by Range.detach(),

     *  so a Range can remove itself from the list of

     *  Ranges.

     */

    void removeRange(Range range) {

        if (range == null) return;

        if (ranges == null) return;

        ranges.remove(range);

    }

    /**

     * A method to be called when some text was changed in a text node,

     * so that live objects can be notified.

     */

    void replacedText(NodeImpl node) {

        // notify ranges

        if (ranges != null) {

            int size = ranges.size();

            for (int i = 0; i != size; i++) {

                ((RangeImpl)ranges.get(i)).receiveReplacedText(node);

            }

        }

    }

    /**

     * A method to be called when some text was deleted from a text node,

     * so that live objects can be notified.

     */

    void deletedText(NodeImpl node, int offset, int count) {

        // notify ranges

        if (ranges != null) {

            int size = ranges.size();

            for (int i = 0; i != size; i++) {

                ((RangeImpl)ranges.get(i)).receiveDeletedText(node,

                                                                offset, count);

            }

        }

    }

    /**

     * A method to be called when some text was inserted into a text node,

     * so that live objects can be notified.

     */

    void insertedText(NodeImpl node, int offset, int count) {

        // notify ranges

        if (ranges != null) {

            int size = ranges.size();

            for (int i = 0; i != size; i++) {

                ((RangeImpl)ranges.get(i)).receiveInsertedText(node,

                                                                offset, count);

            }

        }

    }

    /**

     * A method to be called when a text node has been split,

     * so that live objects can be notified.

     */

    void splitData(Node node, Node newNode, int offset) {

        // notify ranges

        if (ranges != null) {

            int size = ranges.size();

            for (int i = 0; i != size; i++) {

                ((RangeImpl)ranges.get(i)).receiveSplitData(node,

                                                              newNode, offset);

            }

        }

    }

    //

    // DocumentEvent methods

    //

    /**

     * Introduced in DOM Level 2. Optional. <p>

     * Create and return Event objects.

     *

     * @param type The eventType parameter specifies the type of Event

     * interface to be created.  If the Event interface specified is supported

     * by the implementation this method will return a new Event of the

     * interface type requested. If the Event is to be dispatched via the

     * dispatchEvent method the appropriate event init method must be called

     * after creation in order to initialize the Event's values.  As an

     * example, a user wishing to synthesize some kind of Event would call

     * createEvent with the parameter "Events". The initEvent method could then

     * be called on the newly created Event to set the specific type of Event

     * to be dispatched and set its context information.

     * @return Newly created Event

     * @exception DOMException NOT_SUPPORTED_ERR: Raised if the implementation

     * does not support the type of Event interface requested

     * @since WD-DOM-Level-2-19990923

     */

    public Event createEvent(String type)

        throws DOMException {

            if (type.equalsIgnoreCase("Events") || "Event".equals(type))

                return new EventImpl();

            if (type.equalsIgnoreCase("MutationEvents") ||

                "MutationEvent".equals(type))

                return new MutationEventImpl();

            else {

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

                throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

        }

        }

    /**

     * Sets whether the DOM implementation generates mutation events

     * upon operations.

     */

    void setMutationEvents(boolean set) {

        mutationEvents = set;

    }

    /**

     * Returns true if the DOM implementation generates mutation events.

     */

    boolean getMutationEvents() {

        return mutationEvents;

    }

    /**

     * Store event listener registered on a given node

     * This is another place where we could use weak references! Indeed, the

     * node here won't be GC'ed as long as some listener is registered on it,

     * since the eventsListeners table will have a reference to the node.

     */

    protected void setEventListeners(NodeImpl n, List<LEntry> listeners) {

        if (eventListeners == null) {

            eventListeners = new HashMap<>();

        }

        if (listeners == null) {

            eventListeners.remove(n);

            if (eventListeners.isEmpty()) {

                // stop firing events when there isn't any listener

                mutationEvents = false;

            }

        } else {

            eventListeners.put(n, listeners);

            // turn mutation events on

            mutationEvents = true;

        }

    }

    /**

     * Retreive event listener registered on a given node

     */

        if (eventListeners == null) {

            return null;

        }

        return eventListeners.get(n);

    }

    //

    // EventTarget support (public and internal)

    //

    //

    // Constants

    //

    /*

     * NON-DOM INTERNAL: Class LEntry is just a struct used to represent

     * event listeners registered with this node. Copies of this object

     * are hung from the nodeListeners Vector.

     * <p>

     * I considered using two vectors -- one for capture,

     * one for bubble -- but decided that since the list of listeners

     * is probably short in most cases, it might not be worth spending

     * the space. ***** REVISIT WHEN WE HAVE MORE EXPERIENCE.

     */

    class LEntry implements Serializable {

        private static final long serialVersionUID = -8426757059492421631L;

        String type;

        EventListener listener;

        boolean useCapture;

        /** NON-DOM INTERNAL: Constructor for Listener list Entry

         * @param type Event name (NOT event group!) to listen for.

         * @param listener Who gets called when event is dispatched

         * @param useCaptue True iff listener is registered on

         *  capturing phase rather than at-target or bubbling

         */

        LEntry(String type, EventListener listener, boolean useCapture)

        {

            this.type = type;

            this.listener = listener;