/* (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.service;
  
  
  import java.io.*;
  
  import org.caleigo.core.*;
  import org.caleigo.toolkit.log.*;
  
  /*** TextFileDataService provides a simple extension of the MemoryDataService
   * that stores the data entities in text files in a database file-catalog.
   *
   * Note that the class is not suitable to store sensitive data. The class
   * does not verify foreign keys and should only be used for temporary
   * storage and/or for test or demonstration purposes.
   *
   * @author  Dennis Zikovic
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2003-01-07  Dennis Zikovic    Creation
   */
  public class TextFileDataService extends MemoryDataService
  {
      // Constants ---------------------------------------------------------------
      private static final String NULL = "<NULL>";
      
      // Data members ------------------------------------------------------------
      private File mDirectoryFile;
      
      private int mFieldSeparator = ';';
      private int mRecordSeparator = '\n';
      private int mStringDelimiter = '"';
      
      // Constructors ------------------------------------------------------------
  	public TextFileDataService(IDataSourceDescriptor dataSourceDescriptor, String dbDirectoryPath) 
  	{
  		this(dataSourceDescriptor, dataSourceDescriptor.getSourceName(), dbDirectoryPath);
  	}
      
      public TextFileDataService(IDataSourceDescriptor dataSourceDescriptor, Object serviceIdentity, String dbDirectoryPath) 
      {
          super(dataSourceDescriptor, serviceIdentity);
          
          // Create root directory file.
          try
          {
              mDirectoryFile = new File(dbDirectoryPath);
              
              // Try to create directory if it doesn't exist.
              if(!mDirectoryFile.exists())
                  mDirectoryFile.mkdir();
              
              // Check read/write access.
              if(mDirectoryFile==null)
                  Log.printError(this, "Failed to initialize FileDataService, path not found \""+dbDirectoryPath+"\"!");
              else if(!mDirectoryFile.canRead() || !mDirectoryFile.canWrite())
              {
                  Log.printError(this, "Failed to initialize FileDataService, no read/write access on \""+dbDirectoryPath+"\"!");
                  mDirectoryFile = null;
              }
              else
                  Log.print(this, "FileDataService initialized on path \""+dbDirectoryPath+"\".");
          }
          catch(Exception e)
          {
              Log.printError(this, "Failed to initialize FileDataService for path \""+dbDirectoryPath+"\"!", e);
              mDirectoryFile = null;
          }        
      }
      
      // Superclass overrides ----------------------------------------------------
      public boolean ping()
      {
          return mDirectoryFile!=null;
      }
      
      protected ISelection loadTableSelection(IEntityDescriptor entityDescriptor)
      {
         ISelection dbSelection = null;
 
         try
         {            
             File entityFile = new File(mDirectoryFile, entityDescriptor.getCodeName()+".tdb");
             Log.print(this, "Loading table selection from: \""+ entityFile.getAbsolutePath()+"\"");
             if(entityFile.exists())
             {
                 // Create buffered file reader.
                 Reader fileReader = new FileReader(entityFile);
                 fileReader = new BufferedReader(fileReader, 10000);
                 
                 // Wrap file reader in entity reader.
                 EntityReader entityReader = new EntityReader(fileReader, mFieldSeparator, mRecordSeparator);
                 entityReader.setStringDelimiter(mStringDelimiter);
                 
                 // Read table selection.
                 dbSelection = entityReader.readMappedSelection(entityDescriptor);  
                 
                 // Close reader.
                 fileReader.close();    
             }   
             else
                 dbSelection = new Selection(entityDescriptor);
             Log.print(this, "Loading completed. "+(dbSelection!=null ? dbSelection.size() : 0)+" entities loaded.");
         }
         catch(Exception e)
         {
             Log.printError(this, "Failed to load complete table selection: "+ entityDescriptor, e);
         }
         
         return dbSelection;
     }
     
     protected void storeTableSelection(ISelection dbSelection)
     {
         try
         {
             // Create buffered file writer.
             File entityFile = new File(mDirectoryFile, dbSelection.getEntityDescriptor().getCodeName()+".tdb");
             Log.print(this, "Storing table selection to: \""+ entityFile.getAbsolutePath()+"\"");
             Writer fileWriter = new FileWriter(entityFile);
             fileWriter = new BufferedWriter(fileWriter, 10000);
             
             // Wrap file reader in entity writer.
             EntityWriter entityWriter = new EntityWriter(fileWriter, mFieldSeparator, mRecordSeparator);
             entityWriter.setStringDelimiter(mStringDelimiter);
 
             // Write selection.
             entityWriter.writeMappedSelection(dbSelection);
             
             // Flush and close writers.
             entityWriter.flush();
             entityWriter.close();
             
             Log.print(this, "Store completed. "+(dbSelection!=null ? dbSelection.size() : 0)+" entities stored.");
         }
         catch(Exception e)
         {
             Log.printError(this, "Failed to store table selection: "+ dbSelection.getEntityDescriptor(), e);
         }
     }    
         
     // 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 File getDirectoryFile()
     {
         return mDirectoryFile;
     }
 }