/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_IO_DATAINPUTSTREAM_H_
#define _DECAF_IO_DATAINPUTSTREAM_H_

#include <decaf/io/FilterInputStream.h>
#include <decaf/io/IOException.h>
#include <decaf/io/EOFException.h>
#include <decaf/lang/exceptions/NullPointerException.h>
#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>

namespace decaf{
namespace io{

    /**
     * A data input stream lets an application read primitive Java data
     * types from an underlying input stream in a machine-independent way.
     * An application uses a data output stream to write data that can
     * later be read by a data input stream.
     *
     * Due to the lack of garbage collection in C++ a design decision was
     * made to add a boolean parameter to the constructor indicating if the
     * wrapped <code>InputStream</code> is owned by this object.  That way
     * creation of the underlying stream can occur in a Java like way. Ex:
     *
     *  DataInputStream os = new DataInputStream( new InputStream(), true )
     */
    class DECAF_API DataInputStream : public FilterInputStream
    {
    public:

        /**
         * Creates a DataInputStream that uses the specified underlying
         * InputStream.
         * @param inputStream the InputStream instance to wrap.
         * @param own, indicates if this class owns the wrapped string
         * defaults to false.
         */
        DataInputStream( InputStream* inputStream, bool own = false );

        virtual ~DataInputStream();

        /**
         * Reads some number of bytes from the contained input stream and
         * stores them into the buffer array b. The number of bytes actually
         * read is returned as an integer. This method blocks until input
         * data is available, end of file is detected, or an exception is
         * thrown.
         * <p>
         * If the length of buffer is zero, then no bytes are read and 0 is
         * returned; otherwise, there is an attempt to read at least one
         * byte. If no byte is available because the stream is at end of
         * file, the value -1 is returned; otherwise, at least one byte is
         * read and stored into buffer.
         * <p>
         * The first byte read is stored into element buffer[0], the next one
         * into buffer[1], and so on. The number of bytes read is, at most,
         * equal to the length of buffer. Let k be the number of bytes actually
         * read; these bytes will be stored in elements b[0] through b[k-1],
         * leaving elements buffer[k] through buffer[buffer.length-1]
         * unaffected.
         * <p>
         * If the first byte cannot be read for any reason other than end
         * of file, then an IOException is thrown. In particular, an
         * IOException is thrown if the input stream has been closed.
         * <p>
         * The read( buffer ) method has the same effect as:
         *      read( buffer, 0, b.length )
         * @param buffer - byte array to insert read data into
         * @returns the total number of bytes read, or -1 if there is no
         *          more data because the stream is EOF.
         * @throws IOException
         */
        virtual int read( std::vector< unsigned char >& buffer )
            throw ( io::IOException );

        /**
         * Reads up to len bytes of data from the contained input stream
         * into an array of bytes. An attempt is made to read as many as
         * len bytes, but a smaller number may be read, possibly zero. The
         * number of bytes actually read is returned as an integer.
         * <p>
         * This method blocks until input data is available, end of file is
         * detected, or an exception is thrown.
         * <p>
         * If buffer is null, a NullPointerException is thrown.
         * <p>
         * If off is negative, or len is negative then an
         * IndexOutOfBoundsException is thrown, if off + len is greater that
         * the allocated length of the array, an IOException will result
         * depending on the platform and compiler settings.
         * <p>
         * If len is zero, then no bytes are read and 0 is returned;
         * otherwise, there is an attempt to read at least one byte. If no
         * byte is available because the stream is at end of file, the
         * value -1 is returned; otherwise, at least one byte is read and
         * stored into buffer.
         * <p>
         * The first byte read is stored into element b[off], the next one
         * into buffer[off+1], and so on. The number of bytes read is, at most,
         * equal to len. Let k be the number of bytes actually read; these
         * bytes will be stored in elements buffer[off] through buffer[off+k-1],
         * leaving elements buffer[off+k] through buffer[off+len-1] unaffected.
         * <p>
         * In every case, elements buffer[0] through buffer[off] and elements
         * buffer[off+len] through buffer[buffer.length-1] are unaffected.
         * <p>
         * If the first byte cannot be read for any reason other than end of
         * file, then an IOException is thrown. In particular, an IOException
         * is thrown if the input stream has been closed.
         * @param buffer - byte array to insert read data into
         * @param offset - location in buffer to start writing
         * @param length - number of bytes to read
         * @returns the total number of bytes read, or -1 if there is no
         *          more data because the stream is EOF.
         * @throws IOException
         */
        virtual int read( unsigned char* buffer,
                          std::size_t offset,
                          std::size_t length )
            throw ( io::IOException,
                    lang::exceptions::IndexOutOfBoundsException,
                    lang::exceptions::NullPointerException );

