//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;

import java.io.*;
import com.stevesoft.pat.wrap.*;

/** This class allows you to replace the text in strings
    as you read them in.  Be careful what you do with
    this freedom... using Regex.perlCode("s{.*}{x}s")
    as your pattern will result in loading the entire
    contents of the Reader into memory.
    */
public class RegexReader extends Reader {
  RBuffer rb = new RBuffer(new StringBuffer());
  PartialBuffer wrap = new PartialBuffer(rb.sb);
  boolean moreToRead = true;
  Reader r;
  Replacer rp;

  // the buffer size
  int nmax = 2*1024;

  public RegexReader(Regex rex,Reader r) {
    this.r = r;
    rp = rex.getReplacer();
  }
  public RegexReader(Transformer tex,Reader r) {
    this.r = r;
    rp = tex.getReplacer();
  }
  public void reset() throws IOException {
    r.reset();
    rb = new RBuffer(new StringBuffer());
    wrap = new PartialBuffer(rb.sb);
    moreToRead = true;
  }
  void readData() throws IOException {
    int c;
    int n = 0;
    while( (c = r.read()) != -1) {
      rb.sb.append((char)c);
      if(n++ > nmax)
        break;
    }
    if(c == -1 && n == 0) {
      moreToRead = false;
      wrap.allowOverRun = false;
    }
  }
  void getMoreData() throws IOException {
    while(rb.pos >= rb.epos) {
      wrap.overRun = false;
      if(rb.next != null) {
	rb = rb.next;
      } else if(rb.done) {
        break;
      } else if(rb.epos >= rb.sb.length()
	     && rb.epos > nmax) {
	rb.pos = 1;
	rb.epos = 1;
	rb.sb.setLength(1);
	readData();
      } else if(rb.epos >= rb.sb.length()
	     && moreToRead) {
        readData();
      } else if(rp.getRegex().matchAt(wrap,rb.epos)) {
	if(wrap.overRun) {
	  readData();
	} else {
	  StringBufferWrap sbw = new StringBufferWrap();
	  StringBufferLike sbl = new StringBufferLike(sbw);
	  /*
          ReplaceRule rr = rex.getReplaceRule();
	  while(rr != null) {
	    rr.apply(sbl,rex);
	    rr = rr.next;
	  }
	  */
	  Regex rex = rp.getRegex();
	  int npos = rex.matchedTo();
	  rp.setBuffer(sbl);
	  rp.setSource(wrap);
	  rp.setPos(npos);
	  rp.apply(rex,rex.getReplaceRule());
	  int opos = rb.epos;
	  RBuffer rb2 = new RBuffer((StringBuffer)sbw.unwrap());
	  rb2.epos = rb2.sb.length();
	  RBuffer rb3 = new RBuffer(rb.sb);

	  rb.next = rb2;
	  rb2.next = rb3;

	  if(npos == opos) {
	    rb3.epos = npos+1;
	    if(rb3.epos > rb3.sb.length()) {
	      if(rb.pos >= rb.epos)
	        rb = rb.next;
	      rb3.pos = rb3.epos = 0;
	      rb3.done = true;
	      //break;
	    }
            rb3.pos = npos;
	  } else {
	    rb3.pos = rb3.epos = npos;
	  }

        }
      } else {
	if(wrap.overRun) {
	  readData();
        } else if(rb.epos<rb.sb.length()) {
	  rb.epos++;
        } else {
	  break;
	}
      }
    }
  }
  public int read() throws IOException {
    if(rb.pos >= rb.epos) {
      getMoreData();
      if(rb.pos >= rb.epos)
        return -1;
    }
    //System.out.println(rb);
    return rb.sb.charAt(rb.pos++);
  }
  public int read(char[] buf,int off,int len)
    throws IOException
  {
    int c = -1;
    int end = off+len;
    for(int i=off;i<end;i++) {
      c = read();
      if(c < 0) {
	if(i == off)
	  return -1;
        return i-off;
      }
      buf[i] = (char)c;
    }
    return len;
  }
  public void close()
    throws IOException
  {
    r.close();
  }

  public boolean markSupported() { return false; }

  /** Get the size of the working buffer.
      The current buffer may be larger if
      the pattern demands it. */
  public int getBufferSize() {
    return nmax;
  }
  /** Set the size of the working buffer.
      The current buffer may be larger if
      the pattern demands it. */
  public void setBufferSize(int n) {
    nmax = n;
  }

  int max_lines = 2;
  /** This function no longer serves any purpose.
      @deprecated
      */
  public int getMaxLines() { return max_lines; }
  /** This function no longer serves any purpose.
      @deprecated
      */
  public void setMaxLines(int ml) { max_lines = ml; }

  char EOLchar = '\n';
  /** This function no longer serves any purpose.
      @deprecated
      */
  public char getEOLchar() {
    return EOLchar;
  }
  /** This function no longer serves any purpose.
      @deprecated
      */
  public void setEOLchar(char c) {
    EOLchar = c;
  }

  public long skip(long d) throws IOException {
    // This is probably inefficient, I just did it
    // this way to avoid possible bugs.
    long n = 0;
    while(n<d && read() != -1)
      n++;
    return n;
  }

  /*
  static void test(String re,String inp,int n) throws Exception {
    Reader r = new StringReader(inp);
    r = new BufferedReader(r);
    Regex rex = Regex.perlCode(re);
    String res1 = rex.replaceAll(inp);
    int c = -1;
    StringBuffer sb = new StringBuffer();
    RegexReader rr = new RegexReader(rex,r);
    rr.setBufferSize(n);
    while( (c = rr.read()) != -1)
      sb.append((char)c);
    String res2 = sb.toString();
    if(!res1.equals(res2)) {
      System.out.println("nmax="+n);
      System.out.println("re="+re);
      System.out.println("inp="+inp);
      System.out.println("res1="+res1);
      System.out.println("res2="+res2);
      System.exit(255);
    }
  }
  public static void main(String[] args) throws Exception {
    for(int n=6;n<15;n++) {
      test("s/x/y/","-----x123456789",n);
      test("s/x/y/","x123456789",n);
      test("s/x/y/","-----x",n);
      test("s/x.*?x/y/",".xx..x..x...x...x....x....x",n);
      test("s/x.*x/[$&]/","--x........x--xx",n);
      test("s/x.*x/[$&]/","--x........x------",n);
      test("s/.$/a/m","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb",n);
      test("s/.$/a/","123",n);
      test("s/.$/a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
      test("s/^./a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
      test("s/$/a/","bbb",n);
      test("s/^/a/","bbb",n);
      test("s/^/a/","",n);
      test("s{.*}{N}","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",n);
      test("s/.{0,7}/y/","AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",n);
      test("s/x/$&/","xxx",n);
    }
    System.out.println("Success!!!");
  }
  */
}