/*

 * Copyright 2006 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.xml.internal.bind.v2.runtime.output;

import java.io.IOException;

import java.io.OutputStream;

import javax.xml.stream.XMLStreamException;

import com.sun.xml.internal.bind.DatatypeConverterImpl;

import com.sun.xml.internal.bind.v2.runtime.Name;

import com.sun.xml.internal.bind.v2.runtime.XMLSerializer;

import org.xml.sax.SAXException;

/**

 * {@link XmlOutput} implementation specialized for UTF-8.

 *

 * @author Kohsuke Kawaguchi

 * @author Paul Sandoz

 */

public class UTF8XmlOutput extends XmlOutputAbstractImpl {

    protected final OutputStream out;

    /** prefixes encoded. */

    private Encoded[] prefixes = new Encoded[8];

    /**

     * Of the {@link #prefixes}, number of filled entries.

     * This is almost the same as {@link NamespaceContextImpl#count()},

     * except that it allows us to handle contextual in-scope namespace bindings correctly.

     */

    private int prefixCount;

    /** local names encoded in UTF-8. All entries are pre-filled. */

    private final Encoded[] localNames;

    /** Temporary buffer used to encode text. */

    /*

     * TODO

     * The textBuffer could write directly to the _octetBuffer

     * when encoding a string if Encoder is modified.

     * This will avoid an additional memory copy.

     */

    private final Encoded textBuffer = new Encoded();

    /** Buffer of octets for writing. */

    // TODO: Obtain buffer size from property on the JAXB context

    protected final byte[] octetBuffer = new byte[1024];

    /** Index in buffer to write to. */

    protected int octetBufferIndex;

    /**

     * Set to true to indicate that we need to write '>'

     * to close a start tag. Deferring the write of this char

     * allows us to write "/>" for empty elements.

     */

    protected boolean closeStartTagPending = false;

    /**

     *

     * @param localNames

     *      local names encoded in UTF-8.

     */

    public UTF8XmlOutput(OutputStream out, Encoded[] localNames) {

        this.out = out;

        this.localNames = localNames;

        for( int i=0; i<prefixes.length; i++ )

            prefixes[i] = new Encoded();

    }

    @Override

    public void startDocument(XMLSerializer serializer, boolean fragment, int[] nsUriIndex2prefixIndex, NamespaceContextImpl nsContext) throws IOException, SAXException, XMLStreamException {

        super.startDocument(serializer, fragment,nsUriIndex2prefixIndex,nsContext);

        octetBufferIndex = 0;

        if(!fragment) {

            write(XML_DECL);

        }

    }

    public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException {

        flushBuffer();

        super.endDocument(fragment);

    }

    /**

     * Writes '>' to close the start tag, if necessary.

     */

    protected final void closeStartTag() throws IOException {

        if(closeStartTagPending) {

            write('>');

            closeStartTagPending = false;

        }

    }

    public void beginStartTag(int prefix, String localName) throws IOException {

        closeStartTag();

        int base= pushNsDecls();

        write('<');

        writeName(prefix,localName);

        writeNsDecls(base);

    }

    public void beginStartTag(Name name) throws IOException {

        closeStartTag();

        int base = pushNsDecls();

        write('<');

        writeName(name);

        writeNsDecls(base);

    }

    private int pushNsDecls() {

        int total = nsContext.count();

        NamespaceContextImpl.Element ns = nsContext.getCurrent();

        if(total > prefixes.length) {

            // reallocate

            int m = Math.max(total,prefixes.length*2);

            Encoded[] buf = new Encoded[m];

            System.arraycopy(prefixes,0,buf,0,prefixes.length);

            for( int i=prefixes.length; i<buf.length; i++ )

                buf[i] = new Encoded();

            prefixes = buf;

        }

        int base = Math.min(prefixCount,ns.getBase());

        int size = nsContext.count();

        for( int i=base; i<size; i++ ) {

            String p = nsContext.getPrefix(i);

            Encoded e = prefixes[i];

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

                e.buf = EMPTY_BYTE_ARRAY;

                e.len = 0;

            } else {

                e.set(p);

                e.append(':');

            }

        }

        prefixCount = size;

