/*

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

 *

 * THIS FILE WAS MODIFIED BY SUN MICROSYSTEMS, INC.

 */

package com.sun.xml.internal.fastinfoset.stax;

import com.sun.xml.internal.fastinfoset.Encoder;

import com.sun.xml.internal.fastinfoset.EncodingConstants;

import com.sun.xml.internal.fastinfoset.util.NamespaceContextImplementation;

import java.io.IOException;

import java.io.OutputStream;

import java.util.EmptyStackException;

import javax.xml.namespace.NamespaceContext;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmIndexes;

import com.sun.xml.internal.fastinfoset.CommonResourceBundle;

import com.sun.xml.internal.fastinfoset.QualifiedName;

import com.sun.xml.internal.fastinfoset.util.LocalNameQualifiedNamesMap;

import com.sun.xml.internal.org.jvnet.fastinfoset.stax.LowLevelFastInfosetStreamWriter;

/**

 * The Fast Infoset StAX serializer.

 * <p>

 * Instantiate this serializer to serialize a fast infoset document in accordance

 * with the StAX API.

 *

 * <p>

 * More than one fast infoset document may be encoded to the

 * {@link java.io.OutputStream}.

 */

public class StAXDocumentSerializer extends Encoder

        implements XMLStreamWriter, LowLevelFastInfosetStreamWriter {

    protected StAXManager _manager;

    protected String _encoding;

    /**

     * Local name of current element.

     */

    protected String _currentLocalName;

    /**

     * Namespace of current element.

     */

    protected String _currentUri;

    /**

     * Prefix of current element.

     */

    protected String _currentPrefix;

   /**

     * This flag indicates when there is a pending start element event.

     */

    protected boolean _inStartElement = false;

    /**

     * This flag indicates if the current element is empty.

     */

    protected boolean _isEmptyElement = false;

    /**

     * List of attributes qnames and values defined in the current element.

     */

    protected String[] _attributesArray = new String[4 * 16];

    protected int _attributesArrayIndex = 0;

    protected boolean[] _nsSupportContextStack = new boolean[32];

    protected int _stackCount = -1;

    /**

     * Mapping between uris and prefixes.

     */

    protected NamespaceContextImplementation _nsContext =

            new NamespaceContextImplementation();

    /**

     * List of namespaces defined in the current element.

     */

    protected String[] _namespacesArray = new String[2 * 8];

    protected int _namespacesArrayIndex = 0;

    public StAXDocumentSerializer() {

        super(true);

        _manager = new StAXManager(StAXManager.CONTEXT_WRITER);

    }

    public StAXDocumentSerializer(OutputStream outputStream) {

        super(true);

        setOutputStream(outputStream);

        _manager = new StAXManager(StAXManager.CONTEXT_WRITER);

    }

    public StAXDocumentSerializer(OutputStream outputStream, StAXManager manager) {

        super(true);

        setOutputStream(outputStream);

        _manager = manager;

    }

    public void reset() {

        super.reset();

        _attributesArrayIndex = 0;

        _namespacesArrayIndex = 0;

        _nsContext.reset();

        _stackCount = -1;

        _currentUri = _currentPrefix = null;

        _currentLocalName = null;

        _inStartElement = _isEmptyElement = false;

    }

    // -- XMLStreamWriter Interface -------------------------------------------

    public void writeStartDocument() throws XMLStreamException {

        writeStartDocument("finf", "1.0");

    }

    public void writeStartDocument(String version) throws XMLStreamException {

        writeStartDocument("finf", version);

    }

    public void writeStartDocument(String encoding, String version)

        throws XMLStreamException

    {

        reset();

        try {

            encodeHeader(false);

            encodeInitialVocabulary();

        } catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeEndDocument() throws XMLStreamException {

        try {

            // terminate all elements not terminated

            // by writeEndElement

            for(;_stackCount >= 0; _stackCount--) {

                writeEndElement();

            }

            encodeDocumentTermination();

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void close() throws XMLStreamException {

        reset();

    }

    public void flush() throws XMLStreamException {

        try {

            _s.flush();

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeStartElement(String localName)

        throws XMLStreamException

    {

        // TODO is it necessary for FI to obtain the default namespace in scope?

        writeStartElement("", localName, "");

    }

    public void writeStartElement(String namespaceURI, String localName)

        throws XMLStreamException

    {

        writeStartElement("", localName, namespaceURI);

    }

    public void writeStartElement(String prefix, String localName,

        String namespaceURI) throws XMLStreamException

    {

        encodeTerminationAndCurrentElement(false);

        _inStartElement = true;

        _isEmptyElement = false;

        _currentLocalName = localName;

        _currentPrefix = prefix;

        _currentUri = namespaceURI;

        _stackCount++;

        if (_stackCount == _nsSupportContextStack.length) {

            boolean[] nsSupportContextStack = new boolean[_stackCount * 2];

            System.arraycopy(_nsSupportContextStack, 0, nsSupportContextStack, 0, _nsSupportContextStack.length);

            _nsSupportContextStack = nsSupportContextStack;

        }

        _nsSupportContextStack[_stackCount] = false;

    }

    public void writeEmptyElement(String localName)

        throws XMLStreamException

    {

        writeEmptyElement("", localName, "");

    }

    public void writeEmptyElement(String namespaceURI, String localName)

        throws XMLStreamException

    {

        writeEmptyElement("", localName, namespaceURI);

    }

    public void writeEmptyElement(String prefix, String localName,

        String namespaceURI) throws XMLStreamException

    {

        encodeTerminationAndCurrentElement(false);

        _isEmptyElement = _inStartElement = true;

        _currentLocalName = localName;

        _currentPrefix = prefix;

        _currentUri = namespaceURI;

        _stackCount++;

        if (_stackCount == _nsSupportContextStack.length) {

            boolean[] nsSupportContextStack = new boolean[_stackCount * 2];

            System.arraycopy(_nsSupportContextStack, 0, nsSupportContextStack, 0, _nsSupportContextStack.length);

            _nsSupportContextStack = nsSupportContextStack;

        }

        _nsSupportContextStack[_stackCount] = false;

    }

    public void writeEndElement() throws XMLStreamException {

        if (_inStartElement) {

            encodeTerminationAndCurrentElement(false);

        }

        try {

            encodeElementTermination();

            if (_nsSupportContextStack[_stackCount--] == true) {

                _nsContext.popContext();

            }

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

        catch (EmptyStackException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeAttribute(String localName, String value)

        throws XMLStreamException

    {

        writeAttribute("", "", localName, value);

    }

    public void writeAttribute(String namespaceURI, String localName,

        String value) throws XMLStreamException

    {

        String prefix = "";

        // Find prefix for attribute, ignoring default namespace

        if (namespaceURI.length() > 0) {

            prefix = _nsContext.getNonDefaultPrefix(namespaceURI);

            // Undeclared prefix or ignorable default ns?

            if (prefix == null || prefix.length() == 0) {

                // Workaround for BUG in SAX NamespaceSupport helper

                // which incorrectly defines namespace declaration URI

                if (namespaceURI == EncodingConstants.XMLNS_NAMESPACE_NAME ||

                        namespaceURI.equals(EncodingConstants.XMLNS_NAMESPACE_NAME)) {

                    // TODO

                    // Need to check carefully the rule for the writing of

                    // namespaces in StAX. Is it safe to ignore such

                    // attributes, as declarations will be made using the

                    // writeNamespace method

                    return;

                }

                throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.URIUnbound", new Object[]{namespaceURI}));

            }

        }

        writeAttribute(prefix, namespaceURI, localName, value);

    }

    public void writeAttribute(String prefix, String namespaceURI,

        String localName, String value) throws XMLStreamException

    {

        if (!_inStartElement) {

            throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.attributeWritingNotAllowed"));

        }

        // TODO

        // Need to check carefully the rule for the writing of

        // namespaces in StAX. Is it safe to ignore such

        // attributes, as declarations will be made using the

        // writeNamespace method

        if (namespaceURI == EncodingConstants.XMLNS_NAMESPACE_NAME ||

                namespaceURI.equals(EncodingConstants.XMLNS_NAMESPACE_NAME)) {

            return;

        }

        if (_attributesArrayIndex == _attributesArray.length) {

            final String[] attributesArray = new String[_attributesArrayIndex * 2];

            System.arraycopy(_attributesArray, 0, attributesArray, 0, _attributesArrayIndex);

            _attributesArray = attributesArray;

        }

        _attributesArray[_attributesArrayIndex++] = namespaceURI;

        _attributesArray[_attributesArrayIndex++] = prefix;

        _attributesArray[_attributesArrayIndex++] = localName;

        _attributesArray[_attributesArrayIndex++] = value;

    }

    public void writeNamespace(String prefix, String namespaceURI)

        throws XMLStreamException

    {

        if (prefix == null || prefix.length() == 0 || prefix.equals(EncodingConstants.XMLNS_NAMESPACE_PREFIX)) {

            writeDefaultNamespace(namespaceURI);

        }

        else {

            if (!_inStartElement) {

                throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.attributeWritingNotAllowed"));

            }

            if (_namespacesArrayIndex == _namespacesArray.length) {

                final String[] namespacesArray = new String[_namespacesArrayIndex * 2];

                System.arraycopy(_namespacesArray, 0, namespacesArray, 0, _namespacesArrayIndex);

                _namespacesArray = namespacesArray;

            }

            _namespacesArray[_namespacesArrayIndex++] = prefix;

            _namespacesArray[_namespacesArrayIndex++] = namespaceURI;

            setPrefix(prefix, namespaceURI);

        }

    }

    public void writeDefaultNamespace(String namespaceURI)

        throws XMLStreamException

    {

        if (!_inStartElement) {

            throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.attributeWritingNotAllowed"));

        }

        if (_namespacesArrayIndex == _namespacesArray.length) {

            final String[] namespacesArray = new String[_namespacesArrayIndex * 2];

            System.arraycopy(_namespacesArray, 0, namespacesArray, 0, _namespacesArrayIndex);

            _namespacesArray = namespacesArray;

        }

        _namespacesArray[_namespacesArrayIndex++] = "";

        _namespacesArray[_namespacesArrayIndex++] = namespaceURI;

        setPrefix("", namespaceURI);

    }

    public void writeComment(String data) throws XMLStreamException {

        try {

            if (getIgnoreComments()) return;

            encodeTerminationAndCurrentElement(true);

            // TODO: avoid array copy here

            encodeComment(data.toCharArray(), 0, data.length());

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeProcessingInstruction(String target)

        throws XMLStreamException

    {

        writeProcessingInstruction(target, "");

    }

    public void writeProcessingInstruction(String target, String data)

        throws XMLStreamException

    {

        try {

            if (getIgnoreProcesingInstructions()) return;

            encodeTerminationAndCurrentElement(true);

            encodeProcessingInstruction(target, data);

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeCData(String text) throws XMLStreamException {

         try {

            final int length = text.length();

            if (length == 0) {

                return;

            } else if (length < _charBuffer.length) {

                if (getIgnoreWhiteSpaceTextContent() &&

                        isWhiteSpace(text)) return;

                // Warning: this method must be called before any state

                // is modified, such as the _charBuffer contents,

                // so the characters of text cannot be copied to _charBuffer

                // before this call

                encodeTerminationAndCurrentElement(true);

                text.getChars(0, length, _charBuffer, 0);

                encodeCIIBuiltInAlgorithmDataAsCDATA(_charBuffer, 0, length);

            } else {

                final char ch[] = text.toCharArray();

                if (getIgnoreWhiteSpaceTextContent() &&

                        isWhiteSpace(ch, 0, length)) return;

                encodeTerminationAndCurrentElement(true);

                encodeCIIBuiltInAlgorithmDataAsCDATA(ch, 0, length);

            }

        } catch (Exception e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeDTD(String dtd) throws XMLStreamException {

        throw new UnsupportedOperationException(CommonResourceBundle.getInstance().getString("message.notImplemented"));

    }

    public void writeEntityRef(String name) throws XMLStreamException {

        throw new UnsupportedOperationException(CommonResourceBundle.getInstance().getString("message.notImplemented"));

    }

    public void writeCharacters(String text) throws XMLStreamException {

         try {

            final int length = text.length();

            if (length == 0) {

                return;

            } else if (length < _charBuffer.length) {

                if (getIgnoreWhiteSpaceTextContent() &&

                        isWhiteSpace(text)) return;

                // Warning: this method must be called before any state

                // is modified, such as the _charBuffer contents,

                // so the characters of text cannot be copied to _charBuffer

                // before this call

                encodeTerminationAndCurrentElement(true);

                text.getChars(0, length, _charBuffer, 0);

                encodeCharacters(_charBuffer, 0, length);

            } else {

                final char ch[] = text.toCharArray();

                if (getIgnoreWhiteSpaceTextContent() &&

                        isWhiteSpace(ch, 0, length)) return;

                encodeTerminationAndCurrentElement(true);

                encodeCharactersNoClone(ch, 0, length);

            }

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public void writeCharacters(char[] text, int start, int len)

        throws XMLStreamException

    {

         try {

            if (len <= 0) {

                return;

            }

            if (getIgnoreWhiteSpaceTextContent() &&

                    isWhiteSpace(text, start, len)) return;

            encodeTerminationAndCurrentElement(true);

            encodeCharacters(text, start, len);

        }

        catch (IOException e) {

            throw new XMLStreamException(e);

        }

    }

    public String getPrefix(String uri) throws XMLStreamException {

        return _nsContext.getPrefix(uri);

    }

    public void setPrefix(String prefix, String uri)

        throws XMLStreamException

    {

        if (_stackCount > -1 && _nsSupportContextStack[_stackCount] == false) {

            _nsSupportContextStack[_stackCount] = true;

            _nsContext.pushContext();

        }

        _nsContext.declarePrefix(prefix, uri);

    }

    public void setDefaultNamespace(String uri) throws XMLStreamException {

        setPrefix("", uri);

    }

    /**

     * Sets the current namespace context for prefix and uri bindings.

     * This context becomes the root namespace context for writing and