        /**
         * Reads one input byte and returns true if that byte is nonzero,
         * false if that byte is zero.
         * @returns the boolean value read.
         * @throws IOException
         * @throws EOFException
         */
        virtual bool readBoolean()
            throw( io::IOException, io::EOFException );

        /**
         * Reads and returns one input byte. The byte is treated as a
         * signed value in the range -128 through 127, inclusive.
         * @returns the 8-bit value read.
         * @throws IOException
         * @throws EOFException
         */
        virtual char readByte()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads one input byte, zero-extends it to type int, and returns
         * the result, which is therefore in the range 0  through 255.
         * @returns the 8 bit unsigned value read
         * @throws IOException
         * @throws EOFException
         */
        virtual unsigned char readUnsignedByte()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads an input char and returns the char value. A ascii char
         * is made up of one bytes.  This returns the same result as
         * <code>readByte</code>
         * @returns the 8 bit char read
         * @throws IOException
         * @throws EOFException
         */
        virtual char readChar() throw ( io::IOException, io::EOFException );

        /**
         * Reads eight input bytes and returns a double value. It does this
         * by first constructing a long long  value in exactly the manner of
         * the readlong  method, then converting this long  value to a double
         * in exactly the manner of the method Double.longBitsToDouble.
         * @returns the double value read
         * @throws IOException
         * @throws EOFException
         */
        virtual double readDouble()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads four input bytes and returns a float value. It does this
         * by first constructing an int  value in exactly the manner of the
         * readInt  method, then converting this int  value to a float in
         * exactly the manner of the method Float.intBitsToFloat.
         * @returns the float value read
         * @throws IOException
         * @throws EOFException
         */
        virtual float readFloat() throw ( io::IOException, io::EOFException );

        /**
         * Reads four input bytes and returns an int value. Let a  be the
         * first byte read, b be the second byte, c be the third byte, and
         * d be the fourth byte. The value returned is: <p>
         *  (((a & 0xff) << 24) | ((b & 0xff) << 16) |
         *   ((c & 0xff) << 8) | (d & 0xff))
         * @returns the int value read
         * @throws IOException
         * @throws EOFException
         */
        virtual int readInt() throw ( io::IOException, io::EOFException );

        /**
         * Reads eight input bytes and returns a long value. Let a  be the
         * first byte read, b be the second byte, c be the third byte, d
         * be the fourth byte, e be the fifth byte, f  be the sixth byte,
         * g be the seventh byte, and h be the eighth byte. The value
         * returned is:
         *  (((long)(a & 0xff) << 56) |
         *   ((long)(b & 0xff) << 48) |
         *   ((long)(c & 0xff) << 40) |
         *   ((long)(d & 0xff) << 32) |
         *   ((long)(e & 0xff) << 24) |
         *   ((long)(f & 0xff) << 16) |
         *   ((long)(g & 0xff) <<  8) |
         *   ((long)(h & 0xff)))
         * @returns the 64 bit long long read
         * @throws IOException
         * @throws EOFException
         */
        virtual long long readLong()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads two input bytes and returns a short value. Let a  be the
         * first byte read and b  be the second byte. The value returned is:
         *   (short)((a << 8) | (b & 0xff))
         * @returns the 16 bit short value read
         * @throws IOException
         * @throws EOFException
         */
        virtual short readShort() throw ( io::IOException, io::EOFException );

