/*

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

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.stream.writers;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.nio.charset.Charset;

import java.nio.charset.CharsetEncoder;

import java.util.AbstractMap;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Random;

import java.util.Vector;

import java.util.Set;

import java.util.Iterator;

import javax.xml.XMLConstants;

import javax.xml.namespace.NamespaceContext;

import javax.xml.stream.XMLOutputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import javax.xml.transform.stream.StreamResult;

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

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

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

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

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

import com.sun.xml.internal.stream.util.ReadOnlyIterator;

/**

 * This class implements a StAX XMLStreamWriter. It extends

 * <code>AbstractMap</code> in order to support a getter for

 * implementation-specific properties. For example, you can get

 * the underlying <code>OutputStream</code> by casting an instance

 * of this class to <code>Map</code> and calling

 * <code>getProperty(OUTPUTSTREAM_PROPERTY)</code>.

 *

 * @author Neeraj Bajaj

 * @author K.Venugopal

 * @author Santiago.Pericas-Geertsen@sun.com

 * @author Sunitha.Reddy@sun.com

 */

public final class XMLStreamWriterImpl extends AbstractMap implements XMLStreamWriter {

    public static final String START_COMMENT = "<!--";

    public static final String END_COMMENT = "-->";

    public static final String DEFAULT_ENCODING = " encoding=\"utf-8\"";

    public static final String DEFAULT_XMLDECL = "<?xml version=\"1.0\" ?>";

    public static final String DEFAULT_XML_VERSION = "1.0";

    public static final char CLOSE_START_TAG = '>';

    public static final char OPEN_START_TAG = '<';

    public static final String OPEN_END_TAG = "</";

    public static final char CLOSE_END_TAG = '>';

    public static final String START_CDATA = "<![CDATA[";

    public static final String END_CDATA = "]]>";

    public static final String CLOSE_EMPTY_ELEMENT = "/>";

    public static final String SPACE = " ";

    public static final String UTF_8 = "UTF-8";

    public static final String OUTPUTSTREAM_PROPERTY = "sjsxp-outputstream";

    /**

     * This flag can be used to turn escaping off for content. It does

     * not apply to attribute content.

     */

    boolean fEscapeCharacters = true;

    /**

     * Flag for the value of repairNamespace property

     */

    private boolean fIsRepairingNamespace = false;

    /**

     * Underlying Writer to which characters are written.

     */

    private Writer fWriter;

    /**

     * Underlying OutputStream to which <code>fWriter</code>

     * writes to. May be null if unknown.

     */

    private OutputStream fOutputStream = null;

    /**

     * Collects attributes when the writer is in reparing mode.

     */

    private ArrayList fAttributeCache;

    /**

     * Collects namespace declarations when the writer is in reparing mode.

     */

    private ArrayList fNamespaceDecls;

    /**

     * Namespace context encapsulating user specified context

     * and context built by the writer

     */

    private NamespaceContextImpl fNamespaceContext = null;

    private NamespaceSupport fInternalNamespaceContext = null;

    private Random fPrefixGen = null;

    /**

     * Reference to PropertyManager

     */

    private PropertyManager fPropertyManager = null;

    /**

     * Flag to track if start tag is opened

     */

    private boolean fStartTagOpened = false;

    /**

     * Boolean flag  to indicate, if instance can be reused

     */

    private boolean fReuse;

    private SymbolTable fSymbolTable = new SymbolTable();

    private ElementStack fElementStack = new ElementStack(); //Change this .-Venu

    final private String DEFAULT_PREFIX = fSymbolTable.addSymbol("");

    private final ReadOnlyIterator fReadOnlyIterator = new ReadOnlyIterator();

    /**

     * In some cases, this charset encoder is used to determine if a char is

     * encodable by underlying writer. For example, an 8-bit char from the

     * extended ASCII set is not encodable by 7-bit ASCII encoder. Unencodable

     * chars are escaped using XML numeric entities.

     */

    private CharsetEncoder fEncoder = null;

     /**

     * This is used to hold the namespace for attributes which happen to have

     * the same uri as the default namespace; It's added to avoid changing the

     * current impl. which has many redundant code for the repair mode

     */

    HashMap fAttrNamespace = null;

    /**

     * Creates a new instance of XMLStreamWriterImpl. Uses platform's default

     * encoding.

     *

     * @param outputStream Underlying stream to write the bytes to

     * @param props        Properties used by this writer

     */

    public XMLStreamWriterImpl(OutputStream outputStream, PropertyManager props)

        throws IOException {

        // cannot call this(outputStream, null, props); for constructor,

        // OutputStreamWriter charsetName cannot be null

        // use default encoding

        this(new OutputStreamWriter(outputStream), props);

    }

    /**

     * Creates a new instance of XMLStreamWriterImpl.

     *

     * @param outputStream Underlying stream to write the bytes

     * @param encoding     Encoding used to convert chars into bytes

     * @param props        Properties used by this writer

     */

