// BSD License (http://www.galagosearch.org/license)

 package org.galagosearch.tupleflow;

 import java.io.EOFException;

 import java.io.IOException;

 import java.io.RandomAccessFile;

 /**

  *

  * @author trevor

  */

 public class BufferedFileDataStream implements DataStream {

     RandomAccessFile stream;

     long stopPosition;

     long startPosition;

     final static int cacheLength = 32768;

     long bufferStart;

     int bufferPosition;

     byte[] cacheBuffer;

     /** Creates a new instance of BufferedFileDataStream */

     public BufferedFileDataStream(RandomAccessFile stream, long stopPosition) throws IOException {

         this(stream, stream.getFilePointer(), stopPosition);

     }

     public BufferedFileDataStream(RandomAccessFile stream, long start, long end) {

         assert start <= end;

         this.stream = stream;

         this.stopPosition = end;

         this.cacheBuffer = new byte[0];

         this.bufferPosition = 0;

         this.bufferStart = start;

         this.startPosition = start;

     }

     public BufferedFileDataStream subStream(long start, long length) {

         assert start < length();

         assert start + length <= length();

         return new BufferedFileDataStream(

                 stream, bufferStart + start,

                 bufferStart + start + length);

     }

     public boolean isDone() {

         return stopPosition <= bufferStart + bufferPosition;

     }

     public long length() {

         return stopPosition - startPosition;

     }

     public long getPosition() {

         return getAbsolutePosition() - startPosition;

     }

     public long getAbsolutePosition() {

         return bufferStart + bufferPosition;

     }

     /**

      * Seeks forward into the stream to a particular byte offset (reverse

      * seeks are not allowed).  The offset is relative to the start position of

      * this data stream, not the beginning of the file.

      */

     public void seek(long offset) {

         seekAbsolute(offset + startPosition);

     }

     /**

      * Seeks forward into the stream to a particular byte offset (reverse

      * seeks are not allowed).  The offset is relative to the start of the file.

      */

     public void seekAbsolute(long offset) {

         assert bufferStart + bufferPosition <= offset;

         // is any of this data cached?

         if (offset - bufferStart < cacheBuffer.length) {

             // this cast is safe because we know it's smaller than cacheBuffer.length

             bufferPosition = (int) (offset - bufferStart);

         } else {

             // this sets the stream position to the appropriate point,

             // and effectively invalidates the current cache contents.

             bufferStart = offset - cacheBuffer.length;

             bufferPosition = cacheBuffer.length;

         }

     }

     public void readFully(byte[] buffer, int start, int length) throws IOException {

         cache(length);

         System.arraycopy(cacheBuffer, bufferPosition, buffer, start, length);

         update(length);

     }

     public void readFully(byte[] buffer) throws IOException {

         cache(buffer.length);

         System.arraycopy(cacheBuffer, bufferPosition, buffer, 0, buffer.length);

         update(buffer.length);

     }

     public int skipBytes(int n) throws IOException {

         update(n);

         return n;

     }

     public int readUnsignedShort() throws IOException {

         cache(2);

         byte a = cacheByte(0);

         byte b = cacheByte(1);

         int result = (((a << 8) | (b & 0xff)) & 0xffff);

         update(2);

         return result;

     }

     public boolean readBoolean() throws IOException {

         cache(1);

         boolean result = (cacheByte(0) != 0) ? true : false;

         update(1);

         return result;

     }

     public byte readByte() throws IOException {

         cache(1);

         byte result = cacheByte(0);

         update(1);

         return result;

     }

     public char readChar() throws IOException {

         return (char) readShort();

     }

     public short readShort() throws IOException {

         cache(2);

         byte a = cacheByte(0);

         byte b = cacheByte(1);

         short result = (short) ((a << 8) | (b & 0xff));

         update(2);

         return result;

     }

     public double readDouble() throws IOException {

         long result = readLong();

         return Double.longBitsToDouble(result);

     }

     public float readFloat() throws IOException {

         int result = readInt();

         return Float.intBitsToFloat(result);

     }

     public int readInt() throws IOException {

         cache(4);

         int a = cacheByte(0);

         int b = cacheByte(1);

         int c = cacheByte(2);

         int d = cacheByte(3);

         int result = ((a & 0xff) << 24) |

                 ((b & 0xff) << 16) |

                 ((c & 0xff) << 8) |

                 (d & 0xff);

         update(4);

         return result;

     }

     public String readLine() throws IOException {

         throw new IOException("readLine is unimplemented and deprecated");

     }

     public long readLong() throws IOException {

         long a = readInt();

         long b = readInt();

         // shift a to high word

         a <<= 32;

         // mask b

         b &= (0xFFFFFFFFL);

         return a | b;

     }

     public String readUTF() throws IOException {

         throw new IOException("readUTF is unimplemented");

     }

     // inlining here for performance

     public int readUnsignedByte() throws IOException {

         if (cacheBuffer.length - bufferPosition >= 1) {

             int result = 0xff & (int) cacheBuffer[bufferPosition];

             bufferPosition += 1;

             return result;

         } else {

             cache(1);

             int b = cacheByte(0);

             update(1);

             return b & 0xff;

         }

     }

     private void cache(int length) throws IOException {

         assert length >= 0 : "Length can't be negative: " + length + " " +

                 bufferStart + bufferPosition + " " + stopPosition;

         // quick check to see if it's already buffered

         if (cacheBuffer.length - bufferPosition >= length) {

             return;        // if it's not buffered, is there enough room left in the

                            // file to cache this much data?

         }

         if (bufferStart + bufferPosition + length > stopPosition) {

             throw new EOFException("Tried to read off the end of the file.");

         }

         long current = bufferStart + bufferPosition;

         int readLength = (int) Math.min(stopPosition - current, cacheLength);

         readLength = Math.max(readLength, length);

         if (readLength != cacheBuffer.length) {

             cacheBuffer = new byte[readLength];

         }

         stream.seek(current);

         stream.readFully(cacheBuffer);

         bufferStart = current;

         bufferPosition = 0;

     }

     private void update(int length) {

         bufferPosition += length;

     }

     private byte cacheByte(int i) {

         return cacheBuffer[bufferPosition + i];

     }

 }