/*
 *  Copyright 2013 Chris Pheby
 *
 *  Licensed 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.
 */
package org.jadira.lang.io.buffered;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Provides the basic structure for implementing BufferedInputStreams. Subclasses typically differ in terms of how they provide the buffer.
 * Some of the functionality needs to be effectively reproduced from BufferedInputStream - such methods reference the equivalents in that class.
 */
public abstract class AbstractBufferedInputStream extends FilterInputStream {

    /** The default buffer size in bytes */
    public static int DEFAULT_BUFFER_SIZE = 8192;

    private int count;
    private int pos;

    private int markpos = -1;
    private int marklimit;

    private boolean isRestartable = true;

    protected abstract void assertBufferOpen() throws IOException;

    /**
     * Create a new instance with the default buffer size
     * @param in InputStream to be wrapped
     * @see java.io.BufferedInputStream#BufferedInputStream(InputStream)
     */
    public AbstractBufferedInputStream(InputStream in) {
        this(in, DEFAULT_BUFFER_SIZE);
    }

    /**
     * Creates a new instance with the given buffer size in bytes.
     * @param in InputStream to be wrapped
     * @param size The size of the buffer in bytes
     * @see java.io.BufferedInputStream#BufferedInputStream(InputStream, int)
     */
    public AbstractBufferedInputStream(InputStream in, int size) {
        super(in);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size may not be less than or equal to zero");
        }
    }

    private void fill() throws IOException {

        if (markpos < 0) {

            // No mark exists, so throw away the buffer
            pos = 0;

        } else if (pos >= limit()) {

            // Buffer exhausted
            if (markpos > 0 && !isRestartable) {

                // Throw away unnecessary early bit of buffer
                int sz = pos - markpos;
                compact(markpos, sz);
                pos = sz;
                markpos = 0;

            } else if (limit() >= marklimit) {

                // Buffer became too big so invalidate the mark and drop the buffer contents
                markpos = -1;
                pos = 0;

            } else {
                
                // Grow buffer
                int newSize = pos * 2;

                if (newSize > marklimit) {
                    newSize = marklimit;
                }

                resizeBuffer(pos, newSize);
            }
        }

        count = pos;

        int n = getInputStreamIfOpen().read(toArray(), pos, limit() - pos);

        if (n > 0) {
            count = n + pos;
        }
    }

    private InputStream getInputStreamIfOpen() throws IOException {

        InputStream input = in;

        if (input == null) {
            throw new IOException("Stream closed");
        }

        return input;
    }

    /**
     * @see java.io.BufferedInputStream#read()
     */
    public int read() throws IOException {

        if (pos >= count) {

            fill();
            if (pos >= count) {
                return -1;
            }

        }

        return getInt(pos++) & 0xff;
    }

    private int read1(byte[] b, int offset, int length) throws IOException {

        int avail = count - pos;

        if (avail <= 0) {

            if (length >= limit() && markpos < 0) {
                return getInputStreamIfOpen().read(b, offset, length);
            }

            fill();

            avail = count - pos;

            if (avail <= 0) {
                return -1;
            }

        }

        int countSize = (avail < length) ? avail : length;

        if (offset == 0) {

            get(b, pos, countSize);

        } else {

            byte[] bc = new byte[countSize];
            get(bc, pos, countSize);
            System.arraycopy(bc, 0, b, offset, countSize);

        }

        pos += countSize;
        return countSize;
    }

    /**
     * @see java.io.BufferedInputStream#read(byte[], int, int)
     */
    public int read(byte b[], int off, int len) throws IOException {

        assertBufferOpen(); // Cause exception if closed

        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int n = 0;

        while (true) {

            int numberRead = read1(b, off + n, len - n);

            if (numberRead <= 0) {
                return (n == 0) ? numberRead : n;
            }

            n += numberRead;

            if (n >= len) {
                return n;
            }

            // In case of no bytes available, but not closed, return
            InputStream input = in;
            if (input != null && input.available() <= 0) {
                return n;
            }
        }
    }

    /**
     * @see java.io.BufferedInputStream#skip(long)
     */
    public long skip(long n) throws IOException {

        assertBufferOpen(); // Cause exception if closed
        if (n <= 0) {
            return 0;
        }

        long available = count - pos;

        if (available <= 0) {

            if (markpos < 0) {
                return getInputStreamIfOpen().skip(n);
            }

            fill();
            available = count - pos;
            if (available <= 0) {
                return 0;
            }
        }

        long skipped = (available < n) ? available : n;
        pos += skipped;

        return skipped;
    }

    /**
     * @see java.io.BufferedInputStream#available()
     */
    public int available() throws IOException {

        int n = count - pos;
        int avail = getInputStreamIfOpen().available();

        return n > (Integer.MAX_VALUE - avail) ? Integer.MAX_VALUE : n + avail;
    }

    /**
     * @see java.io.BufferedInputStream#mark(int)
     */
    public void mark(int readlimit) {
        marklimit = readlimit;
        markpos = pos;
    }

    /**
     * @see java.io.BufferedInputStream#reset()
     */
    public void reset() throws IOException {

        assertBufferOpen(); // Cause exception if closed

        if (markpos < 0) {
            throw new IOException("Resetting to invalid mark");
        }

        pos = markpos;
    }

    /**
     * @see java.io.BufferedInputStream#markSupported()
     */
    public boolean markSupported() {
        return true;
    }

    /**
     * @see java.io.BufferedInputStream#close()
     */
    public void close() throws IOException {

        try {
            if (in != null) {
                in.close();
            }
        } finally {
            clean();
        }
    }

    /**
     * Indicates whether the stream can be restarted
     * @return true if the stream can be restarted
     */
    public boolean isRestartable() {
        return isRestartable;
    }

    /**
     * Return the stream back to its start position
     * @throws IOException Indicates a problem occurred (e.g. the stream was closed)
     */
    public synchronized void restart() throws IOException {

        if (!isRestartable()) {
            throw new IllegalStateException("Cannot restart as current buffer is not restartable");
        }
        assertBufferOpen(); // Cause exception if closed
        pos = 0;
    }

    /**
     * Compact the buffer reducing it to the given size, offset from the given mark position
     * @param markpos The mark position to use as the start of the buffer
     * @param size Required buffer size
     */
    protected abstract void compact(int markpos, int size);

    /**
     * Return the bytes in the buffer as a byte array
     * @return The bytes
     */
    protected abstract byte[] toArray();

    /**
     * Enlarge the buffer to the new size, retaining the position
     * @param position The position
     * @param newSize The new size
     * @throws IOException Indicates a problem resizing
     */
    protected abstract void resizeBuffer(int position, int newSize) throws IOException;

    /**
     * Returns the buffer's limit
     * @return The limit
     */
    protected abstract int limit();

    /**
     * Reads four bytes (an int) from the given offset
     * @param position The offset
     * @return An int
     * @throws IOException Indicates a problem reading the int
     */
    protected abstract int getInt(int position) throws IOException;

    /**
     * Retrieve the given number of bytes from the stream
     * @param b The array into which bytes will be written
     * @param pos The offset within the array of the first byte to be written
     * @param cnt The maximum number of bytes to be written to the given array
     */
    protected abstract void get(byte[] b, int pos, int cnt);

    /**
     * Performs any necessary cleaning of the buffer and releasing of resources.
     */
    protected abstract void clean();

    protected int getMarkLimit() {
        return marklimit;
    }
}