    public XMLStreamWriterImpl(OutputStream outputStream, String encoding,

        PropertyManager props) throws java.io.IOException {

        this(new StreamResult(outputStream), encoding, props);

    }

    /**

     * Creates a new instance of XMLStreamWriterImpl using a Writer.

     *

     * @param writer  Underlying writer to which chars are written

     * @param props   Properties used by this writer

     */

    public XMLStreamWriterImpl(Writer writer, PropertyManager props)

        throws java.io.IOException {

        this(new StreamResult(writer), null, props);

    }

    /**

     * Creates a new instance of XMLStreamWriterImpl using a StreamResult.

     * A StreamResult encasupates an OutputStream, a Writer or a SystemId.

     *

     * @param writer  Underlying writer to which chars are written

     * @param props   Properties used by this writer

     */

    public XMLStreamWriterImpl(StreamResult sr, String encoding,

        PropertyManager props) throws java.io.IOException {

        setOutput(sr, encoding);

        fPropertyManager = props;

        init();

    }

    /**

     * Initialize an instance of this XMLStreamWriter. Allocate new instances

     * for all the data structures. Set internal flags based on property values.

     */

    private void init() {

        fReuse = false;

        fNamespaceDecls = new ArrayList();

        fPrefixGen = new Random();

        fAttributeCache = new ArrayList();

        fInternalNamespaceContext = new NamespaceSupport();

        fInternalNamespaceContext.reset();

        fNamespaceContext = new NamespaceContextImpl();

        fNamespaceContext.internalContext = fInternalNamespaceContext;

        // Set internal state based on property values

        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);

