package org.postgresql.largeobject;

import java.io.InputStream;
import java.io.IOException;
import java.sql.SQLException;

/*
 * This is an initial implementation of an InputStream from a large object.
 * For now, the bare minimum is implemented. Later (after 7.1) we will overide
 * the other read methods to optimise them.
 */
public class BlobInputStream extends InputStream
{
	/*
	 * The parent LargeObject
	 */
	private LargeObject lo;

	/*
	 * Buffer used to improve performance
	 */
	private byte[] buffer;

	/*
	 * Position within buffer
	 */
	private int bpos;

	/*
	 * The buffer size
	 */
	private int bsize;

	/*
	 * The mark position
	 */
	private int mpos = 0;

	/*
	 * @param lo LargeObject to read from
	 */
	public BlobInputStream(LargeObject lo)
	{
		this(lo, 1024);
	}

	/*
	 * @param lo LargeObject to read from
	 * @param bsize buffer size
	 */
	public BlobInputStream(LargeObject lo, int bsize)
	{
		this.lo = lo;
		buffer = null;
		bpos = 0;
		this.bsize = bsize;
	}

	/*
	 * The minimum required to implement input stream
	 */
	public int read() throws java.io.IOException
	{
		try
		{
			if (buffer == null || bpos >= buffer.length)
			{
				buffer = lo.read(bsize);
				bpos = 0;
			}

			// Handle EOF
			if (bpos >= buffer.length)
			{
				return -1;
			}

			int ret = (buffer[bpos] & 0x7F);
			if ((buffer[bpos] &0x80) == 0x80)
			{
				ret |= 0x80;
			}

			bpos++;

			return ret;
		}
		catch (SQLException se)
		{
			throw new IOException(se.toString());
		}
	}


	/*
	 * Closes this input stream and releases any system resources associated
	 * with the stream.
	 *
	 * <p> The <code>close</code> method of <code>InputStream</code> does
	 * nothing.
	 *
	 * @exception  IOException	if an I/O error occurs.
	 */
	public void close() throws IOException
	{
		try
		{
			lo.close();
			lo = null;
		}
		catch (SQLException se)
		{
			throw new IOException(se.toString());
		}
	}

	/*
	 * Marks the current position in this input stream. A subsequent call to
	 * the <code>reset</code> method repositions this stream at the last marked
	 * position so that subsequent reads re-read the same bytes.
	 *
	 * <p> The <code>readlimit</code> arguments tells this input stream to
	 * allow that many bytes to be read before the mark position gets
	 * invalidated.
	 *
	 * <p> The general contract of <code>mark</code> is that, if the method
	 * <code>markSupported</code> returns <code>true</code>, the stream somehow
	 * remembers all the bytes read after the call to <code>mark</code> and
	 * stands ready to supply those same bytes again if and whenever the method
	 * <code>reset</code> is called.  However, the stream is not required to
	 * remember any data at all if more than <code>readlimit</code> bytes are
	 * read from the stream before <code>reset</code> is called.
	 *
	 * <p> The <code>mark</code> method of <code>InputStream</code> does
	 * nothing.
	 *
	 * @param	readlimit	the maximum limit of bytes that can be read before
	 *						the mark position becomes invalid.
	 * @see		java.io.InputStream#reset()
	 */
	public synchronized void mark(int readlimit)
	{
		try
		{
			mpos = lo.tell();
		}
		catch (SQLException se)
		{
			//throw new IOException(se.toString());
		}
	}

	/*
	 * Repositions this stream to the position at the time the
	 * <code>mark</code> method was last called on this input stream.
	 * NB: If mark is not called we move to the begining.
	 * @see		java.io.InputStream#mark(int)
	 * @see		java.io.IOException
	 */
	public synchronized void reset()
	throws IOException
	{
		try
		{
			lo.seek(mpos);
		}
		catch (SQLException se)
		{
			throw new IOException(se.toString());
		}
	}

	/*
	 * Tests if this input stream supports the <code>mark</code> and
	 * <code>reset</code> methods. The <code>markSupported</code> method of
	 * <code>InputStream</code> returns <code>false</code>.
	 *
	 * @return	<code>true</code> if this true type supports the mark and reset
	 *			method; <code>false</code> otherwise.
	 * @see		java.io.InputStream#mark(int)
	 * @see		java.io.InputStream#reset()
	 */
	public boolean markSupported()
	{
		return true;
	}
}