/*
    * Copyright 2008-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.maven.issues.cache;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.eclipse.mylyn.tasks.core.data.TaskData;
  
  /**
   * Base implementation of the {@link TaskDataStore} interface that writes the
   * task data to individual files.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public abstract class AbstractFileTaskDataStore implements TaskDataStore
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Log LOG = LogFactory
        .getLog(AbstractFileTaskDataStore.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The reference to the directory to store the individual task files.
     */
    protected final File persistentStoreDirectory;
  
    /**
     * The extension to append to the created files. This extension usually
     * includes the dot, may be empty, but must not be <code>null</code>.
     */
    protected final String fileNameExtension;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param persistentStoreDirectory the reference to the directory to store the
     *          individual task files.
     * @param fileNameExtension the extension to append to the created files.
     */
    protected AbstractFileTaskDataStore(final File persistentStoreDirectory,
        final String fileNameExtension)
    {
      this.persistentStoreDirectory = persistentStoreDirectory;
      this.fileNameExtension = fileNameExtension;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * {@inheritDoc}
     */
    public TaskData load(final String id) throws PersistenceException
    {
      final File file = createFile(id);
      if (file.exists())
     {
       final TaskData task = readTask(file);
       return task;
     }
     return null;
   }
 
   /**
    * Creates a file for the given identifier.
    *
    * @param id the identifier of the file to be created.
    * @return a file with a name that is unique for the given unique identifier.
    */
   protected File createFile(final String id)
   {
     return new File(this.persistentStoreDirectory, id + fileNameExtension);
   }
 
   /**
    * Reads the task from the given file.
    *
    * @param file the file to read from.
    * @return the task information read from the given file.
    * @throws PersistenceException if the task data cannot be read from the given
    *           file.
    */
   protected TaskData readTask(final File file) throws PersistenceException
   {
     InputStream in = null;
     try
     {
       in = new BufferedInputStream(new FileInputStream(file));
       final TaskData task = readTask(in);
       return task;
     }
     catch (final Exception e)
     {
       final String message =
           "Cannot read task from file '" + file.getAbsolutePath() + "'.";
       LOG.warn(message);
       throw new PersistenceException(message, e);
     }
     finally
     {
       close(file, in);
     }
   }
 
   /**
    * Reads the task from the given input stream.
    *
    * @param inputStream the input stream to read from.
    * @return the task information read from the given input stream.
    * @throws PersistenceException if the task data cannot be read from the given
    *           input stream.
    */
   protected abstract TaskData readTask(InputStream inputStream)
     throws PersistenceException;
 
   /**
    * {@inheritDoc}
    */
   public void persist(final TaskData task) throws PersistenceException
   {
     final String id = task.getTaskId();
     final File file = createFile(id);
     writeTask(file, task);
   }
 
   /**
    * Persists the task to the given file. If the file already exists, it will be
    * overwritten.
    *
    * @param file the file to write to.
    * @param task the task data to store.
    * @throws PersistenceException if the task data cannot be written to the
    *           given file.
    */
   protected void writeTask(final File file, final TaskData task)
     throws PersistenceException
   {
     OutputStream out = null;
     try
     {
       out = new BufferedOutputStream(new FileOutputStream(file));
       writeTask(out, task);
     }
     catch (final FileNotFoundException e)
     {
       final String message =
           "Cannot persist task data with ID '" + task.getTaskId()
               + "' to file '" + file.getAbsolutePath() + "'.";
       LOG.warn(message, e);
       throw new PersistenceException(message, e);
     }
     finally
     {
       close(file, out);
     }
   }
 
   /**
    * Closes the given closeable and logs problems at error level to the log.
    *
    * @param closeable the closeable to close.
    */
   protected static void close(final Closeable closeable)
   {
     close(null, closeable);
   }
 
   /**
    * Closes the given closeable and logs problems at error level to the log.
    *
    * @param file the name of the file for logging.
    * @param closeable the closeable to close.
    */
   protected static void close(final File file, final Closeable closeable)
   {
     if (closeable != null)
     {
       try
       {
         closeable.close();
       }
       catch (final IOException e)
       {
         // Ignore
         if (LOG.isErrorEnabled())
         {
           final String message =
               file != null ? "Cannot close stream to file '" + file
                              + "'. Continue..."
                   : "Cannot close stream. Continue...";
           LOG.error(message, e);
         }
       }
     }
   }
 
   /**
    * Persists the task to the given output stream.
    *
    * @param outputStream the output stream to write to.
    * @param task the task data to store.
    * @throws PersistenceException if the task data cannot be written to the
    *           given output stream.
    */
   protected abstract void writeTask(OutputStream outputStream, TaskData task)
     throws PersistenceException;
 
   // --- object basics --------------------------------------------------------
 
 }