/*

 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * 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.xml.internal.serializer.dom3;

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

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

import com.sun.org.apache.xml.internal.serializer.OutputPropertiesFactory;

import com.sun.org.apache.xml.internal.serializer.SerializationHandler;

import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;

import com.sun.org.apache.xml.internal.serializer.utils.Utils;

import java.io.IOException;

import java.io.Writer;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import org.w3c.dom.Attr;

import org.w3c.dom.CDATASection;

import org.w3c.dom.Comment;

import org.w3c.dom.DOMError;

import org.w3c.dom.DOMErrorHandler;

import org.w3c.dom.Document;

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.ProcessingInstruction;

import org.w3c.dom.Text;

import org.w3c.dom.ls.LSSerializerFilter;

import org.w3c.dom.traversal.NodeFilter;

import org.xml.sax.Locator;

import org.xml.sax.SAXException;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.LocatorImpl;

/**

 * Built on org.apache.xml.serializer.TreeWalker and adds functionality to

 * traverse and serialize a DOM Node (Level 2 or Level 3) as specified in

 * the DOM Level 3 LS Recommedation by evaluating and applying DOMConfiguration

 * parameters and filters if any during serialization.

 *

 * @xsl.usage internal

 */

final class DOM3TreeWalker {

    /**

     * The SerializationHandler, it extends ContentHandler and when

     * this class is instantiated via the constructor provided, a

     * SerializationHandler object is passed to it.

     */

    private SerializationHandler fSerializer = null;

    /** We do not need DOM2Helper since DOM Level 3 LS applies to DOM Level 2 or newer */

    /** Locator object for this TreeWalker          */

    private LocatorImpl fLocator = new LocatorImpl();

    /** ErrorHandler */

    private DOMErrorHandler fErrorHandler = null;

    /** LSSerializerFilter */

    private LSSerializerFilter fFilter = null;

    /** If the serializer is an instance of a LexicalHandler */

    private LexicalHandler fLexicalHandler = null;

    private int fWhatToShowFilter;

    /** New Line character to use in serialization */

    private String fNewLine = null;

    /** DOMConfiguration Properties */

    private Properties fDOMConfigProperties = null;

    /** Keeps track if we are in an entity reference when entities=true */

    private boolean fInEntityRef = false;

    /** Stores the version of the XML document to be serialize */

    private String fXMLVersion = null;

    /** XML Version, default 1.0 */

    private boolean fIsXMLVersion11 = false;

    /** Is the Node a Level 3 DOM node */

    private boolean fIsLevel3DOM = false;

    /** DOM Configuration Parameters */

    private int fFeatures = 0;

    /** Flag indicating whether following text to be processed is raw text          */

    boolean fNextIsRaw = false;

    //

    private static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";

    //

    private static final String XMLNS_PREFIX = "xmlns";

    //

    private static final String XML_URI = "http://www.w3.org/XML/1998/namespace";

    //

    private static final String XML_PREFIX = "xml";

    /** stores namespaces in scope */

    protected NamespaceSupport fNSBinder;

    /** stores all namespace bindings on the current element */

    protected NamespaceSupport fLocalNSBinder;

    /** stores the current element depth */

    private int fElementDepth = 0;

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

    // DOMConfiguration paramter settings

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

    // Parameter canonical-form, true [optional] - NOT SUPPORTED

    private final static int CANONICAL = 0x1 << 0;

    // Parameter cdata-sections, true [required] (default)

    private final static int CDATA = 0x1 << 1;

    // Parameter check-character-normalization, true [optional] - NOT SUPPORTED

    private final static int CHARNORMALIZE = 0x1 << 2;

    // Parameter comments, true [required] (default)

    private final static int COMMENTS = 0x1 << 3;

    // Parameter datatype-normalization, true [optional] - NOT SUPPORTED

    private final static int DTNORMALIZE = 0x1 << 4;

    // Parameter element-content-whitespace, true [required] (default) - value - false [optional] NOT SUPPORTED

    private final static int ELEM_CONTENT_WHITESPACE = 0x1 << 5;

    // Parameter entities, true [required] (default)

    private final static int ENTITIES = 0x1 << 6;

    // Parameter infoset, true [required] (default), false has no effect --> True has no effect for the serializer

    private final static int INFOSET = 0x1 << 7;

    // Parameter namespaces, true [required] (default)

    private final static int NAMESPACES = 0x1 << 8;

    // Parameter namespace-declarations, true [required] (default)

    private final static int NAMESPACEDECLS = 0x1 << 9;

    // Parameter normalize-characters, true [optional] - NOT SUPPORTED

    private final static int NORMALIZECHARS = 0x1 << 10;

    // Parameter split-cdata-sections, true [required] (default)

    private final static int SPLITCDATA = 0x1 << 11;

    // Parameter validate, true [optional] - NOT SUPPORTED

    private final static int VALIDATE = 0x1 << 12;

    // Parameter validate-if-schema, true [optional] - NOT SUPPORTED

