/*

 * Copyright (c) 2006, 2016, 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;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

import java.io.Writer;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EmptyStackException;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.List;

import java.util.Properties;

import java.util.Set;

import java.util.StringTokenizer;

import javax.xml.transform.ErrorListener;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import org.w3c.dom.Node;

import org.xml.sax.Attributes;

import org.xml.sax.ContentHandler;

import org.xml.sax.SAXException;

import com.sun.org.apache.xalan.internal.utils.SecuritySupport;

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

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

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

/**

 * This abstract class is a base class for other stream

 * serializers (xml, html, text ...) that write output to a stream.

 *

 * @xsl.usage internal

 */

abstract public class ToStream extends SerializerBase {

    private static final String COMMENT_BEGIN = "<!--";

    private static final String COMMENT_END = "-->";

    /** Stack to keep track of disabling output escaping. */

    protected BoolStack m_disableOutputEscapingStates = new BoolStack();

    /**

     * The encoding information associated with this serializer.

     * Although initially there is no encoding,

     * there is a dummy EncodingInfo object that will say

     * that every character is in the encoding. This is useful

     * for a serializer that is in temporary output state and has

     * no associated encoding. A serializer in final output state

     * will have an encoding, and will worry about whether

     * single chars or surrogate pairs of high/low chars form

     * characters in the output encoding.

     */

    EncodingInfo m_encodingInfo = new EncodingInfo(null,null);

    /**

     * Method reference to the sun.io.CharToByteConverter#canConvert method

     * for this encoding.  Invalid if m_charToByteConverter is null.

     */

    java.lang.reflect.Method m_canConvertMeth;

    /**

     * Boolean that tells if we already tried to get the converter.

     */

    boolean m_triedToGetConverter = false;

    /**

     * Opaque reference to the sun.io.CharToByteConverter for this

     * encoding.

     */

    Object m_charToByteConverter = null;

    /**

     * Used to buffer the text nodes and the entity reference nodes if

     * indentation is on.

     */

    protected CharacterBuffer m_charactersBuffer = new CharacterBuffer();

    /**

     * Used to decide if a text node is pretty-printed with indentation.

     * If m_childNodeNum > 1, the text node will be indented.

     *

     */

    protected List<Integer> m_childNodeNumStack = new ArrayList<>();

    protected int m_childNodeNum = 0;

    /**

     * Used to handle xml:space attribute

     *

     */

    protected BoolStack m_preserveSpaces = new BoolStack();

    protected boolean m_ispreserveSpace = false;

    /**

     * State flag that tells if the previous node processed

     * was text, so we can tell if we should preserve whitespace.

     *

     * Used in endDocument() and shouldIndent() but

     * only if m_doIndent is true.

     * If m_doIndent is false this flag has no impact.

     */

    protected boolean m_isprevtext = false;

    /**

     * The maximum character size before we have to resort

     * to escaping.

     */

    protected int m_maxCharacter = Encodings.getLastPrintable();

    /**

     * The system line separator for writing out line breaks.

     * The default value is from the system property,

     * but this value can be set through the xsl:output

     * extension attribute xalan:line-separator.

     */

    protected char[] m_lineSep =

        SecuritySupport.getSystemProperty("line.separator").toCharArray();

    /**

     * True if the the system line separator is to be used.

     */

    protected boolean m_lineSepUse = true;

    /**

     * The length of the line seperator, since the write is done

     * one character at a time.

     */

    protected int m_lineSepLen = m_lineSep.length;

    /**

     * Map that tells which characters should have special treatment, and it

     *  provides character to entity name lookup.

     */

    protected CharInfo m_charInfo;

    /** True if we control the buffer, and we should flush the output on endDocument. */

    boolean m_shouldFlush = true;

    /**

     * Add space before '/>' for XHTML.

     */

    protected boolean m_spaceBeforeClose = false;

    /**

     * Flag to signal that a newline should be added.

     *

     * Used only in indent() which is called only if m_doIndent is true.

     * If m_doIndent is false this flag has no impact.

     */

    boolean m_startNewLine;

    /**

     * Tells if we're in an internal document type subset.

     */

    protected boolean m_inDoctype = false;

    /**

     * Flag to quickly tell if the encoding is UTF8.

     */

    boolean m_isUTF8 = false;

    /**

     * remembers if we are in between the startCDATA() and endCDATA() callbacks

     */

    protected boolean m_cdataStartCalled = false;

    /**

     * If this flag is true DTD entity references are not left as-is,

     * which is exiting older behavior.

     */

    private boolean m_expandDTDEntities = true;

    /**

     * Default constructor

     */

    public ToStream() { }

    /**

     * This helper method to writes out "]]>" when closing a CDATA section.

     *

     * @throws org.xml.sax.SAXException

     */

