/*
    * Fsgrep is a simple Java application which allows a user to
    * search all files in a directory structure for lines matching
    * a given pattern.  Its functionality is a combination of the
    * Unix 'find' and 'grep' utilities.
    * Visit [http://fsgrep.sourceforge.net/] for more information.
    * 
    * Copyright (C) 2003-2006 Murali Krishnan [murali_ca_us@users.sourceforge.net]
    * 
   * Fsgrep is free software; you can redistribute it and/or modify
   * it under the terms of version 2 of the GNU General Public
   * License as published by the Free Software Foundation.
   * 
   * Fsgrep is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License
   * along with Fsgrep (see the file named LICENSE.txt); if not, write
   * to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   * Boston, MA  02111-1307  USA
   */
  
  package mk.fsgrep.util;
  
  import java.io.*;
  import java.util.*;
  
  /***
   * A utility that fully reads a file and provides access to the contents
   * as a List of lines.
   * It is meant to replace LineNumberReader and (its parent) BufferedReader
   * because those consume the EOL characters when returning lines.
   * 
   * @author  Murali Krishnan
   *
   */
  public class RawLineReader {
  
      //------------------------------------------------------------
      //- Class Variables
  
      private static final int BUFFER_SIZE = 36;
      private static final char CR = '\r';
      private static final char LF = '\n';
  
  
      //------------------------------------------------------------
      //- Class Functions
  
  
  
      //------------------------------------------------------------
      //- Instance Variables
  
      private File vFile = null;
      private LinkedList<FileLine> vLines = new LinkedList<FileLine>();
      private int vSize = 0;
  
  
      //------------------------------------------------------------
      //- Constructors
  
      public RawLineReader(String pFileName) {
          this(new File(pFileName));
      }
  
  
      public RawLineReader(File pFile) {
          vFile = pFile;
  
          initialize();
      }
  
  
      /***
       * For testing only.
       * 
       */
      protected RawLineReader() {
      }
  
  
      //------------------------------------------------------------
      //- Accessors
  
      protected File getFile() {
          return vFile;
      }
  
      public int getSize() {
          return vSize;
      }
  
      protected LinkedList<FileLine> getLines() {
          return vLines;
      }
  
 
 
     //------------------------------------------------------------
     //- Settors
 
     public void setSize(int val) {
         vSize = val;
     }
 
 
 
     //------------------------------------------------------------
     //- Private/Protected Utility Functions
 
     protected void initialize() {
         try {
             FileReader fr = new FileReader(getFile());
             initialize(fr);
             fr.close();
         } catch (IOException ioe) {
             System.err.println("Problem reading [" + getFileName() + "].");
             ioe.printStackTrace();
         }
     }
 
 
     protected void initialize(Reader reader) throws IOException {
         int size = 0;
         char[] buffer = new char[BUFFER_SIZE];
         Splitter splitter = new Splitter(getLines());
 
         boolean done;
         do {
             int charsRead = reader.read(buffer);
             done = (charsRead == -1);
             if (done) {
                 if (splitter.hasRemainder()) {
                     getLines().add(splitter.giveRemainder());
                 }
             } else {
                 size += charsRead;
                 splitter.add(buffer, charsRead);
             }
         } while(!done);
 
         setSize(size);
     }
 
 
     protected void initialize(String content) {
         try {
             StringReader reader = new StringReader(content);
             initialize(reader);
             reader.close();
         } catch (IOException ioe) {
             System.err.println("Problem reading content.");
             ioe.printStackTrace();
         }
     }
 
 
     protected String getFileName() {
         String result = getFile().getAbsolutePath();
         return result;
     }
 
 
     protected void saveTo(String pString) {
         try {
             FileWriter fw = new FileWriter(pString);
             for (FileLine line : getLines()) {
                 fw.write(line.getText());
             }
             fw.close();
         } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
 
 
     //------------------------------------------------------------
     //- Public Interface Functions
 
     public String toString() {
         String result = "RawLineReader[name=" + getFileName() + ",lines=" + getLines().size() + ",characters=" + getSize() + "]";
         return result;
     }
 
 
     public boolean hasMore() {
         boolean result = !getLines().isEmpty();
         return result;
     }
 
 
     public FileLine nextLine() {
         return getLines().removeFirst();
     }
 
 
     //------------------------------------------------------------
     //- Class Interface Functions
 
 
 
     //------------------------------------------------------------
     //- Inner Classes
 
     private class Splitter {
         private StringBuffer vRemainder = new StringBuffer();
         private char vLastRemainderChar = Character.MIN_VALUE;
         private char[] vBuffer = null;
         private int vStart = 0;
         private int vCurrent = 0;
         private int vEnd = 0;
         private int vLineNumber = 0;
         private LinkedList<FileLine> vBufferLines = null;
 
         public Splitter(LinkedList<FileLine> pBufferLines) {
             vBufferLines = pBufferLines;
         }
 
 
         private boolean currentIs(char ch) {
             boolean result = vBuffer[vCurrent] == ch;
             return result;
         }
 
         private boolean nextIs(char ch) {
             int next = vCurrent + 1;
             boolean result = (next < vEnd) && (vBuffer[next] == ch);
             return result;
         }
 
         private boolean atEol() {
             boolean result = currentIs(LF) ||
                 (currentIs(CR) && !nextIs(LF));
             return result;
         }
 
         private boolean atEob() {
             boolean result = (vCurrent >= vEnd);
             return result;
         }
 
         public boolean hasRemainder() {
             boolean result = (vRemainder.length() > 0);
             return result;
         }
 
 
         public FileLine giveRemainder() {
             FileLine result = new FileLine(++vLineNumber, vRemainder.toString());
             vRemainder = new StringBuffer();
             return result;
         }
 
         public boolean needToProcess() {
             boolean result = true;
 
             while (!(atEob() || atEol())) {
                 vCurrent++;
             }
 
             if (atEob()) {
                 result = false;
                 --vCurrent;
 
                 int length = (vCurrent-vStart+1);
                 if (length > 0) {
                     vRemainder.append(new String(vBuffer, vStart, length));
                 } else {
                     // Store what the last char in the buffer was.
                     vLastRemainderChar = vBuffer[vCurrent];
                 }
             } else {
                 int length = (vCurrent-vStart+1);
                 String text = new String(vBuffer, vStart, length);
                 if (vRemainder.length() > 0) {
                     text = vRemainder + text;
                     vRemainder = new StringBuffer();
                 }
 
                 vStart = ++vCurrent;
 
                 FileLine newLine = new FileLine(++vLineNumber, text);
                 vBufferLines.add(newLine);
             }
 
             return result;
         }
 
 
         public boolean hasMore() {
             boolean result = !vBufferLines.isEmpty();
             return result;
         }
 
 
         public FileLine nextLine() {
             return vBufferLines.removeFirst();
         }
 
 
         public void add(char[] buffer, int len) {
             vBuffer = buffer;
             vStart = 0;
             vCurrent = 0;
             vEnd = len;
 
             // If last line ended in CR, check if buffer start with LF.
             if ((vLastRemainderChar == CR) && (buffer[0] == LF)) {
                 // This means it was a CRLF that was prematurely seen as
                 // as just CR.  Rectify by adding the LF.
                 FileLine last = vBufferLines.getLast();
                 last.setText(last.getText() + LF);
 
                 // And skip over the LF.
                 vStart = 1;
                 vCurrent = 1;
             }
 
             //noinspection StatementWithEmptyBody
             while (needToProcess());
         }
     }
 
 
     //------------------------------------------------------------
     //- Main
 
     public static void main(String[] args) {
         try {
             for (String arg : args) {
                 RawLineReader rlr = new RawLineReader(arg);
                 System.out.println(rlr);
                 rlr.saveTo("testout.txt");
             }
 
         } catch (Throwable thr) {
             System.err.println("Fatal error.");
             thr.printStackTrace();
         }
     }
 
 
 
 }