    private final static int SCHEMAVALIDATE = 0x1 << 13;

    // Parameter split-cdata-sections, true [required] (default)

    private final static int WELLFORMED = 0x1 << 14;

    // Parameter discard-default-content, true [required] (default)

    // Not sure how this will be used in level 2 Documents

    private final static int DISCARDDEFAULT = 0x1 << 15;

    // Parameter format-pretty-print, true [optional]

    private final static int PRETTY_PRINT = 0x1 << 16;

    // Parameter ignore-unknown-character-denormalizations, true [required] (default)

    // We currently do not support XML 1.1 character normalization

    private final static int IGNORE_CHAR_DENORMALIZE = 0x1 << 17;

    // Parameter discard-default-content, true [required] (default)

    private final static int XMLDECL = 0x1 << 18;

    /**

     * Constructor.

     * @param   contentHandler serialHandler The implemention of the SerializationHandler interface

     */

    DOM3TreeWalker(

        SerializationHandler serialHandler,

        DOMErrorHandler errHandler,

        LSSerializerFilter filter,

        String newLine) {

        fSerializer = serialHandler;

        //fErrorHandler = errHandler == null ? new DOMErrorHandlerImpl() : errHandler; // Should we be using the default?

        fErrorHandler = errHandler;

        fFilter = filter;

        fLexicalHandler = null;

        fNewLine = newLine;

        fNSBinder = new NamespaceSupport();

        fLocalNSBinder = new NamespaceSupport();

        fDOMConfigProperties = fSerializer.getOutputFormat();

        fSerializer.setDocumentLocator(fLocator);

        initProperties(fDOMConfigProperties);

    }

    /**

     * Perform a pre-order traversal non-recursive style.

     *

     * Note that TreeWalker assumes that the subtree is intended to represent

     * a complete (though not necessarily well-formed) document and, during a

     * traversal, startDocument and endDocument will always be issued to the

     * SAX listener.

     *

     * @param pos Node in the tree where to start traversal

     *

     * @throws TransformerException

     */

    public void traverse(Node pos) throws org.xml.sax.SAXException {

        this.fSerializer.startDocument();

        // Determine if the Node is a DOM Level 3 Core Node.

        if (pos.getNodeType() != Node.DOCUMENT_NODE) {

            Document ownerDoc = pos.getOwnerDocument();

            if (ownerDoc != null

                && ownerDoc.getImplementation().hasFeature("Core", "3.0")) {

                fIsLevel3DOM = true;

            }

        } else {

            if (((Document) pos)

                .getImplementation()

                .hasFeature("Core", "3.0")) {

                fIsLevel3DOM = true;

            }

        }

        if (fSerializer instanceof LexicalHandler) {

            fLexicalHandler = ((LexicalHandler) this.fSerializer);

        }

        if (fFilter != null)

            fWhatToShowFilter = fFilter.getWhatToShow();

        Node top = pos;

        while (null != pos) {

            startNode(pos);

            Node nextNode = null;

            nextNode = pos.getFirstChild();

            while (null == nextNode) {

                endNode(pos);

                if (top.equals(pos))

                    break;

                nextNode = pos.getNextSibling();

                if (null == nextNode) {

                    pos = pos.getParentNode();

                    if ((null == pos) || (top.equals(pos))) {

                        if (null != pos)

                            endNode(pos);

                        nextNode = null;

                        break;

                    }

                }

            }

            pos = nextNode;

        }

        this.fSerializer.endDocument();

    }

    /**

     * Perform a pre-order traversal non-recursive style.

     * Note that TreeWalker assumes that the subtree is intended to represent

     * a complete (though not necessarily well-formed) document and, during a

     * traversal, startDocument and endDocument will always be issued to the

     * SAX listener.

     *

     * @param pos Node in the tree where to start traversal

     * @param top Node in the tree where to end traversal

     *

     * @throws TransformerException

     */

    public void traverse(Node pos, Node top) throws org.xml.sax.SAXException {

        this.fSerializer.startDocument();

        // Determine if the Node is a DOM Level 3 Core Node.

        if (pos.getNodeType() != Node.DOCUMENT_NODE) {

            Document ownerDoc = pos.getOwnerDocument();

            if (ownerDoc != null

                && ownerDoc.getImplementation().hasFeature("Core", "3.0")) {

                fIsLevel3DOM = true;

            }

        } else {

            if (((Document) pos)

                .getImplementation()

                .hasFeature("Core", "3.0")) {

                fIsLevel3DOM = true;

            }

        }

        if (fSerializer instanceof LexicalHandler) {

            fLexicalHandler = ((LexicalHandler) this.fSerializer);

        }

        if (fFilter != null)

            fWhatToShowFilter = fFilter.getWhatToShow();

        while (null != pos) {

            startNode(pos);

            Node nextNode = null;

            nextNode = pos.getFirstChild();

            while (null == nextNode) {

                endNode(pos);

                if ((null != top) && top.equals(pos))

                    break;

                nextNode = pos.getNextSibling();

                if (null == nextNode) {

                    pos = pos.getParentNode();

                    if ((null == pos) || ((null != top) && top.equals(pos))) {

                        nextNode = null;

                        break;

                    }

                }

            }

            pos = nextNode;

        }

        this.fSerializer.endDocument();

    }