    protected void closeCDATA() throws org.xml.sax.SAXException {

        try {

            m_writer.write(CDATA_DELIMITER_CLOSE);

            // write out a CDATA section closing "]]>"

            m_cdataTagOpen = false; // Remember that we have done so.

        }

        catch (IOException e) {

            throw new SAXException(e);

        }

    }

    /**

     * Serializes the DOM node. Throws an exception only if an I/O

     * exception occured while serializing.

     *

     * @param node Node to serialize.

     * @throws IOException An I/O exception occured while serializing

     */

    public void serialize(Node node) throws IOException {

        try {

            TreeWalker walker = new TreeWalker(this);

            walker.traverse(node);

        } catch (org.xml.sax.SAXException se) {

            throw new WrappedRuntimeException(se);

        }

    }

    /**

     * Return true if the character is the high member of a surrogate pair.

     *

     * NEEDSDOC @param c

     *

     * NEEDSDOC ($objectName$) @return

     */

    static final boolean isUTF16Surrogate(char c) {

        return (c & 0xFC00) == 0xD800;

    }

    /**

     * Taken from XSLTC

     */

    private boolean m_escaping = true;

    /**

     * Flush the formatter's result stream.

     *

     * @throws org.xml.sax.SAXException

     */

    protected final void flushWriter() throws org.xml.sax.SAXException {

        final Writer writer = m_writer;

        if (null != writer) {

            try {

                if (writer instanceof WriterToUTF8Buffered) {

                    if (m_shouldFlush)

                        ((WriterToUTF8Buffered)writer).flush();

                    else

                        ((WriterToUTF8Buffered)writer).flushBuffer();

                }

                if (writer instanceof WriterToASCI) {

                    if (m_shouldFlush)

                        writer.flush();

                } else {

                    // Flush always.

                    // Not a great thing if the writer was created

                    // by this class, but don't have a choice.

                    writer.flush();

                }

            } catch (IOException ioe) {

                throw new org.xml.sax.SAXException(ioe);

            }

        }

    }

    OutputStream m_outputStream;

    /**

     * Get the output stream where the events will be serialized to.

     *

     * @return reference to the result stream, or null of only a writer was

     * set.

     */

    public OutputStream getOutputStream() {

        return m_outputStream;

    }

    // Implement DeclHandler

    /**

     *   Report an element type declaration.

     *

     *   <p>The content model will consist of the string "EMPTY", the

     *   string "ANY", or a parenthesised group, optionally followed

     *   by an occurrence indicator.  The model will be normalized so

     *   that all whitespace is removed,and will include the enclosing

     *   parentheses.</p>

     *

     *   @param name The element type name.

     *   @param model The content model as a normalized string.

     *   @exception SAXException The application may raise an exception.

     */

    public void elementDecl(String name, String model) throws SAXException

    {

        // Do not inline external DTD

        if (m_inExternalDTD)

            return;

        try {

            final Writer writer = m_writer;

            DTDprolog();

            writer.write("<!ELEMENT ");

            writer.write(name);

            writer.write(' ');

            writer.write(model);

            writer.write('>');

            writer.write(m_lineSep, 0, m_lineSepLen);

        }

        catch (IOException e)

        {

            throw new SAXException(e);

        }

    }

    /**

     * Report an internal entity declaration.

     *

     * <p>Only the effective (first) declaration for each entity

     * will be reported.</p>

     *

     * @param name The name of the entity.  If it is a parameter

     *        entity, the name will begin with '%'.

     * @param value The replacement text of the entity.

     * @exception SAXException The application may raise an exception.

     * @see #externalEntityDecl

     * @see org.xml.sax.DTDHandler#unparsedEntityDecl

     */

    public void internalEntityDecl(String name, String value)

        throws SAXException

    {

        // Do not inline external DTD

        if (m_inExternalDTD)

            return;

        try {

            DTDprolog();

            outputEntityDecl(name, value);

        } catch (IOException e) {

            throw new SAXException(e);

        }

    }

    /**

     * Output the doc type declaration.

     *

     * @param name non-null reference to document type name.

     * NEEDSDOC @param value

     *

     * @throws org.xml.sax.SAXException

     */

    void outputEntityDecl(String name, String value) throws IOException

    {

        final Writer writer = m_writer;

        writer.write("<!ENTITY ");

        writer.write(name);

        writer.write(" \"");

        writer.write(value);

        writer.write("\">");

        writer.write(m_lineSep, 0, m_lineSepLen);

    }

    /**

     * Output a system-dependent line break.

     *

     * @throws org.xml.sax.SAXException

     */

    protected final void outputLineSep() throws IOException {

        m_writer.write(m_lineSep, 0, m_lineSepLen);

    }