        fIsRepairingNamespace = ob.booleanValue();

        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);

        setEscapeCharacters(ob.booleanValue());

    }

    /**

     * Reset this instance so that it can be re-used. Do not read properties

     * again. The method <code>setOutput(StreamResult, encoding)</code> must

     * be called after this one.

     */

    public void reset() {

        reset(false);

    }

    /**

     * Reset this instance so that it can be re-used. Clears but does not

     * re-allocate internal data structures.

     *

     * @param resetProperties Indicates if properties should be read again

     */

    void reset(boolean resetProperties) {

        if (!fReuse) {

            throw new java.lang.IllegalStateException(

                "close() Must be called before calling reset()");

        }

        fReuse = false;

        fNamespaceDecls.clear();

        fAttributeCache.clear();

        // reset Element/NamespaceContext stacks

        fElementStack.clear();

        fInternalNamespaceContext.reset();

        fStartTagOpened = false;

        fNamespaceContext.userContext = null;

        if (resetProperties) {

            Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);

            fIsRepairingNamespace = ob.booleanValue();

            ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);

            setEscapeCharacters(ob.booleanValue());

        }

    }

    /**

     * Use a StreamResult to initialize the output for this XMLStreamWriter. Check

     * for OutputStream, Writer and then systemId, in that order.

     *

     * @param sr        StreamResult encapsulating output information

     * @param encoding  Encoding to be used except when a Writer is available

     */

    public void setOutput(StreamResult sr, String encoding)

        throws IOException {

        if (sr.getOutputStream() != null) {

            setOutputUsingStream(sr.getOutputStream(), encoding);

        }

        else if (sr.getWriter() != null) {

            setOutputUsingWriter(sr.getWriter());

        }

        else if (sr.getSystemId() != null) {

            setOutputUsingStream(new FileOutputStream(sr.getSystemId()),

                encoding);

        }

    }

     private void setOutputUsingWriter(Writer writer)

        throws IOException

     {

         fWriter = writer;

         if (writer instanceof OutputStreamWriter) {

             String charset = ((OutputStreamWriter) writer).getEncoding();

             if (charset != null && !charset.equalsIgnoreCase("utf-8")) {

                 fEncoder = Charset.forName(charset).newEncoder();

             }

         }

     }

    /**

     * Utility method to create a writer when passed an OutputStream. Make

     * sure to wrap an <code>OutputStreamWriter</code> using an

     * <code>XMLWriter</code> for performance reasons.

     *

     * @param os        Underlying OutputStream

     * @param encoding  Encoding used to convert chars into bytes

     */

    private void setOutputUsingStream(OutputStream os, String encoding)

        throws IOException {

        fOutputStream = os;

        if (encoding != null) {

            if (encoding.equalsIgnoreCase("utf-8")) {

                fWriter = new UTF8OutputStreamWriter(os);

            }

            else {

                fWriter = new XMLWriter(new OutputStreamWriter(os, encoding));

                fEncoder = Charset.forName(encoding).newEncoder();

            }

        } else {

            if (encoding != null && encoding.equalsIgnoreCase("utf-8")) {

                fWriter = new UTF8OutputStreamWriter(os);

            } else {

                fWriter = new XMLWriter(new OutputStreamWriter(os));

            }

        }

    }

    /** Can this instance be reused

     *

     * @return boolean boolean value to indicate if this instance can be reused or not

     */

    public boolean canReuse() {

        return fReuse;

    }

    public void setEscapeCharacters(boolean escape) {

        fEscapeCharacters = escape;

    }

    public boolean getEscapeCharacters() {

        return fEscapeCharacters;

    }

    /**

     * Close this XMLStreamWriter by closing underlying writer.

     */

    public void close() throws XMLStreamException {

        if (fWriter != null) {

            try {

                //fWriter.close();

                fWriter.flush();

            } catch (IOException e) {

                throw new XMLStreamException(e);

            }

        }

        fWriter = null;

        fOutputStream = null;

        fNamespaceDecls.clear();

        fAttributeCache.clear();

        fElementStack.clear();

        fInternalNamespaceContext.reset();

        fReuse = true;

        fStartTagOpened = false;

        fNamespaceContext.userContext = null;

    }

    /**

     * Flush this XMLStreamWriter by flushin underlying writer.

     */

    public void flush() throws XMLStreamException {

        try {

            fWriter.flush();

        } catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    /**

     * Return <code>NamespaceContext</code> being used by the writer.

     *

     * @return NamespaceContext

     */

    public NamespaceContext getNamespaceContext() {

        return fNamespaceContext;

    }

    /**

     * Return a prefix associated with specified uri, or null if the

     * uri is unknown.

     *

     * @param  uri The namespace uri

     * @throws XMLStreamException if uri specified is "" or null

     */

    public String getPrefix(String uri) throws XMLStreamException {

        return fNamespaceContext.getPrefix(uri);

    }

    /**

     * Returns value associated with the specified property name.

     *

     * @param  str Property name

     * @throws IllegalArgumentException if the specified property is not supported

     * @return value associated with the specified property.

     */

    public Object getProperty(String str)

        throws IllegalArgumentException {

        if (str == null) {

            throw new NullPointerException();

        }

        if (!fPropertyManager.containsProperty(str)) {

            throw new IllegalArgumentException("Property '" + str +

                "' is not supported");

        }

        return fPropertyManager.getProperty(str);

    }

    /**

     * Set the specified URI as default namespace in the current namespace context.

     *

     * @param uri Namespace URI

     */

    public void setDefaultNamespace(String uri) throws XMLStreamException {

        if (uri != null) {

            uri = fSymbolTable.addSymbol(uri);

        }

        if (fIsRepairingNamespace) {

            if (isDefaultNamespace(uri)) {

                return;

            }

            QName qname = new QName();

            qname.setValues(DEFAULT_PREFIX, "xmlns", null, uri);

            fNamespaceDecls.add(qname);

        } else {

            fInternalNamespaceContext.declarePrefix(DEFAULT_PREFIX, uri);

        }

    }

    /**

     * Sets the current <code>NamespaceContext</code> for prefix and uri bindings.

     * This context becomes the root namespace context for writing and

     * will replace the current root namespace context. Subsequent calls

     * to setPrefix and setDefaultNamespace will bind namespaces using

     * the context passed to the method as the root context for resolving

     * namespaces. This method may only be called once at the start of the

     * document. It does not cause the namespaces to be declared. If a

     * namespace URI to prefix mapping is found in the namespace context

     * it is treated as declared and the prefix may be used by the

     * <code>XMLStreamWriter</code>.

     *

     * @param namespaceContext the namespace context to use for this writer, may not be null

     * @throws XMLStreamException

     */

    public void setNamespaceContext(NamespaceContext namespaceContext)

        throws XMLStreamException {

        fNamespaceContext.userContext = namespaceContext;

    }

    /**

     * Sets the prefix the uri is bound to. This prefix is bound in the scope of

     * the current START_ELEMENT / END_ELEMENT pair. If this method is called before

     * a START_ELEMENT has been written the prefix is bound in the root scope.

     *

     * @param prefix

     * @param uri

     * @throws XMLStreamException

     */

    public void setPrefix(String prefix, String uri) throws XMLStreamException {

        if (prefix == null) {

            throw new XMLStreamException("Prefix cannot be null");

        }

        if (uri == null) {

            throw new XMLStreamException("URI cannot be null");

        }

        prefix = fSymbolTable.addSymbol(prefix);

        uri = fSymbolTable.addSymbol(uri);

        if (fIsRepairingNamespace) {

            String tmpURI = fInternalNamespaceContext.getURI(prefix);

            if ((tmpURI != null) && (tmpURI == uri)) {

                return;

            }

            if(checkUserNamespaceContext(prefix,uri))

                return;

            QName qname = new QName();

            qname.setValues(prefix,XMLConstants.XMLNS_ATTRIBUTE, null,uri);

            fNamespaceDecls.add(qname);

            return;

        }

        fInternalNamespaceContext.declarePrefix(prefix, uri);

    }

    public void writeAttribute(String localName, String value)