    /**

     * Optimized dispatch of characters.

     */

    private final void dispatachChars(Node node)

        throws org.xml.sax.SAXException {

        if (fSerializer != null) {

            String data = ((Text) node).getData();

            this.fSerializer.characters(data.toCharArray(), 0, data.length());

        }

    }

    /**

     * Start processing given node

     *

     * @param node Node to process

     *

     * @throws org.xml.sax.SAXException

     */

    protected void startNode(Node node) throws org.xml.sax.SAXException {

        if (node instanceof Locator) {

            Locator loc = (Locator) node;

            fLocator.setColumnNumber(loc.getColumnNumber());

            fLocator.setLineNumber(loc.getLineNumber());

            fLocator.setPublicId(loc.getPublicId());

            fLocator.setSystemId(loc.getSystemId());

        } else {

            fLocator.setColumnNumber(0);

            fLocator.setLineNumber(0);

        }

        switch (node.getNodeType()) {

            case Node.DOCUMENT_TYPE_NODE :

                serializeDocType((DocumentType) node, true);

                break;

            case Node.COMMENT_NODE :

                serializeComment((Comment) node);

                break;

            case Node.DOCUMENT_FRAGMENT_NODE :

                // Children are traversed

                break;

            case Node.DOCUMENT_NODE :

                break;

            case Node.ELEMENT_NODE :

                serializeElement((Element) node, true);

                break;

            case Node.PROCESSING_INSTRUCTION_NODE :

                serializePI((ProcessingInstruction) node);

                break;

            case Node.CDATA_SECTION_NODE :

                serializeCDATASection((CDATASection) node);

                break;

            case Node.TEXT_NODE :

                serializeText((Text) node);

                break;

            case Node.ENTITY_REFERENCE_NODE :

                serializeEntityReference((EntityReference) node, true);

                break;

            default :

                }

    }

    /**

     * End processing of given node

     *

     *

     * @param node Node we just finished processing

     *

     * @throws org.xml.sax.SAXException

     */

    protected void endNode(Node node) throws org.xml.sax.SAXException {

        switch (node.getNodeType()) {

            case Node.DOCUMENT_NODE :

                break;

            case Node.DOCUMENT_TYPE_NODE :

                serializeDocType((DocumentType) node, false);

                break;

            case Node.ELEMENT_NODE :

                serializeElement((Element) node, false);

                break;

            case Node.CDATA_SECTION_NODE :

                break;

            case Node.ENTITY_REFERENCE_NODE :

                serializeEntityReference((EntityReference) node, false);

                break;

            default :

                }

    }

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

    // Node serialization methods

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

    /**

     * Applies a filter on the node to serialize

     *

     * @param node The Node to serialize

     * @return True if the node is to be serialized else false if the node

     *         is to be rejected or skipped.

     */

    protected boolean applyFilter(Node node, int nodeType) {

        if (fFilter != null && (fWhatToShowFilter & nodeType) != 0) {

            short code = fFilter.acceptNode(node);

            switch (code) {

                case NodeFilter.FILTER_REJECT :

                case NodeFilter.FILTER_SKIP :

                    return false; // skip the node

                default : // fall through..

            }

        }

        return true;

    }

    /**

     * Serializes a Document Type Node.

     *

     * @param node The Docuemnt Type Node to serialize

     * @param bStart Invoked at the start or end of node.  Default true.

     */

    protected void serializeDocType(DocumentType node, boolean bStart)

        throws SAXException {

        // The DocType and internalSubset can not be modified in DOM and is

        // considered to be well-formed as the outcome of successful parsing.

        String docTypeName = node.getNodeName();

        String publicId = node.getPublicId();

        String systemId = node.getSystemId();

        String internalSubset = node.getInternalSubset();

        //DocumentType nodes are never passed to the filter

        if (internalSubset != null && !"".equals(internalSubset)) {

            if (bStart) {

                try {

                    // The Serializer does not provide a way to write out the

                    // DOCTYPE internal subset via an event call, so we write it

                    // out here.

                    Writer writer = fSerializer.getWriter();

                    StringBuffer dtd = new StringBuffer();

                    dtd.append("<!DOCTYPE ");

                    dtd.append(docTypeName);

                    if (null != publicId) {

                        dtd.append(" PUBLIC \"");

                        dtd.append(publicId);

                        dtd.append('\"');

                    }

                    if (null != systemId) {

                        if (null == publicId) {

                            dtd.append(" SYSTEM \"");

                        } else {

                            dtd.append(" \"");

                        }

                        dtd.append(systemId);

                        dtd.append('\"');

                    }

                    dtd.append(" [ ");

                    dtd.append(fNewLine);