    void setProp(String name, String val, boolean defaultVal) {

        if (val != null) {

            char first = getFirstCharLocName(name);

            switch (first) {

            case 'c':

                if (OutputKeys.CDATA_SECTION_ELEMENTS.equals(name)) {

                    addCdataSectionElements(val); // val is cdataSectionNames

                }

                break;

            case 'd':

                if (OutputKeys.DOCTYPE_SYSTEM.equals(name)) {

                    this.m_doctypeSystem = val;

                } else if (OutputKeys.DOCTYPE_PUBLIC.equals(name)) {

                    this.m_doctypePublic = val;

                    if (val.startsWith("-//W3C//DTD XHTML"))

                        m_spaceBeforeClose = true;

                }

                break;

            case 'e':

                String newEncoding = val;

                if (OutputKeys.ENCODING.equals(name)) {

                    String possible_encoding = Encodings.getMimeEncoding(val);

                    if (possible_encoding != null) {

                        // if the encoding is being set, try to get the

                        // preferred

                        // mime-name and set it too.

                        super.setProp("mime-name", possible_encoding,

                                defaultVal);

                    }

                    final String oldExplicitEncoding = getOutputPropertyNonDefault(OutputKeys.ENCODING);

                    final String oldDefaultEncoding  = getOutputPropertyDefault(OutputKeys.ENCODING);

                    if ( (defaultVal && ( oldDefaultEncoding == null || !oldDefaultEncoding.equalsIgnoreCase(newEncoding)))

                            || ( !defaultVal && (oldExplicitEncoding == null || !oldExplicitEncoding.equalsIgnoreCase(newEncoding) ))) {

                       // We are trying to change the default or the non-default setting of the encoding to a different value

                       // from what it was

                       EncodingInfo encodingInfo = Encodings.getEncodingInfo(newEncoding);

                       if (newEncoding != null && encodingInfo.name == null) {

                        // We tried to get an EncodingInfo for Object for the given

                        // encoding, but it came back with an internall null name

                        // so the encoding is not supported by the JDK, issue a message.

                        final String msg = Utils.messages.createMessage(

                                MsgKey.ER_ENCODING_NOT_SUPPORTED,new Object[]{ newEncoding });

                        final String msg2 =

                            "Warning: encoding \"" + newEncoding + "\" not supported, using "

                                   + Encodings.DEFAULT_MIME_ENCODING;

                        try {

                                // Prepare to issue the warning message

                                final Transformer tran = super.getTransformer();

                                if (tran != null) {

                                    final ErrorListener errHandler = tran

                                            .getErrorListener();

                                    // Issue the warning message

                                    if (null != errHandler

                                            && m_sourceLocator != null) {

                                        errHandler

                                                .warning(new TransformerException(

                                                        msg, m_sourceLocator));

                                        errHandler

                                                .warning(new TransformerException(

                                                        msg2, m_sourceLocator));

                                    } else {

                                        System.out.println(msg);

                                        System.out.println(msg2);

                                    }

                                } else {

                                    System.out.println(msg);

                                    System.out.println(msg2);

                                }

                            } catch (Exception e) {

                            }

                            // We said we are using UTF-8, so use it

                            newEncoding = Encodings.DEFAULT_MIME_ENCODING;

                            val = Encodings.DEFAULT_MIME_ENCODING; // to store the modified value into the properties a little later

                            encodingInfo = Encodings.getEncodingInfo(newEncoding);

                        }

                       // The encoding was good, or was forced to UTF-8 above

                       // If there is already a non-default set encoding and we

                       // are trying to set the default encoding, skip the this block

                       // as the non-default value is already the one to use.

                       if (defaultVal == false || oldExplicitEncoding == null) {

                           m_encodingInfo = encodingInfo;

                           if (newEncoding != null)

                               m_isUTF8 = newEncoding.equals(Encodings.DEFAULT_MIME_ENCODING);

                           // if there was a previously set OutputStream

                           OutputStream os = getOutputStream();

                           if (os != null) {

                               Writer w = getWriter();

                               // If the writer was previously set, but

                               // set by the user, or if the new encoding is the same

                               // as the old encoding, skip this block

                               String oldEncoding = getOutputProperty(OutputKeys.ENCODING);

                               if ((w == null || !m_writer_set_by_user)

                                       && !newEncoding.equalsIgnoreCase(oldEncoding)) {

                                   // Make the change of encoding in our internal

                                   // table, then call setOutputStreamInternal

                                   // which will stomp on the old Writer (if any)

                                   // with a new Writer with the new encoding.

                                   super.setProp(name, val, defaultVal);

                                   setOutputStreamInternal(os,false);

                               }

                           }

                       }

                    }

                }

                break;

            case 'i':

                if (OutputPropertiesFactory.S_KEY_INDENT_AMOUNT.equals(name)) {

                    setIndentAmount(Integer.parseInt(val));

                } else if (OutputKeys.INDENT.equals(name)) {

                    boolean b = val.endsWith("yes") ? true : false;

                    m_doIndent = b;

                }

                break;