/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.utils.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;

/**
 * @author Thomas Down
 */
    public class CountedBufferedReader extends BufferedReader {
	private final static int DEFAULT_BUFFER_SIZE = 1 << 14;

	private long position;

	private Reader stream;
	private char[] buffer;
	private int buffPos;
	private int buffFill;

	private boolean reachedEOF = false;

	private int mark = -1;
	private int markLimit = -1;

	public long getFilePointer() {
	    return position;
	}

	public CountedBufferedReader(Reader stream) {
	    super(new Reader() {
		public void close() {}
		public int read(char[] cbuf, int off, int len) { return 0; }
	    });

	    this.stream = stream;
	    this.buffer = new char[DEFAULT_BUFFER_SIZE];
	    position = 0;
	    buffPos = 0;
	    buffFill = 0;
	}

	public void close()
	    throws IOException
	{
	    stream.close();
	    stream = null;
	}

	public int read() 
	    throws IOException
	{
	    if (buffPos >= buffFill)
		fillBuffer();

	    if (reachedEOF) {
		return -1;
	    } else {
		position++;
		return buffer[buffPos++];
	    }
	}

	private int peek()
	    throws IOException
	{
	    if (buffPos >= buffFill)
		fillBuffer();

	    if (reachedEOF) {
		return -1;
	    } else {
		return buffer[buffPos];
	    }
	}

	public int read(char[] cbuf)
	    throws IOException
	{
	    return read(cbuf, 0, cbuf.length);
	}

	public int read(char[] cbuf, int off, int len) 
	    throws IOException
	{
	    if (buffPos >= buffFill)
		fillBuffer();

	    if (reachedEOF) {
		return -1;
	    } else {
		int toReturn = Math.min(len, buffFill - buffPos);
		System.arraycopy(buffer, buffPos, cbuf, off, toReturn);
		buffPos += toReturn;
		position += toReturn;

		return toReturn;
	    }
	}

	public boolean ready() 
	    throws IOException
	{
	    if (buffPos < buffFill)
		return true;
	    return stream.ready();
	}

	public long skip(long n)
	    throws IOException
	{
	    int skipInBuffer;
	    if (n < buffer.length) {
		skipInBuffer = Math.min((int) n, buffFill - buffPos);
	    } else {
		skipInBuffer = buffFill - buffPos;
	    }
	    position += skipInBuffer;
	    buffPos += skipInBuffer;

	    if (n > skipInBuffer) {
		long skippedInStream;

		if (mark >= 0) {
		    // Yuck, fix this...
		    char[] dummy = new char[(int) (n - skipInBuffer)];
		    skippedInStream = read(dummy); 
		} else {
		    skippedInStream = stream.skip(n - skipInBuffer);
		}

		position += skippedInStream;
		return skippedInStream + skipInBuffer;
	    } else {
		return skipInBuffer;
	    }
	}

	public boolean markSupported() {
	    return true;
	}

	public void mark(int limit)
	    throws IOException
	{
	    //	    System.err.println("*** Mark");

	    if (limit + 1> buffer.length) {
		char[] newBuffer = new char[limit + 1];
		System.arraycopy(buffer, buffPos, newBuffer, 0, buffFill - buffPos);
		buffer = newBuffer;
		buffFill = buffFill - buffPos;
		buffPos = 0;
	    } else if (buffPos + limit > buffer.length) {
		System.arraycopy(buffer, buffPos, buffer, 0, buffFill - buffPos);
		buffFill = buffFill - buffPos;
		buffPos = 0;
	    }

	    mark = buffPos;
	    markLimit = limit;
	}

	public void reset()
	    throws IOException
	{
	    //	    System.err.println("*** Reset");

	    if (mark < 0)
		throw new IOException("The mark is not currently in scope");

	    position = position - buffPos + mark;
	    buffPos = mark;
	}

	public String readLine()
	    throws IOException 
	{
	    String line = null;
	    
      while(!reachedEOF) {
        for(int i = buffPos; i < buffFill; i++) {
          char c = buffer[i];
          if(c == '\n' || c == '\r') {
            int len = i - buffPos;
            String bit = new String(buffer, buffPos, len);
            position += len;
            if(line == null) {
              line = bit;
            } else {
              line += bit;
            }
            buffPos = i;
            read();
            char d = (char) peek();
            if(c == '\r' && d == '\n') {
              read();
            }
            
            return line;
          }
        }
        int len = buffFill - buffPos;
        String bit = new String(buffer, buffPos, len);
        position += len;
        buffPos = buffFill;
        if(line == null) {
          line = bit;
        } else {
          line += bit;
        }
        fillBuffer();
      }
      
      return line;
	}

	private void fillBuffer()
	    throws IOException
	{
	    // System.err.println("*** Fill buffer");

	    if (mark < 0) {
		buffFill = stream.read(buffer);
		if (buffFill == -1) {
		    buffFill = 0;
		    reachedEOF = true;
		} 
		// System.out.println("Filled buffer: " + buffFill);
		
		buffPos = 0;
	    } else {
		if (buffPos >= (markLimit + mark)) {
		    // Mark's gone out of scope -- wheee!
		    mark = -1;
		    markLimit = -1;
		    fillBuffer();
		    return;
		}

		System.arraycopy(buffer, mark, buffer, 0, buffFill - mark);
		buffFill = buffFill - mark;
		mark = 0;
		buffPos = buffFill;
		int newChars = stream.read(buffer, buffFill, buffer.length - buffFill);
		if (newChars == -1) {
		    reachedEOF = true;
		} else {
		    buffFill = buffFill + newChars;
		}
	    }
	}
    }