////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2001-2004 Open World Ltd
   //
   // This file is part of MillScript.
   //
   // MillScript is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript 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
  // MillScript; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.millscript.loaders;
  
  import org.millscript.commons.util.IList;
  import org.millscript.commons.util.list.EArrayList;
  import org.millscript.commons.vfs.VFile;
  import org.millscript.millscript.alert.Alerts;
  
  import java.io.IOException;
  
  /**
   * This class implements a separated file format loader for MillScript. The
   * contents of the file are read as text, which is then broken up into lines.
   * Each line is broken up into sections, based on the separator registered with
   * this loader.
   */
  public class SVLoader extends AbsTextLoader {
  
      /**
       * The separated file field delimiter. This is used to delimit
       * fields that contain either the field or record separator.
       */
      private String delimiter = "\"";
  
      /**
       * The escaped version of the delimiter character. This is used
       * when reading a quoted value that contains the delimiter
       * character.
       */
      private String escapedDelimiter = delimiter + delimiter;
  
      /**
       * The separated file field separator. This is used to separate
       * individual fields within a record.
       */
      private String separator = ",";
  
      /**
       * Holds the complete contents of the SV file as a String.
       */
      private String svFileContents = "";
  
      /**
       * Holds the current position in the sv file.
       */
      private int currentPos = 0;
  
      /**
       * Flag to indicate if we must still trim leading white space
       * from the field.
       */
      private boolean trimLeading = true;
  
      /**
       * This holds the current field that we are reading.
       */
      private StringBuffer currentField;
  
      /**
       * Temporarily holds the last unquoted section of the
       * current field, so that we can remove trailing white space
       * if necessary.
       */
      private StringBuffer lastUnquotedSection;
  
      /**
       * This will hold each field in a record from the SV file
       */
      private EArrayList< String > currentRecord;
  
      /**
       * @see org.millscript.millscript.loaders.Loader#loadValue()
       */
      @Override
      public Object loadValue() throws IOException {
  
          // This string is used to separate records in the SV file.
          String recordSeparator = System.getProperty( "line.separator" );
  
          if ( this.entry instanceof VFile && this.entry.exists() ) {
             // Read the complete contents of the SV file into our
             // storage variable.
             svFileContents = readAll( ((VFile) entry).getReader() );
         } else {
             throw(
                 Alerts.compile(
                     "Inventory entry is not a file",
                     "Separated value loader can only be used to load files"
                 ).culprit( "entry", this.entry ).mishap()
             );
         }
 
         // This will hold each record of the SV file
         // after we've processed it.
         EArrayList< IList< String > > records = new EArrayList< IList< String > >();
 
         // Reset the current record holder.
         currentRecord = new EArrayList< String >();
 
         // Reset the current field holder.
         currentField = new StringBuffer();
 
         // Reset the last unquoted section.
         lastUnquotedSection = new StringBuffer();
 
         // Reset the current position in the sv file
         currentPos = 0;
 
         // Reset the trim leading whitespace flag.
         trimLeading = true;
 
         while ( currentPos < svFileContents.length() ) {
 
             if ( svFileContents.startsWith( separator, currentPos ) ) {
 
                 // System.err.println( "ENDFIELD: Adding field to current record" );
 
                 addField();
 
                 // Increment the current position by the length
                 // of the field separator.
                 currentPos += separator.length();
 
             } else if ( svFileContents.startsWith( recordSeparator, currentPos ) ) {
 
                 // System.err.println( "ENDRECORD: Adding last field to current record" );
 
                 addField();
 
                 // System.err.println( "ENDRECORD: Adding current record to records" );
 
                 // Add the current record to the list of records
                 // we've read from the SV file so far.
                 records.addLast( currentRecord );
 
                 // Now reset the current record ready to read
                 // the next one.
                 currentRecord = new EArrayList< String >();
 
                 // Increment the current position by the length
                 // of the field separator.
                 currentPos += recordSeparator.length();
 
             } else if ( svFileContents.startsWith( delimiter, currentPos ) ) {
 
                 // System.err.println( "Reading quoted field/value" );
 
                 addLastUnquotedSectionToField();
 
                 // Read the quoted field/value, appending it to
                 // the current field buffer.
                 readQuotedField();
 
             } else {
 
                 // System.err.println( "Adding '" + svFileContents.charAt( currentPos ) + "' to current field" );
 
                 // This is just a normal character, so we append it
                 // to the current field.
                 lastUnquotedSection.append( svFileContents.charAt( currentPos ) );
 
                 // Increment the current position by one, so that we
                 // move on to the next character.
                 currentPos++;
 
             }
 
         }
 
         return records;
 
     }
 
     /**
      * Adds the last unquoted section of a field/value to the
      * current field buffer. This is done whenever we are about
      * to start reading a quoted section or we have reached the
      * end of the field.
      */
     private void addLastUnquotedSectionToField() {
 
         // Add the last unquoted section of the field
         currentField.append( lastUnquotedSection );
 
         // Reset the last unquoted section buffer, so that
         // we are ready to read the next field/value.
         lastUnquotedSection = new StringBuffer();
 
         // Remove any leading whitespace from the front of this field, if
         // appropriate.
         trimLeadingWhitespace();
 
     }
 
     /**
      * Adds the current field to the current record, resetting
      * the important state information.
      */
     private void addField() {
 
         // System.err.println( "ADDFIELD: Adding field to current record" );
 
         // Remove any trailing whitespace from the last unquoted
         // section.
         trimTrailingWhitespace();
 
         // Add the last unquoted section.
         addLastUnquotedSectionToField();
 
         // Add the current field to the current record.
         currentRecord.addLast( currentField.toString() );
 
         // Now reset the current field ready to read
         // the next one.
         currentField = new StringBuffer();
 
         // Reset the trim leading white space flag, for the new field.
         trimLeading = true;
 
     }
 
     /**
      * Set the separator for this separated value file.
      *
      * @param s the separator for this file
      */
     public void setSeparator( final String s ) {
 
         separator = s;
 
     }
 
     /**
      * Set the delimiter for quoted fields/values in the separated
      * value file.
      *
      * @param d the delimiter for quoted values
      */
     public void setDelimeter( final String d ) {
 
         // Set the delimiter
         delimiter = d;
 
         // Set the escaped version of the delimiter.
         escapedDelimiter = delimiter + delimiter;
 
     }
 
     /**
      * Reads a quoted value from the SV file. A quoted value starts
      * with the delimiter and continues to the next single delimiter.
      * Within a quoted field the delimiter is represented by a pair
      * of the delimiter characters.
      */
     private void readQuotedField() {
 
         // Add the character at the current position
         // (which is the delimiter at the start of the quoted value)
         // currentField.append( delimiter );
 
         // Increment the current position, otherwise we won't read
         // the quoted value properly.
         // We might stop without reading the quoted value, as we
         // might think the first delimiter is the last...
         currentPos += delimiter.length();
 
         while ( currentPos < svFileContents.length() ) {
 
             if ( svFileContents.startsWith( escapedDelimiter, currentPos ) ) {
 
                 // It's just a delimiter character.
                 currentField.append( delimiter );
 
                 // Increment the current position by the length
                 // of the escaped delimiter.
                 currentPos += escapedDelimiter.length();
 
             } else if ( svFileContents.startsWith( delimiter, currentPos ) ) {
 
                 // It's the end of the quoted field/value.
                 // currentField.append( delimiter );
 
                 // Increment the current position
                 currentPos += delimiter.length();
 
                 // Break out of the while loop.
                 // Otherwise we'll read to the end of the file...
                 break;
 
             } else {
 
                 // The character at the current position is just
                 // a normal part of the field, so we just add it.
                 currentField.append( svFileContents.charAt( currentPos ) );
 
                 // Increment the current position.
                 currentPos++;
 
             }
 
         }
 
     }
 
     /**
      * Tests is the supplied character is white space, according to our
      * definition. We currently recognise only spaces and tabs as white space
      * characters. This is deliberately different from the Java version
      * which would also include newlines and more.
      *
      * @param   ch  the character to test
      * @return  <code>true</code> if the supplied character is whitespace,
      * <code>false</code> otherwise
      */
     private boolean isWhiteSpace( final char ch ) {
         return ( ch == ' ' || ch == '\t' );
     }
 
     /**
      * Removes any white space from the start of the current field. This method will
      * only remove characters once for any imported field. As this method is called
      * before any quoted section is parsed it will only remove unquoted white space.
      */
     private void trimLeadingWhitespace() {
         if ( trimLeading ) {
 
             // We start from the begining of the current field.
             int pos = 0;
 
             // Keep moving one character at a time, from left to right, until
             // we find the first character that is not white space, or we reach
             // the end of the field.
             while ( pos < currentField.length() && isWhiteSpace( currentField.charAt( pos ) ) ) {
                 // System.err.println( "TRIMLEADING: pos(" + Integer.toString( pos ) + ") : '" + currentField.charAt( pos ) + "'" );
                 pos++;
             }
 
             // Remove any white space from the start of the current field
             // to the character preceeding the first non-white space character.
             currentField.delete( 0, pos );
 
             // We don't want to trim any more leading white space while we
             // are processing this field.
             trimLeading = false;
         }
     }
 
     /**
      * Removes any white space from the end of unquoted sections of the current
      * field. As this method is called just before the field is "added" to the
      * current row, only white space at the end of the last unquoted section will
      * be removed.
      */
     private void trimTrailingWhitespace() {
 
         // The length of the last unquoted section.
         int length = lastUnquotedSection.length();
 
         // The index of the last character is the length - 1.
         int pos = length - 1;
 
         // Keep moving one character at a time, from right to left, until
         // we find the first character that is not white space, or we reach
         // the start of the field.
         while ( length > 0 && isWhiteSpace( lastUnquotedSection.charAt( pos ) ) ) {
             // System.err.println( "TRIMTRAILING: pos(" + Integer.toString( pos ) + ") : '" + lastUnquotedSection.charAt( pos ) + "'" );
             length--;
             pos--;
         }
 
         // Truncate the last unquoted section after the last non-white space
         // character.
         lastUnquotedSection.setLength( length );
     }
 
 }