        return base;

    }

    protected void writeNsDecls(int base) throws IOException {

        NamespaceContextImpl.Element ns = nsContext.getCurrent();

        int size = nsContext.count();

        for( int i=ns.getBase(); i<size; i++ )

            writeNsDecl(i);

    }

    /**

     * Writes a single namespace declaration for the specified prefix.

     */

    protected final void writeNsDecl(int prefixIndex) throws IOException {

        String p = nsContext.getPrefix(prefixIndex);

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

            if(nsContext.getCurrent().isRootElement()

            && nsContext.getNamespaceURI(prefixIndex).length()==0)

                return;     // no point in declaring xmlns="" on the root element

            write(XMLNS_EQUALS);

        } else {

            Encoded e = prefixes[prefixIndex];

            write(XMLNS_COLON);

            write(e.buf,0,e.len-1); // skip the trailing ':'

            write(EQUALS);

        }

        doText(nsContext.getNamespaceURI(prefixIndex),true);

        write('\"');

    }

    private void writePrefix(int prefix) throws IOException {

        prefixes[prefix].write(this);

    }

    private void writeName(Name name) throws IOException {

        writePrefix(nsUriIndex2prefixIndex[name.nsUriIndex]);

        localNames[name.localNameIndex].write(this);

    }

    private void writeName(int prefix, String localName) throws IOException {

        writePrefix(prefix);

        textBuffer.set(localName);

        textBuffer.write(this);

    }

    @Override

    public void attribute(Name name, String value) throws IOException {

        write(' ');

        if(name.nsUriIndex==-1) {

            localNames[name.localNameIndex].write(this);

        } else

            writeName(name);

        write(EQUALS);

        doText(value,true);

        write('\"');

    }

    public void attribute(int prefix, String localName, String value) throws IOException {

        write(' ');

        if(prefix==-1) {

            textBuffer.set(localName);

            textBuffer.write(this);

        } else

            writeName(prefix,localName);

        write(EQUALS);

        doText(value,true);

        write('\"');

    }

    public void endStartTag() throws IOException {

        closeStartTagPending = true;

    }

    @Override

    public void endTag(Name name) throws IOException {

        if(closeStartTagPending) {

            write(EMPTY_TAG);

            closeStartTagPending = false;

        } else {

            write(CLOSE_TAG);

            writeName(name);

            write('>');

        }

    }

    public void endTag(int prefix, String localName) throws IOException {

        if(closeStartTagPending) {

            write(EMPTY_TAG);

            closeStartTagPending = false;

        } else {

            write(CLOSE_TAG);

            writeName(prefix,localName);

            write('>');

        }

    }

    public void text(String value, boolean needSP) throws IOException {

        closeStartTag();

        if(needSP)

            write(' ');

        doText(value,false);

    }

    public void text(Pcdata value, boolean needSP) throws IOException {

        closeStartTag();

        if(needSP)

            write(' ');

        value.writeTo(this);

    }

    private void doText(String value,boolean isAttribute) throws IOException {

        textBuffer.setEscape(value,isAttribute);

        textBuffer.write(this);

    }

    public final void text(int value) throws IOException {

        closeStartTag();

        /*

         * TODO

         * Change to use the octet buffer directly

         */

        // max is -2147483648 and 11 digits

        boolean minus = (value<0);

        textBuffer.ensureSize(11);

        byte[] buf = textBuffer.buf;

        int idx = 11;

        do {

            int r = value%10;

            if(r<0) r = -r;

            buf[--idx] = (byte)('0'|r);    // really measn 0x30+r but 0<=r<10, so bit-OR would do.

            value /= 10;

        } while(value!=0);

        if(minus)   buf[--idx] = (byte)'-';

        write(buf,idx,11-idx);

    }

    /**

     * Writes the given byte[] as base64 encoded binary to the output.

     *

     * <p>

     * Being defined on this class allows this method to access the buffer directly,

     * which translates to a better performance.

     */

    public void text(byte[] data, int dataLen) throws IOException {

        closeStartTag();

        int start = 0;

        while(dataLen>0) {

            // how many bytes (in data) can we write without overflowing the buffer?

            int batchSize = Math.min(((octetBuffer.length-octetBufferIndex)/4)*3,dataLen);

            // write the batch

            octetBufferIndex = DatatypeConverterImpl._printBase64Binary(data,start,batchSize,octetBuffer,octetBufferIndex);

            if(batchSize<dataLen)

                flushBuffer();

            start += batchSize;

            dataLen -= batchSize;

        }

    }

//

//

// series of the write method that places bytes to the output

// (by doing some buffering internal to this class)

//

    /**

     * Writes one byte directly into the buffer.

     *

     * <p>

     * This method can be used somewhat like the {@code text} method,

     * but it doesn't perform character escaping.

     */

    public final void write(int i) throws IOException {

        if (octetBufferIndex < octetBuffer.length) {

            octetBuffer[octetBufferIndex++] = (byte)i;

        } else {

            out.write(octetBuffer);

            octetBufferIndex = 1;

            octetBuffer[0] = (byte)i;

        }

    }

    protected final void write(byte[] b) throws IOException {

        write(b, 0,  b.length);

    }

    protected final void write(byte[] b, int start, int length) throws IOException {

        if ((octetBufferIndex + length) < octetBuffer.length) {

            System.arraycopy(b, start, octetBuffer, octetBufferIndex, length);

            octetBufferIndex += length;

        } else {

            out.write(octetBuffer, 0, octetBufferIndex);

            out.write(b, start, length);

            octetBufferIndex = 0;

        }

    }

    protected final void flushBuffer() throws IOException {

        out.write(octetBuffer, 0, octetBufferIndex);

        octetBufferIndex = 0;

    }

    static byte[] toBytes(String s) {

        byte[] buf = new byte[s.length()];

        for( int i=s.length()-1; i>=0; i-- )

            buf[i] = (byte)s.charAt(i);

        return buf;

    }

    private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

}