/*

 * 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.org.apache.xalan.internal.xsltc.trax;

import java.util.Iterator;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import javax.xml.stream.XMLEventWriter;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.ext.Locator2;

/**

 * @author Sunitha Reddy

 */

public class SAX2StAXStreamWriter extends SAX2StAXBaseWriter {

        private XMLStreamWriter writer;

        private boolean needToCallStartDocument = false;

        public SAX2StAXStreamWriter() {

        }

        public SAX2StAXStreamWriter(XMLStreamWriter writer) {

                this.writer = writer;

        }

        public XMLStreamWriter getStreamWriter() {

                return writer;

        }

        public void setStreamWriter(XMLStreamWriter writer) {

                this.writer = writer;

        }

        public void startDocument() throws SAXException {

                super.startDocument();

                // Encoding and version info will be available only after startElement

                // is called for first time. So, defer START_DOCUMENT event of StAX till

                // that point of time.

                needToCallStartDocument = true;

        }

        public void endDocument() throws SAXException {

                try {

                        writer.writeEndDocument();

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

                super.endDocument();

        }

        public void startElement(String uri, String localName, String qName,

                        Attributes attributes) throws SAXException {

                if (needToCallStartDocument) {

                    try {

                        if (docLocator == null)

                            writer.writeStartDocument();

                        else {

                            try{

                                writer.writeStartDocument(((Locator2)docLocator).getXMLVersion());

                            }catch(ClassCastException e){

                                writer.writeStartDocument();

                            }

                        }

                    } catch (XMLStreamException e) {

                            throw new SAXException(e);

                    }

                    needToCallStartDocument = false;

                }

                try {

                        String[] qname = {null, null};

                        parseQName(qName, qname);

                        //Do not call writeStartElement with prefix and namespaceURI, as it writes out

                        //namespace declaration.

                        //writer.writeStartElement(qname[0], qname[1], uri);

                        writer.writeStartElement(qName);

                        // No need to write namespaces, as they are written as part of attributes.

                        /*if (namespaces != null) {

                            final int nDecls = namespaces.size();

                            for (int i = 0; i < nDecls; i++) {

                                final String prefix = (String) namespaces.elementAt(i);

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

                                    writer.setDefaultNamespace((String)namespaces.elementAt(++i));

                                } else {

                                    writer.setPrefix(prefix, (String) namespaces.elementAt(++i));

                                }

                                writer.writeNamespace(prefix, (String)namespaces.elementAt(i));

                            }

                        }*/

                        // write attributes

                        for (int i = 0, s = attributes.getLength(); i < s; i++) {

                                parseQName(attributes.getQName(i), qname);

                                String attrPrefix = qname[0];

                                String attrLocal = qname[1];

                                String attrQName = attributes.getQName(i);

                                String attrValue = attributes.getValue(i);

                                String attrURI = attributes.getURI(i);

                                if ("xmlns".equals(attrPrefix) || "xmlns".equals(attrQName)) {

                                        // namespace declaration disguised as an attribute.

                                        // write it as an namespace

                                        if (attrLocal.length() == 0) {

                                            writer.setDefaultNamespace(attrValue);

                                        } else {

                                            writer.setPrefix(attrLocal, attrValue);

                                        }

                                        writer.writeNamespace(attrLocal, attrValue);

                                } else if (attrPrefix.length() > 0) {

                                        writer.writeAttribute(attrPrefix, attrURI, attrLocal,

                                                        attrValue);

                                } else {

                                        writer.writeAttribute(attrQName, attrValue);

                                }

                        }

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                } finally {

                        super.startElement(uri, localName, qName, attributes);

                }

        }

        public void endElement(String uri, String localName, String qName)

                        throws SAXException {

                try {

                        writer.writeEndElement();

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                } finally {

                        super.endElement(uri, localName, qName);

                }

        }

        public void comment(char[] ch, int start, int length) throws SAXException {

                super.comment(ch, start, length);

                try {

                        writer.writeComment(new String(ch, start, length));

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

        }

        public void characters(char[] ch, int start, int length)

                        throws SAXException {

                super.characters(ch, start, length);

                try {

                        if (!isCDATA) {

                                writer.writeCharacters(ch, start, length);

                        }

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

        }

        public void endCDATA() throws SAXException {

                try {

                        writer.writeCData(CDATABuffer.toString());

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

                super.endCDATA();

        }

        public void ignorableWhitespace(char[] ch, int start, int length)

                        throws SAXException {

                super.ignorableWhitespace(ch, start, length);

                try {

                        writer.writeCharacters(ch, start, length);

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

        }

        public void processingInstruction(String target, String data)

                        throws SAXException {

                super.processingInstruction(target, data);

                try {

                        writer.writeProcessingInstruction(target, data);

                } catch (XMLStreamException e) {

                        throw new SAXException(e);

                }

        }

}