/*

 * 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 sun.net.www.http;

import java.io.*;

/**

 * OutputStream that sends the output to the underlying stream using chunked

 * encoding as specified in RFC 2068.

 */

public class ChunkedOutputStream extends PrintStream {

    /* Default chunk size (including chunk header) if not specified */

    static final int DEFAULT_CHUNK_SIZE = 4096;

    private static final byte[] CRLF = {'\r', '\n'};

    private static final int CRLF_SIZE = CRLF.length;

    private static final byte[] FOOTER = CRLF;

    private static final int FOOTER_SIZE = CRLF_SIZE;

    private static final byte[] EMPTY_CHUNK_HEADER = getHeader(0);

    private static final int EMPTY_CHUNK_HEADER_SIZE = getHeaderSize(0);

    /* internal buffer */

    private byte buf[];

    /* size of data (excluding footers and headers) already stored in buf */

    private int size;

    /* current index in buf (i.e. buf[count] */

    private int count;

    /* number of bytes to be filled up to complete a data chunk

     * currently being built */

    private int spaceInCurrentChunk;

    /* underlying stream */

    private PrintStream out;

    /* the chunk size we use */

    private int preferredChunkDataSize;

    private int preferedHeaderSize;

    private int preferredChunkGrossSize;

    /* header for a complete Chunk */

    private byte[] completeHeader;

    /* return the size of the header for a particular chunk size */

    private static int getHeaderSize(int size) {

        return (Integer.toHexString(size)).length() + CRLF_SIZE;

    }

    /* return a header for a particular chunk size */

    private static byte[] getHeader(int size){

        try {

            String hexStr =  Integer.toHexString(size);

            byte[] hexBytes = hexStr.getBytes("US-ASCII");

            byte[] header = new byte[getHeaderSize(size)];

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

                header[i] = hexBytes[i];

            header[hexBytes.length] = CRLF[0];

            header[hexBytes.length+1] = CRLF[1];

            return header;

        } catch (java.io.UnsupportedEncodingException e) {

            /* This should never happen */

            throw new InternalError(e.getMessage(), e);

        }

    }

    public ChunkedOutputStream(PrintStream o) {

        this(o, DEFAULT_CHUNK_SIZE);

    }

    public ChunkedOutputStream(PrintStream o, int size) {

        super(o);

        out = o;

        if (size <= 0) {

            size = DEFAULT_CHUNK_SIZE;

        }

        /* Adjust the size to cater for the chunk header - eg: if the

         * preferred chunk size is 1k this means the chunk size should

         * be 1017 bytes (differs by 7 from preferred size because of

         * 3 bytes for chunk size in hex and CRLF (header) and CRLF (footer)).

         *

         * If headerSize(adjusted_size) is shorter then headerSize(size)

         * then try to use the extra byte unless headerSize(adjusted_size+1)

         * increases back to headerSize(size)

         */

        if (size > 0) {

            int adjusted_size = size - getHeaderSize(size) - FOOTER_SIZE;

            if (getHeaderSize(adjusted_size+1) < getHeaderSize(size)){

                adjusted_size++;

            }

            size = adjusted_size;

        }

        if (size > 0) {

            preferredChunkDataSize = size;

        } else {

            preferredChunkDataSize = DEFAULT_CHUNK_SIZE -

                    getHeaderSize(DEFAULT_CHUNK_SIZE) - FOOTER_SIZE;

        }

        preferedHeaderSize = getHeaderSize(preferredChunkDataSize);

        preferredChunkGrossSize = preferedHeaderSize + preferredChunkDataSize

                + FOOTER_SIZE;

        completeHeader = getHeader(preferredChunkDataSize);

        /* start with an initial buffer */

        buf = new byte[preferredChunkGrossSize];

        reset();

    }

    /*

     * Flush a buffered, completed chunk to an underlying stream. If the data in

     * the buffer is insufficient to build up a chunk of "preferredChunkSize"

     * then the data do not get flushed unless flushAll is true. If flushAll is

     * true then the remaining data builds up a last chunk which size is smaller

     * than preferredChunkSize, and then the last chunk gets flushed to

     * underlying stream. If flushAll is true and there is no data in a buffer

     * at all then an empty chunk (containing a header only) gets flushed to

     * underlying stream.

     */

     private void flush(boolean flushAll) {

        if (spaceInCurrentChunk == 0) {

            /* flush a completed chunk to underlying stream */

            out.write(buf, 0, preferredChunkGrossSize);

            out.flush();

            reset();

        } else if (flushAll){

            /* complete the last chunk and flush it to underlying stream */

            if (size > 0){

                /* adjust a header start index in case the header of the last

                 * chunk is shorter then preferedHeaderSize */

                int adjustedHeaderStartIndex = preferedHeaderSize -

                        getHeaderSize(size);

                /* write header */

                System.arraycopy(getHeader(size), 0, buf,

                        adjustedHeaderStartIndex, getHeaderSize(size));

                /* write footer */

                buf[count++] = FOOTER[0];

                buf[count++] = FOOTER[1];

                //send the last chunk to underlying stream

                out.write(buf, adjustedHeaderStartIndex, count - adjustedHeaderStartIndex);

            } else {

                //send an empty chunk (containing just a header) to underlying stream

                out.write(EMPTY_CHUNK_HEADER, 0, EMPTY_CHUNK_HEADER_SIZE);

            }

            out.flush();

            reset();

         }

    }

    @Override

    public boolean checkError() {

        return out.checkError();

    }

    /* Check that the output stream is still open */

    private void ensureOpen() {

        if (out == null)

            setError();

    }

   /*

    * Writes data from b[] to an internal buffer and stores the data as data

    * chunks of a following format: {Data length in Hex}{CRLF}{data}{CRLF}

    * The size of the data is preferredChunkSize. As soon as a completed chunk

    * is read from b[] a process of reading from b[] suspends, the chunk gets

    * flushed to the underlying stream and then the reading process from b[]

    * continues. When there is no more sufficient data in b[] to build up a

    * chunk of preferredChunkSize size the data get stored as an incomplete

    * chunk of a following format: {space for data length}{CRLF}{data}

    * The size of the data is of course smaller than preferredChunkSize.

    */

    @Override

            }

    }

    @Override

    }

    }

    public int size() {

        return size;

    }

    @Override

            flush(true);

        }

    }

    @Override

        }

    }

}