/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library 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
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.core;
  
  import java.io.*;
  import java.util.*;
  
  /*** The EntityReader is a FilterReader that adds read methods for reading 
   * entities, selections and related data.
   *
   * @author  Dennis Zikovic
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2003-02-24  Dennis Zikovic    Creation
   */
  public class EntityReader extends FilterReader
  {
      // Data members ------------------------------------------------------------
      private int mFieldSeparator = ';';
      private int mRecordSeparator = '\n';
      private int mStringDelimiter = '"';
  
      private String mNullValue = "";
      
      private int mLastReadSeperator = mRecordSeparator;
  
      // Constructors ------------------------------------------------------------
      public EntityReader(Reader in)
      {
          super(in);
      }
      
      public EntityReader(Reader in, int fieldSeparator, int entitySeparator)
      {
          this(in);
          mFieldSeparator = fieldSeparator;
          mRecordSeparator = entitySeparator;
      }
      
      // Action methods ----------------------------------------------------------
      public IEntity readEntity(IEntityDescriptor entityDescriptor) throws IOException
      {
          IEntity entity = entityDescriptor.createEntity();
          
          Object data = null;
          for(int j=0; j<entity.getEntityDescriptor().getFieldCount(); j++)
          {
              data = this.readData(entity.getEntityDescriptor().getFieldDescriptor(j).getDataType());
              if(data!=this)
                  entity.setData(entityDescriptor.getFieldDescriptor(j), data);
          }
          
          entity.setStatusFlag(IEntity.PERSISTENT);
          entity.clearStatusFlag(IEntity.DIRTY | IEntity.EMPTY);
          return entity;
      }
      
      /*** Reads a mapped selection from the Reader until end of data. Using this
       * method makes it possible to read from files that has an old entity 
       * descriptor that has changed since the data was written.
       */
      public ISelection readMappedSelection(IEntityDescriptor entityDescriptor) throws IOException
      {
          ISelection selection = new Selection(entityDescriptor);
          
          // Read and create field map.
          ArrayList fieldArray = new ArrayList();
          do
          {
              fieldArray.add(this.readData(DataType.STRING));
          }
          while(mLastReadSeperator!=mRecordSeparator);        
          
          // Validate field map.
          IFieldDescriptor fieldMap[] = new IFieldDescriptor[fieldArray.size()];
          for(int j=0; j<fieldArray.size(); j++)
              fieldMap[j] = findFieldDescriptor(entityDescriptor, fieldArray.get(j).toString());
          
          // Read selection until end of data.
         //
         // Note that the ready method is not reliable on input streams returned
         // from zip files. Because of that extra checks is added on the last
         // read seperator to avoid reading in empty entities.
         IEntity entity; 
         Object data;
         while(in.ready() && mLastReadSeperator==mRecordSeparator)
         {
             entity = entityDescriptor.createEntity();
             
             for(int j=0; j==0 || j<fieldMap.length && (mLastReadSeperator==mFieldSeparator); j++)
             {
                 if(fieldMap[j]!=null)
                 {
                     data = this.readData(((IFieldDescriptor)fieldMap[j]).getDataType());
                     entity.setData(entityDescriptor.getFieldDescriptor(j), data);
                 }
                 else    
                     this.readData(null);
             }
             
 			if(mLastReadSeperator==mRecordSeparator)
 			{
 				entity.setStatusFlag(IEntity.PERSISTENT);
 				entity.clearStatusFlag(IEntity.DIRTY | IEntity.EMPTY);
 				selection.addEntity(entity);
 			}
         }
     
         return selection;
     }
 
     // Access methods ----------------------------------------------------------
     
     public int getFieldSeparator()
     {
         return mFieldSeparator;
     }
     
     public void setFieldSeparator(int character)
     {
         mFieldSeparator = character;
     }
     
     public int getRecordSeparator()
     {
         return mRecordSeparator;
     }
     
     public void setRecordSeparator(int character)
     {
         mRecordSeparator = character;
     }
     
     public int getStringDelimiter()
     {
         return mStringDelimiter;
     }
     
     public void setStringDelimiter(int character)
     {
         mStringDelimiter = character;
     }
     
     public String getNullValue()
     {
         return mNullValue;
     }
     
     public void setNullValue(String nullString)
     {
         mNullValue = nullString;
     }
     
     // Help methods ------------------------------------------------------------
     
     protected Object readData(DataType dataType) throws IOException
     {
         StringBuffer buf = new StringBuffer(255);
         boolean isUsingDelimiter = dataType!=null && this.useStringDelimiter(dataType);
         boolean isInDelimitedZone = false;
                 
         // MAX_VALUE check added to solve endless loop bugg that occured on
         // some machines. No pattern to determine why and where was identified.
         int ch = (char)in.read();  
         while(ch>0 && ch<Character.MAX_VALUE && (isInDelimitedZone || !(ch==mFieldSeparator || ch==mRecordSeparator)))
         {
             if(isUsingDelimiter && ch==mStringDelimiter)
             {
                 isInDelimitedZone = !isInDelimitedZone;
                 if(isInDelimitedZone && buf.length()>0)
                     buf.append((char)ch);
             }
             else if(!isUsingDelimiter || isInDelimitedZone)
                 buf.append((char)ch);
                 
             ch = (char)in.read();        
         }
         mLastReadSeperator = ch;
         
         // Covert data using the fields data type and return it.
         // Trim non-delimited data to handle poorly manually edited data files
         // and to counteract microsoft double character newlines.
         if(dataType==null || (mNullValue.length()==0 && buf.length()==0) || buf.equals(mNullValue))
             return null;
         else
         {
             String data = buf.toString();
             if(!isUsingDelimiter)
                 data = data.trim();
             return dataType.convertFrom(data);
         }
     }
     
     protected boolean useStringDelimiter(DataType dataType)
     {
         return mStringDelimiter>0 && dataType==DataType.STRING;
     }
     
     private IFieldDescriptor findFieldDescriptor(IEntityDescriptor entityDescriptor, String sourceName)
     {
         for(int j=0; j<entityDescriptor.getFieldCount(); j++)
             if(entityDescriptor.getFieldDescriptor(j).getSourceName().equals(sourceName))
                 return entityDescriptor.getFieldDescriptor(j);
         return null;
     }
 }