// Copyright (c) 2001 Hursh Jain (http://www.mollypages.org) 
// The Molly framework is freely distributable under the terms of an
// MIT-style license. For details, see the molly pages web site at:
// http://www.mollypages.org/. Use, modify, have fun !

package fc.util.pagetemplate;

import java.io.*;
import java.util.*;

import fc.io.*;
import fc.util.*;

/**
A Reader suitable for lexing. Supports all of: <code>peek</code>,
<code>read</code> and <code>unread</code>. (no JDK 1.5 reader class has
all of those). Mark/reset is not supported because it's too complex to
implement given the current <i>fixed-buffer</i> implementation of this
class. (on the flip-side this implementation does allow to read
<i>very</i> large files without risk of running out of JDK memory).
<p>
Note 1: If this class is invoked from the command line, setting the dbg
flag in the code to <code>true</code> is useful.

@author hursh jain
*/
public final class TemplateReader extends Reader
{
static final boolean dbg = false;

//our own buf/pos because most/all reader subclasses dont have mark/reset/unread  
char[]      buf       = null;
int       pos       = 0;
int       count       = 0;
int       markpos     = 0;
//line, col and other tracking 
int       line      = 1;
int       col       = 0;
int       lastcol     = 1;  //for unread past a newline
boolean     pushBackNL    = false;
boolean     lastWasCR   = false;
String      encoding;
static String DEFAULT_ENCODING = TemplatePage.DEFAULT_ENCODING;

/** 
Creates a new TemplateReader wrapping the specified reader
*/
public TemplateReader(Reader r) throws IOException
  {
  Argcheck.notnull(r, "specified reader was null");
  buf = IOUtil.readerToCharArray(r);
  this.encoding = DEFAULT_ENCODING;
  }

/**
Creates a reader with the specified non-null encoding.
*/
public TemplateReader(File file, String encoding)  throws IOException
  {
  Argcheck.notnull(file, "specified file was null");
  Argcheck.notnull(encoding, "specified encoding was null");
  this.encoding = encoding;
  buf = IOUtil.fileToCharArray(file, encoding);
  }

/**
Creates a reader using the UTF-8 encoding.
*/
public TemplateReader(File file)  throws IOException
  {
  this(file, DEFAULT_ENCODING);
  }

public void close() throws IOException
  {
  //no underlying stream since everything read into buffer. not much to do.
  }
  
public int read() throws IOException
  {
  if (pos == buf.length) {
    return -1;
    }
    
  char c = buf[pos++];  
  
  if (dbg) System.out.println(">>>>>>>> DEBUG: read() from BUF, c=" + StringUtil.viewableAscii(c));
  adjustReadLineNum(c);

  return c;
  }

public int read(char[] buf, int start, int len) throws IOException
  {
  throw new IOException("not implemented, use the read() method instead");
  }

/**
Unreads the current character (which could be EOF) so that the next read will 
return the current character (or EOF) again.
*/
public void unread() throws IOException
  {
  char c = 0;
  
  if (pos == 0) 
    {
    throw new IOException("I am at the beginning of the stream. Cannot unread anything because nothing has been read so far");
    }
  else{ 
    c = buf[--pos];
    if (dbg) System.out.println(">>>>>>>> DEBUG: unread() from BUF, c=" + StringUtil.viewableAscii(c));
    }
  
  adjustUnreadLineNum(c);
  }

/**
Unreads the specified number of characters
*/
public void unread(int count)  throws IOException
  {
  for (int n = 0; n < count; n++) {
    unread();
    }
  }

/**
Useful for inserting included files into the stream and then parsing that content in-line
with the rest of the file.
*/
public void insertIntoStream(File file) throws IOException
  {
  char[] insert = IOUtil.fileToCharArray(file, encoding);

  char[] result = new char[buf.length + insert.length];
  System.arraycopy(buf, 0, result, 0, pos);
  System.arraycopy(insert, 0, result, pos, insert.length);
  System.arraycopy(buf, pos, result, pos+insert.length, buf.length-pos);
  
  buf = result;
  }

/**
Useful for inserting included files into the stream and then parsing that content in-line
with the rest of the file.
*/
public void insertIntoStream(Reader r) throws IOException
  {
  char[] insert = IOUtil.readerToCharArray(r);

  char[] result = new char[buf.length + insert.length];
  System.arraycopy(buf, 0, result, 0, pos);
  System.arraycopy(insert, 0, result, pos, insert.length);
  System.arraycopy(buf, pos, result, pos+insert.length, buf.length-pos);
  
  buf = result;
  }


void adjustReadLineNum(char c)
  {
  // we can read: \r, \r\n , \n all of which increase line count by exactly 1
  switch (c) 
    {
    case '\n': 
      if (! lastWasCR) {
        line++;
        lastcol=col;
        col=1;
        }
      else {
        lastWasCR = false;
        }
      break;
    
    case '\r': 
      line++;
      lastcol=col;
      col=1;
      lastWasCR = true;
      break;
    
    case '\t':
      col = col + 4;
      break;
    
    default:
      col++;
    }
  }


void adjustUnreadLineNum(char c)
  {
  // we can unread: \r, \r\n , \n all of which reduce line count by exactly 1
  switch (c) {
    case '\n': 
      pushBackNL = true;
      line--;
      col=lastcol;
      break;
    case '\r': 
      if (! pushBackNL) { 
        line--;
        col=lastcol;
        }
      else{
        pushBackNL = false;
        }
      break;
    case '\t':
      col = col - 4;
      break;
    default:
      col--;
    }
  }

public int peek() throws IOException
  {
  return buf[pos];
  }


/**
Skips all whitespace characters such that the next {@link read} will
return the <b>next</b> non-whitespace character (or EOF if there are no
more characters).
*/
public void skipWhitespace() throws IOException
  {
  int c = -1;
  while (true)
    {
    c = read();
    
    if (c == -1) {
      break;
      }
    
    if (! Character.isWhitespace(c)) {
      unread();
      break;
      }
    }
  }
  


/**
Tries to read/consumes the specified char and returns true
if successful. If the specified char is not found, does not
consume anything and returns false.
*/
public boolean match(int target) throws IOException
  {
  int c = read();
  
  if (c == target)
    return true;
  else
    unread();
  
  return false;
  }

/**
Tries to read/consumes the specified non-null string and returns true
if successful. If the specified string is not found, does not
consume anything and returns false.
*/
public boolean match(String target) throws IOException
  {
  if (target == null)
    throw new IllegalArgumentException("Specified target string was null");
  
  int c = -1;
  for (int i = 0; i < target.length(); i++)
    {
    c = read();
    
    if ( c == -1 || c != target.charAt(i)) {
      unread(i+1);
      return false;
      }
    }
  
  return true;
  }

public boolean matchIgnoreCase(String target) throws IOException
  {
  if (target == null)
    throw new IllegalArgumentException("Specified target string was null");
  
  int c = -1;
  for (int i = 0; i < target.length(); i++)
    {
    c = read();
    
    if ( c == -1 || c != Character.toLowerCase(target.charAt(i))) {
      unread(i+1);
      return false;
      }

    }
  
  return true;
  }

public boolean markSupported()
  {
  return false;
  }

public  int getLine() { 
  return line; 
  }
  
public  int getCol() { 
  return col; 
  }

char[] getBuf() { return buf; }
int getPos() { return pos; }

//other utility methods

public static void main (String args[]) throws IOException
  {
  //CHANGE CHAR BUFFER TO A SMALL VALUE FOR TESTING */
  StringReader sr = null;
  TemplateReader lex = null;
  int c = -1;
  
  System.out.println("Reading an empty string....."); 
  sr = new StringReader("");  
  lex = new TemplateReader(sr);
  while ( (c = lex.read()) != -1) {
    testprint(lex, c);
    }
  
  System.out.println("----------------- TEST 2 --------------");
  sr = new StringReader("abc");   
  lex = new TemplateReader(sr);
  while ( (c = lex.read()) != -1) {
    testprint(lex, c);
    //System.out.print(c + " ");
    }

  System.out.println("----------------- TEST 3 --------------");
  sr = new StringReader("abcde");   
  lex = new TemplateReader(sr);
  try {
    c = lex.read();
    testprint(lex, c);
    lex.unread();
    testprint(lex, -10);
    lex.unread();
    testprint(lex, -10);
    c = lex.read();
    testprint(lex, c);
    }
  catch (Exception e) {
    e.printStackTrace();
    }

  System.out.println("----------------- TEST 4 --------------");
  sr = new StringReader("abcd\ne");   
  lex = new TemplateReader(sr);
  try {
    c = lex.read();
    testprint(lex, c);
    lex.unread();
    testprint(lex, -10);

    for (int i = 0; i < 5; i++) {
      c = lex.read();
      testprint(lex, c);
      }

    for (int i = 0; i < 5; i++) {
      lex.unread();
      testprint(lex, -10);
      }
    
    for (int i = 0; i < 5; i++) {
      c = lex.read();
      testprint(lex, c);
      }
    
    c = lex.read();
    testprint(lex, c);
    }
  catch (Exception e) {
    e.printStackTrace();
    }

  System.out.println("----------------- TEST 5 --------------");
  sr = new StringReader("abcd\r\ne");   
  lex = new TemplateReader(sr);
  try {
    c = lex.read();
    testprint(lex, c, lex.peek());
    lex.unread();
    testprint(lex, -10, lex.peek());

    for (int i = 0; i < 5; i++) {
      c = lex.read();
      testprint(lex, c, lex.peek());
      }

    for (int i = 0; i < 5; i++) {
      lex.unread();
      testprint(lex, -10, lex.peek());
      }
    
    for (int i = 0; i < 5; i++) {
      c = lex.read();
      testprint(lex, c, lex.peek());
      }
    
    c = lex.read();
    testprint(lex, c, lex.peek());
    }
  catch (Exception e) {
    e.printStackTrace();
    }

  System.out.println("--------- TEST 6 ---(insert into stream middle)-------");
  sr = new StringReader("abc"); 
  lex = new TemplateReader(sr);
  
  try {
    c = lex.read();
    testprint(lex, c);
  
    StringReader insert = new StringReader("123");
    System.out.println("inserting \"123\" into the stream\n");
    lex.insertIntoStream(insert);

    while ( (c = lex.read()) != -1) {
      testprint(lex, c);
      }
    }
  catch (Exception e) {
    e.printStackTrace();
    }


  System.out.println("--------- TEST 7 ---(insert into stream begin)-------");
  sr = new StringReader("abc"); 
  lex = new TemplateReader(sr);
  
  try {
    StringReader insert = new StringReader("123");
    System.out.println("inserting \"123\" into the beginning of stream\n");
    lex.insertIntoStream(insert);

    while ( (c = lex.read()) != -1) {
      testprint(lex, c);
      }
    }
  catch (Exception e) {
    e.printStackTrace();
    }

  System.out.println("--------- TEST 8 ---(insert into stream end)-------");
  sr = new StringReader("abc"); 
  lex = new TemplateReader(sr);
  
  try {
    while ( (c = lex.read()) != -1) {
      testprint(lex, c);
      }
    StringReader insert = new StringReader("123");
    System.out.println("inserting \"123\" into the end of the stream\n");
    lex.insertIntoStream(insert);

    while ( (c = lex.read()) != -1) {
      testprint(lex, c);
      }
    }
  catch (Exception e) {
    e.printStackTrace();
    }

  }

private static void testprint(TemplateReader lex, int c, int peek)
  {
  if (c == -1) {
    System.out.println("====> recieved EOF (-1) from read().......");
    }

  System.out.format(
    "buf=%s, pos=%d, buflen=%d\nline=%d, col=%d, char=[%s]",
    StringUtil.arrayToString(lex.getBuf()), lex.getPos(), lex.getBuf().length,
    lex.getLine(), lex.getCol(), 
    (c == -10) ? "N/A" : StringUtil.viewableAscii((char)c));  

  if (peek != -2)  
    System.out.format(", peek=[%s]", StringUtil.viewableAscii((char)peek));

  System.out.print("\n\n");
  }

private static void testprint(TemplateReader lex, int c)
  {
  testprint(lex, c, -2);
  }

}