        /**
         * Reads two input bytes and returns an int value in the range 0
         * through 65535. Let a  be the first byte read and b  be the
         * second byte. The value returned is:
         *   (((a & 0xff) << 8) | (b & 0xff))
         * @returns the 16 bit unsigned short read
         * @throws IOException
         * @throws EOFException
         */
        virtual unsigned short readUnsignedShort()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads an null terminated ASCII string to the stream and returns the
         * string to the caller.
         * @returns string object containing the string read.
         * @throws IOException
         * @throws EOFException
         */
        virtual std::string readString()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads a UTF8 encoded string in ASCII format and returns it, this is
         * only useful if you know for sure that the string that is to be read
         * was a string that contained all ascii values, and not uncide chars.
         * @returns string read from stream.
         * @throws IOException
         * @throws EOFException
         */
        virtual std::string readUTF()
            throw ( io::IOException, io::EOFException );

        /**
         * Reads some bytes from an input stream and stores them into the
         * buffer array buffer. The number of bytes read is equal to the length
         * of buffer.<p>
         * This method blocks until one of the following conditions occurs:
         *    * buffer.size() bytes of input data are available, in which case
         *      a normal return is made.
         *    * End of file is detected, in which case an EOFException is
         *      thrown.
         *    * An I/O error occurs, in which case an IOException other than
         *      EOFException is thrown.
         * <p>
         * If buffer.size() is zero, then no bytes are read. Otherwise, the
         * first byte read is stored into element b[0], the next one into
         * buffer[1], and so on. If an exception is thrown from this method,
         * then it may be that some but not all bytes of buffer have been
         * updated with data from the input stream.
         * @param buffer - vector of char that is read to its size()
         * @throws IOException
         * @throws EOFException
         */
        virtual void readFully( std::vector< unsigned char >& buffer )
            throw ( io::IOException, io::EOFException );

        /**
         * Reads length bytes from an input stream.
         * <p>
         * This method blocks until one of the following conditions occurs:
         *    * length bytes of input data are available, in which case a
         *      normal return is made.
         *    * End of file is detected, in which case an EOFException is
         *      thrown.
         *    * An I/O error occurs, in which case an IOException other
         *      than EOFException is thrown.
         * <p>
         * If buffer is null, a NullPointerException is thrown. If offset is
         * negative, or len is negative, or offset+length is greater than the
         * length of the array buffer, then an IndexOutOfBoundsException is
         * thrown. If len is zero, then no bytes are read. Otherwise, the
         * first byte read is stored into element buffer[off], the next one into
         * buffer[offset+1], and so on. The number of bytes read is, at most,
         * equal to len.
         * @param buffer - byte array to insert read data into
         * @param offset - location in buffer to start writing
         * @param length - number of bytes to read
         * @throws IOException
         * @throws EOFException
         */
        virtual void readFully( unsigned char* buffer,
                                std::size_t offset,
                                std::size_t length )
            throw ( io::IOException,
                    io::EOFException,
                    lang::exceptions::IndexOutOfBoundsException,
                    lang::exceptions::NullPointerException );

        /**
         * Makes an attempt to skip over n bytes of data from the input
         * stream, discarding the skipped bytes. However, it may skip over
         * some smaller number of bytes, possibly zero. This may result from
         * any of a number of conditions; reaching end of file before n
         * bytes have been skipped is only one possibility. This method
         * never throws an EOFException. The actual number of bytes skipped
         * is returned.
         * @param num - number of bytes to skip
         * @return the total number of bytes skipped
         */
        virtual std::size_t skip( std::size_t num )
            throw( io::IOException,
                   lang::exceptions::UnsupportedOperationException );

    private:

        // Used internally to reliable get data from the underlying stream
        inline void readAllData( unsigned char* buffer,
                                 std::size_t length )
            throw ( io::IOException,
                    io::EOFException ) {

            std::size_t n = 0;
            do{
                int count = inputStream->read( &buffer[n], length - n );
                if( count == -1 ) {
                    throw EOFException(
                        __FILE__, __LINE__,
                        "DataInputStream::readLong - Reached EOF" );
                }
                n += count;
            } while( n < length );
        }

    };

}}

#endif /*_DECAF_IO_DATAINPUTSTREAM_H_*/