/*
    * Copyright 2010-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.testdoc.core.doc;
  
  import java.io.File;
  import java.io.IOException;
  
  import org.apache.commons.io.FilenameUtils;
  
  /**
   * Helps with creating directories and files.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public class FileHelper
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The root directory to which the generated files are written.
     */
    private final File rootDir;
  
    /**
     * The extension for the files being exported by this instance (such as
     * <code>xml</code> or <code>properties</code>).
     */
    private final String fileNameExtension;
  
    /**
     * The flag determines whether an existing file should be overwritten (
     * <code>true</code>) or not (<code>false</code>).
     */
    private final boolean overwrite;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor selecting the option to overwrite.
     *
     * @param rootDir the root directory to which the generated files are written.
     * @param fileNameExtension the extension for the files being exported by this
     *          instance (such as <code>xml</code> or <code>properties</code>).
     */
    public FileHelper(final File rootDir, final String fileNameExtension)
    {
      this(rootDir, fileNameExtension, true);
    }
  
    /**
     * Default constructor.
     *
     * @param rootDir the root directory to which the generated files are written.
     * @param fileNameExtension the extension for the files being exported by this
     *          instance (such as <code>xml</code> or <code>properties</code>).
     * @param overwrite the flag determines whether an existing file should be
     *          overwritten ( <code>true</code>) or not (<code>false</code>).
     */
    public FileHelper(final File rootDir, final String fileNameExtension,
        final boolean overwrite)
    {
      this.rootDir = rootDir;
      this.fileNameExtension = fileNameExtension;
      this.overwrite = overwrite;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    public final File provideFile(final Type uutType) throws IOException
    {
      final File outputFile = createFileRef(uutType, null);
     return provideFile(outputFile);
   }
 
   public final File provideFile(final Type testCaseType, final Type uutType)
     throws IOException
   {
     final File outputFile = createFileRef(testCaseType, uutType);
     return provideFile(outputFile);
   }
 
   private File provideFile(final File outputFile) throws IOException
   {
     final String fileName = outputFile.getName();
     final File dir = outputFile.getParentFile();
     if (outputFile.exists())
     {
       if (overwrite && !outputFile.canWrite())
       {
         throw new IOException("Cannot write test documentation file '"
                               + outputFile.getAbsolutePath() + "'.");
       }
       else if (!overwrite) // TODO: Do we still need this?
       {
         final String baseName = FilenameUtils.getBaseName(fileName);
         final String extension = FilenameUtils.getExtension(fileName);
         File file = new File(dir, baseName + "2." + extension);
         for (int i = 3; file.exists(); i++)
         {
           file = new File(dir, baseName + i + '.' + extension);
         }
         return file;
       }
     }
     return outputFile;
   }
 
   private File createFileRef(final Type testCaseType, final Type uutType)
     throws IOException
   {
     final File dir = provideDirectory(testCaseType);
     final String fileName = createFileName(testCaseType, uutType);
     final File file = new File(dir, fileName);
     return file;
   }
 
   private String createFileName(final Type type1, final Type type2)
   {
     final String stem =
         type1.getTypeName() + (type2 != null ? '-' + type2.getTypeName() : "");
     return stem + '.' + fileNameExtension;
   }
 
   public final File[] listFiles()
   {
     return rootDir.listFiles();
   }
 
   private File provideDirectory(final Type testCaseType) throws IOException
   {
     final File dir = createDirectoryRef(testCaseType);
     try
     {
       return provideDir(dir);
     }
     catch (final IOException e)
     {
       throw new IOException("Cannot create directory '" + dir.getAbsolutePath()
                             + "' for test documentation of UUT type '"
                             + testCaseType + "'.", e);
     }
   }
 
   public static final File provideDir(final File dir) throws IOException
   {
     if (!dir.exists())
     {
       final boolean created = dir.mkdirs();
       if (!created)
       {
         throw new IOException("Cannot create directory '"
                               + dir.getAbsolutePath() + "'.");
       }
     }
     return dir;
   }
 
   public File createDirectoryRef(final Type testCaseType)
   {
     final String packageName = testCaseType.getPackageName();
     final File dir;
     if (packageName != null)
     {
       final String directoryName = packageName.replace('.', '/');
       dir = new File(rootDir, directoryName);
     }
     else
     {
       dir = rootDir;
     }
     return dir;
   }
 
   // --- object basics --------------------------------------------------------
 
 }