/*
 * 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_BYTEARRAYINPUTSTREAM_H_
#define _DECAF_IO_BYTEARRAYINPUTSTREAM_H_

#include <decaf/io/InputStream.h>
#include <decaf/util/concurrent/Mutex.h>
#include <vector>

namespace decaf{
namespace io{

    /**
     * A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from
     * the stream. An internal counter keeps track of the next byte to be supplied by the read method.
     * The ByteArrayInputStream never copies the supplied buffers, only points to them, therefore the
     * caller must ensure that the supplied buffer remain in scope, or is not deleted before this
     * ByteArrayInputStream is freed.  If the own argument of one of the constructors that accepts an
     * array pointer is set to true than the ByteArrayInputStream instance will take ownership of the
     * supplied pointer and delete it when that instance is destroyed.
     *
     * Closing a ByteArrayInputStream has no effect. The methods in this class can be called after
     * the stream has been closed without generating an IOException.
     *
     * @since 1.0
     */
    class DECAF_API ByteArrayInputStream: public InputStream {
    private:

        /**
         * An array of bytes that was provided by the creator of the stream. Elements buffer[0]
         * through buffer[count-1] are the only bytes that can ever be read from the stream; element
         * buffer[pos] is the next byte to be read.
         */
        const unsigned char* buffer;

        /**
         * The Size of the input buffer.
         */
        int size;

        /**
         * Does this object own the supplied pointer.
         */
        bool own;

        /**
         * The index one greater than the last valid character in the input stream buffer. This
         * value should always be nonnegative and not larger than the length of buffer. It is one
         * greater than the position of the last byte within buffer that can ever be read from the
         * input stream buffer.
         */
        int count;

        /**
         * The index of the next character to read from the input stream buffer. This value should
         * always be nonnegative and not larger than the value of count. The next byte to be read
         * from the input stream buffer will be buffer[pos].
         */
        int pos;

        /**
         * The currently marked position in the stream. ByteArrayInputStream objects are marked at
         * position zero by default when constructed. They may be marked at another position within
         * the buffer by the mark() method. The current buffer position is set to this point by the
         * reset() method.
         *
         * If no mark has been set, then the value of mark is the offset passed to the constructor
         * (or 0 if the offset was not supplied).
         */
        int markpos;

    private:

        ByteArrayInputStream(const ByteArrayInputStream&);
        ByteArrayInputStream& operator=(const ByteArrayInputStream&);

    public:

        /**
         * Creates an ByteArrayInputStream with an empty input buffer, the buffer can be
         * initialized with a call to setByteArray.
         */
        ByteArrayInputStream();

        /**
         * Creates the input stream and calls setBuffer with the
         * specified buffer object.
         *
         * @param buffer
         *      The buffer to be used.
         */
        ByteArrayInputStream(const std::vector<unsigned char>& buffer);

        /**
         * Create an instance of the ByteArrayInputStream with the given buffer as
         * the source of input for all read operations.
         *
         * @param buffer
         *      The initial byte array to use to read from.
         * @param bufferSize
         *      The size of the buffer.
         * @param own
         *      Indicates if this object should take ownership of the array, default is false.
         *
         * @throws NullPointerException if the buffer is Null.
         * @throws IllegalArguementException if the bufferSize is negative.
         */
        ByteArrayInputStream(const unsigned char* buffer, int bufferSize, bool own = false);

        /**
         * Create an instance of the ByteArrayInputStream with the given buffer as
         * the source of input for all read operations.
         *
         * @param buffer
         *      The initial byte array to use to read from.
         * @param bufferSize
         *      The size of the buffer.
         * @param offset
         *      The offset into the buffer to begin reading from.
         * @param length
         *      The number of bytes to read past the offset.
         * @param own
         *      Indicates if this object should take ownership of the array, default is false.
         *
         * @throws NullPointerException if the buffer is Null.
         * @throws IllegalArguementException if the bufferSize is negative.
         */
        ByteArrayInputStream(const unsigned char* buffer, int bufferSize, int offset, int length, bool own = false);

        virtual ~ByteArrayInputStream();

        /**
         * Sets the internal buffer.  The input stream will wrap around
         * this buffer and will perform all read operations on it.  The
         * position will be reinitialized to the beginning of the specified
         * buffer.  This class will not own the given buffer - it is the
         * caller's responsibility to free the memory of the given buffer
         * as appropriate.
         *
         * @param buffer
         *      The buffer to be used.
         */
        virtual void setByteArray(const std::vector<unsigned char>& buffer);

        /**
         * Sets the data that this reader uses, replaces any existing
         * data and resets to beginning of the buffer.
         *
         * @param buffer
         *      The initial byte array to use to read from.
         * @param bufferSize
         *      The size of the buffer.
         *
         * @throws NullPointerException if the buffer is Null.
         * @throws IllegalArguementException if the bufferSize is negative.
         */
        virtual void setByteArray(const unsigned char* buffer, int bufferSize);

        /**
         * Sets the data that this reader uses, replaces any existing
         * data and resets to beginning of the buffer.
         *
         * @param buffer
         *      The initial byte array to use to read from.
         * @param bufferSize
         *      The size of the buffer.
         * @param offset
         *      The offset into the buffer to begin reading from.
         * @param length
         *      The number of bytes to read past the offset.
         *
         * @throws NullPointerException if the buffer is Null.
         * @throws IllegalArguementException if the bufferSize is negative.
         */
        virtual void setByteArray(const unsigned char* buffer, int bufferSize, int offset, int length);

        /**
         * {@inheritDoc}
         */
        virtual int available() const;

        /**
         * {@inheritDoc}
         */
        virtual long long skip(long long num);

        /**
         * {@inheritDoc}
         */
        virtual void mark(int readLimit);

        /**
         * {@inheritDoc}
         */
        virtual void reset();

        /**
         * {@inheritDoc}
         */
        virtual bool markSupported() const {
            return true;
        }

    protected:

        virtual int doReadByte();

        virtual int doReadArrayBounded(unsigned char* buffer, int size, int offset, int length);

    };

}}

#endif /*_DECAF_IO_BYTEARRAYINPUTSTREAM_H_*/