/*
    * $Source$
    * $Revision$
    *
    * Part of Melati (http://melati.org), a framework for the rapid
    * development of clean, maintainable web applications.
    *
    *  Copyright (C) 2001 Myles Chippendale
    *
   * Melati is free software; Permission is granted to copy, distribute
   * and/or modify this software under the terms either:
   *
   * a) 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,
   *
   *    or
   *
   * b) any version of the Melati Software License, as published
   *    at http://melati.org
   *
   * You should have received a copy of the GNU General Public License and
   * the Melati Software License along with this program;
   * if not, write to the Free Software Foundation, Inc.,
   * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
   * GNU General Public License and visit http://melati.org to obtain the
   * Melati Software License.
   *
   * Feel free to contact the Developers of Melati (http://melati.org),
   * if you would like to work out a different arrangement than the options
   * outlined here.  It is our intention to allow Melati to be used by as
   * wide an audience as possible.
   *
   * This program 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.
   *
   * Contact details for copyright holder:
   *
   *     Myles Chippendale <mylesc At paneris.org>
   *
   *
   * ------
   *  Note
   * ------
   *
   * I will assign copyright to PanEris (http://paneris.org) as soon as
   * we have sorted out what sort of legal existence we need to have for
   * that to make sense. 
   * In the meantime, if you want to use Melati on non-GPL terms,
   * contact me!
   */
  
  package org.melati.poem.csv;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.Writer;
  import java.util.Enumeration;
  import java.util.Hashtable;
  import java.util.NoSuchElementException;
  import java.util.Vector;
  
  import org.melati.poem.Persistent;
  import org.melati.poem.Table;
  
  /**
   * A representation of a CSV file as a POEM Table.
   */
  public class CSVTable {
  
    protected Table<?> table = null;
    protected File data = null;
    protected Hashtable<String,CSVColumn> columns = new Hashtable<String,CSVColumn>();
    protected Vector<CSVColumn> columnsInUploadOrder = new Vector<CSVColumn>();
    protected CSVColumn primaryKey = null;
    protected Vector<CSVRecord> records = new Vector<CSVRecord>();
    protected BufferedReader reader = null;
    protected CSVFileParser parser = null;
    
    /** The line number of the CSV file. */
    private int lineNo;
    
    /** The record number of the CSV file. */
    private int recordNo;
  
  
   /**
    * Constructor.
    * 
    * @param table POEM table to load data into
    * @param data CSV file to read from
    */
    public CSVTable(Table<?> table, File data) {
      this.table = table;
      this.data = data;
     try {
       reader = new BufferedReader(new FileReader(this.data));
       parser = new CSVFileParser(this.reader);
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
 
   /**
    * Process the first line to define columns. 
    * The first line contains the field names - this needs to be
    * validated against expected values, and the order of
    * the fields established.
    * 
    * @throws IOException
    */
   public void define() throws IOException  {
       parser.nextRecord();
       lineNo = 1;
       recordNo = 0;
 
       while (parser.recordHasMoreFields()) {
         String key = parser.nextField();
         CSVColumn col = columns.get(key);
         if (col == null)
           throw new CSVParseException(
             "I don't know what to do with the column in " + data.getPath() +
             " called " + key); 
         columnsInUploadOrder.addElement(col);
       }
   }  
 
  /**
   * Add column definitions to this table.
   */
   public void addColumn(String csvName, String poemName) {
     columns.put(csvName, new CSVColumn(poemName));
   }
 
  /**
   * Add column definitions, perhaps Primary Keys, to this table.
   */
   public void addColumn(String csvName, String poemName, boolean isPrimaryKey)
       throws CSVPrimaryKeyColumnAlreadySetException {
     if (isPrimaryKey && primaryKey != null)
       throw new CSVPrimaryKeyColumnAlreadySetException(table.getName());
     CSVColumn col = new CSVColumn(poemName, isPrimaryKey);
     columns.put(csvName, col);
     if (isPrimaryKey)
       primaryKey = col;
   }
 
    /**
     * Add column definitions for foreign keys to this table.
     */
     public void addColumn(String csvName,  
                           String foreignPoemName, CSVTable foreignTable) {
       columns.put(csvName, new CSVColumn(foreignPoemName, foreignTable));
     }
 
 
  /**
   * Parse the CSV data file and store the data for saving later.
   * 
   * @param writeOnFly whether to commit each line to db as we go
   * @throws IOException if there is a file system problem
   * @throws CSVParseException if the is a malformed field in the CSV
   * @throws CSVWriteDownException
   * @throws NoPrimaryKeyInCSVTableException
   */
   public void load(boolean writeOnFly) 
       throws IOException, CSVParseException, NoPrimaryKeyInCSVTableException, 
              CSVWriteDownException {
 
     try {
       define();
       // Suck in all the data
       CSVRecord record;
       while(null != (record = parseRecord())) {
         record.setLineNo(lineNo++);
         record.setRecordNo(recordNo++);
         if (writeOnFly)
           record.makePersistent();
         else 
           records.addElement(record);
       }
 
     }
     catch (IllegalArgumentException e) {
        throw new CSVParseException("Failed to load field in " +
                                     data.getPath() + 
                                     " line " + lineNo +
                                     ": " + e.toString());
     }
     catch (NoSuchElementException f) {
        throw new CSVParseException("Failed to read column header in " +
                                     data.getPath() + 
                                     " line " + lineNo +
                                     ": " + f.toString());
     }
     finally {
       reader.close();
     }
   }
 
 
  /**
   * Reads the file until is has seen an object's-worth of
   * field values (ie until it sees an EOF or a line starting
   * with '$') which it returns in a hashtable (null if there are
   * no field values).
    * @return a new CSVRecord
    * @throws IOException if there is a problem with the file system
    * @throws CSVParseException if there is a problem parsing the input
    */
   public CSVRecord parseRecord() throws IOException, CSVParseException {
     if (!parser.nextRecord())
       return null;
 
     int i = 0;
     String value = null;
     try {
       CSVRecord record = new CSVRecord(table);
       for (; i < columnsInUploadOrder.size(); i++) {
         value = parser.nextField();
         CSVColumn col = (CSVColumn)columnsInUploadOrder.elementAt(i);
         record.addField(new CSVField(col, value));
       }
       record.setLineNo(parser.getLineNo());
       return record;
     }
     catch (IllegalArgumentException e) {
        throw new CSVParseException("Failed to read data field no. " + 
                                     (i+1) + 
                                     " in " +
                                     data + 
                                     " line " + lineNo +
                                     ": " + e.toString());
     }
     catch (NoSuchElementException f) {
       String message = "Problem with data field no. " + (i+1) +
       " of " + columnsInUploadOrder.size() +
       " in " + data +
       " line " + lineNo;
       
       if (value == null) {
         message += " (Check last line of file) : " + 
                     f.toString();
       } else {
         message += ", Value:" + value + ": " + f.toString();
       }
       throw new CSVParseException(message);
     }
   }
 
 
  /**
   * Delete all Persistents from the Poem table.
   */
   public void emptyTable() {
     Enumeration<?> rows = table.selection();
     while(rows.hasMoreElements()) {
       Persistent p = (Persistent)rows.nextElement();
       p.delete();
     }
   }
 
  /**
   * Write the records to the database, 
   * called if we are not writing each record to db as we go.
   */
   public void writeRecords() 
       throws NoPrimaryKeyInCSVTableException,  CSVWriteDownException {
     for (int i = 0; i < records.size(); i++) {
       ((CSVRecord)records.elementAt(i)).makePersistent();
     }
   }
   
 
   /**
    * Lookup the Persistent corresponding to the CSV record
    * with the given value for the CSV table's primary key.
    * @throws NoPrimaryKeyInCSVTableException
    * @throws CSVWriteDownException
    */
   protected Persistent getRecordWithID(String csvValue)
       throws NoPrimaryKeyInCSVTableException, CSVWriteDownException {
     if (primaryKey == null)
       throw new NoPrimaryKeyInCSVTableException(table.getName(), csvValue);
 
     for (int i = 0; i < records.size(); i++) {
       CSVRecord record = (CSVRecord)records.elementAt(i);
       if (record.primaryKeyValue != null &&
           record.primaryKeyValue.equals(csvValue))
         return record.getPersistent();
     }
     return null;
   }
 
  /**
   * Return a string reporting on the data added to this table.
   */
   public void report(boolean recordDetails, boolean fieldDetails,
                        Writer output) throws IOException {
 
     output.write("*** TABLE: " + table.getName().toUpperCase() + " **\n\n");
     output.write("** I have read " + records.size() + " records of " +
                    columnsInUploadOrder.size() + " fields\n");
 
     if (recordDetails) {
       for (int i = 0; i < records.size(); i++) {
         CSVRecord record = (CSVRecord)records.elementAt(i);
         output.write("   Record: CSV primary key = " +
                         record.primaryKeyValue);
 
         if (record.poemRecord == null)
           output.write(", No Poem Persistent written\n");
         else
           output.write(", Poem Troid = " + record.poemRecord.getTroid() + "\n");
 
         if (fieldDetails) {
           for (int j = 0; j < record.getFields().size(); j++) {
             CSVField field = (CSVField)record.getFields().elementAt(j);
             output.write(field.column + "=\"" + field.value);
             if (j < record.getFields().size()-1)
               output.write("\",");
             else
               output.write("\"\n");
           }
         }
       }
     }
     output.write("** Currently " + table.count(null) +
                   " Persistents in this table\n\n");
   }
 
   /**
    * Used in debugging to display name of table being emptied.
    * 
    * @return the POEM Table's name
    */
   public String getName() {
     return table.getName();
   }
 }