/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.impl.utils;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Enumeration;

import java.util.Vector;

/**

 * A utility class for stream operations.

 */

public class StreamUtils

{

    private static final int mDefaultBufferSize = 1024;

    /**

     * Reads all bytes from given stream until EOF, and returns the bytes in

     * an array. The method will block until EOF is reached. The method uses

     * efficiently buffers in order to avoid extra copying. User can provide

     * a hint how large first buffer should be allocated to optimize buffer

     * copying. The user must note that it is only a hint - the result buffer

     * might also be smaller or bigger. If hint is <=0, then value of

     * stream.available() is used as hint.

     *

     * @param stream The stream from where to read data from.

     * @param byteCountHint A hint about the total amount of bytes in the

     *                      stream. Value <=0 means that caller has no hint to

     *                      give.

     * @return The data read from the given stream in byte array.

     * @throws IOException on I/O error cases.

     */

    public static byte[] readBytesFromStream(InputStream stream,

            int byteCountHint)

    throws IOException

    {

        // Set the first buffer size.

        int bufferSize = Math.max(byteCountHint, stream.available());

        if (bufferSize < 1)

        {

            bufferSize = mDefaultBufferSize;

        }

        // A vector for buffers.

        Vector bufferVector = new Vector();

        // Amount of total read bytes.

        int totalCount = 0;

        while (true)

        {

            // Internal buffer where to read the content.

            byte[] currentBuffer = new byte[bufferSize];

            // Read from stream.

            int len = readBytesFromStream(stream, currentBuffer);

            if (len < 1)

            {

                // There were no more data in the stream.

                break;

            }

            totalCount += len; // Increase total amount of read bytes.

            // Add the buffer to vector.

            bufferVector.addElement(new ByteBuffer(currentBuffer, len));

            if (len < currentBuffer.length)

            {

                // We have read all the data. Buffer contains less data

                // than the size of the buffer.

                break;

            }

            bufferSize = mDefaultBufferSize;

        }

        return createResultBuffer(totalCount, bufferVector);

    }

    /**

     * Fills the given buffer with bytes from given stream. The method will

     * not read to the end of stream if the buffer is filled up.

     *

     * @param stream The stream from where to read data from.

     * @param buffer A byte array where to copy the data.

     * @return The amount of data read into byte array. If return value <

     *         len(buffer), then EOF has been reached.

     * @throws IOException on I/O error cases.

     */

    public static int readBytesFromStream(InputStream stream,

                                          byte[] buffer) throws IOException

    {

        int readByteCount = 0;

        int len;

        while (readByteCount < buffer.length &&

                (len = stream.read(buffer, readByteCount,

                                   buffer.length - readByteCount)) >= 0)

        {

            // Increase the start position where to write into current buffer.

            readByteCount += len;

        }

        return readByteCount;

    }

    /**

     * Creates a result buffer from given args.

     *

     * @param totalByteCount Total count of read bytes.

     * @param firstBuffer A byte array containing first set of data.

     * @return The amount of data read into byte array.

     * @throws IOException on I/O error cases.

     */

    private static byte[] createResultBuffer(int totalByteCount,

            Vector bufferVector)

    {

        if (totalByteCount == 0)

        {

            return new byte[0];

        }

        byte[] resultBuffer = null;

        // The stream contained data.

        if (bufferVector.size() == 1)

        {

            // There is only one buffer.

            ByteBuffer firstBuffer = (ByteBuffer)bufferVector.elementAt(0);

            if (firstBuffer.isFull())

            {

                // The first buffer was full.

                resultBuffer = firstBuffer.mBuffer;

            }

        }

        if (resultBuffer == null)

        {

            // Need to combine the result from several buffers or the

            // first buffer wasn't full.

            resultBuffer = new byte[totalByteCount];

            // A destination position in the result buffer.

            int dst = 0;

            // Loop and copy all the buffers.

            Enumeration byteBufs = bufferVector.elements();

            while (byteBufs.hasMoreElements())

            {

                ByteBuffer buf = (ByteBuffer)byteBufs.nextElement();

                System.arraycopy(buf.mBuffer, 0, resultBuffer, dst, buf.mCount);

                dst +=  buf.mCount;

            }

        }

        return resultBuffer;

    }

    /**

     * A utility class for storing the byte array and how much data it

     * contains.

     */

    private static class ByteBuffer

    {

        byte[] mBuffer;

        int    mCount;

        private ByteBuffer(byte[] buffer, int count)

        {

            mBuffer = buffer;

            mCount = count;

        }

        private boolean isFull()

        {

            return mBuffer.length == mCount;

        }

    }

}