/*
    * Copyright 2007-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.exceptions.util;
  
  import java.io.File;
  
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.tools.ant.DirectoryScanner;
  
  import de.smartics.exceptions.report.scan.ScannerFactory;
  
  /**
   * Utilities to work on file names and files.
   */
  public final class FileNameUtils
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Utility class pattern.
     */
    private FileNameUtils()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Checks if the given root refers to an archive or not. Simply the file
     * extension is checked. Accessibility et al. is not considered.
     *
     * @param root the root to check.
     * @return <code>true</code> if root refers to an archive file,
     *         <code>false</code> otherwise.
     * @throws NullPointerException if <code>root</code> is <code>null</code>.
     */
    public static boolean isArchive(final String root)
      throws NullPointerException
    {
      return root.endsWith(".jar") || root.endsWith(".zip");
    }
  
    /**
     * Creates package names from directory files found by the given scanner.
     *
     * @param log the logger to log at debug level. No logging if <code>log</code>
     *          is <code>null</code>.
     * @param rootDir the root directory to create a scanner on.
     * @param scannerFactory the factory to create the scanner with the given
     *          <code>rootDir</code>.
     * @return the package list. Package names are separated by a colon (
     *         <code>:</code>) or the empty string if the root directory is not
     *         accessible (will be logged at debug level if <code>log</code> is
     *         not <code>null</code>.
     * @throws NullPointerException if the <code>rootDir</code> or
     *           <code>scannerFactory</code> is <code>null</code>.
     */
    public static String createPackageNames(final Log log, final String rootDir,
        final ScannerFactory scannerFactory) throws NullPointerException
    {
      if (!isRootAccessible(rootDir))
      {
        if (log != null && log.isDebugEnabled())
        {
          log.debug("Root '" + rootDir + "' does not exist. Skipping...");
        }
        return "";
      }
 
     final DirectoryScanner scanner = scannerFactory.createScanner(rootDir);
     final String[] dirs = scanner.getIncludedDirectories();
     final StringBuilder buffer = new StringBuilder();
     for (String dir : dirs)
     {
       if (!containsJavaFiles(rootDir, dir))
       {
         continue;
       }
 
       final String packageName = internalCreatePackageName(dir);
       if (StringUtils.isNotBlank(packageName))
       {
         buffer.append(packageName).append(':');
       }
     }
     final String packageNames = StringUtils.chop(buffer.toString());
     return packageNames;
   }
 
   /**
    * Checks if the given directory contains files with the extension
    * <code>java</code>.
    *
    * @param rootDir the path to the root directory the <code>dir</code> is
    *          relative to.
    * @param dir the directory within <code>rootDir</code> to check if it
    *          contains Java files.
    * @return <code>true</code> if the directory contains Java files (or is an
    *         entry in an archive), <code>false</code> otherwise.
    * @todo Currently, if <code>rootDir</code> points to an
    *       {@link #isArchive(String) archive}, this method always returns
    *       <code>true</code>.
    */
   private static boolean containsJavaFiles(final String rootDir,
       final String dir)
   {
     if (isArchive(rootDir))
     {
       // TODO: We make life simple for the moment, assuming, that there are no
       // empty packages in an archive file. The answer of this method may be
       // plain wrong, but currently does no harm.
       return true;
     }
     else
     {
       final File[] files = new File(rootDir, dir).listFiles();
       if (files != null)
       {
         for (File file : files)
         {
           if (file.isFile()
               && FilenameUtils.getExtension(file.getName()).equals("java"))
           {
             return true;
           }
         }
       }
       else
       {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Calls {@link #createPackageName(String)} and maps exceptions to
    * <code>null</code>.
    *
    * @param dirName the name of the directory that contains classes of a
    *          package. It is expected that the directory is relative to the
    *          source root directory.
    * @return the package name for the directory or <code>null</code> if the name
    *         is not a valid package name.
    */
   private static String internalCreatePackageName(final String dirName)
   {
     try
     {
       return createPackageName(dirName);
     }
     catch (final Exception e)
     {
       return null;
     }
   }
 
   /**
    * Creates the package name for the given directory.
    *
    * @param dirName the name of the directory that contains classes of a
    *          package. It is expected that the directory is relative to the
    *          source root directory.
    * @return the package name for the directory.
    * @throws NullPointerException if <code>dirName</code> is <code>null</code>.
    * @throws IllegalArgumentException if the directory is not valid as a package
    *           directory or if <code>dirName</code> is blank.
    */
   public static String createPackageName(final String dirName)
     throws IllegalArgumentException, NullPointerException
   {
     if (dirName != null && StringUtils.isBlank(dirName))
     {
       // If dirName is null, the NPE will be thrown later.
       throw new IllegalArgumentException("Directory name must not be blank.");
     }
     if (dirName.indexOf('.') != -1)
     {
       throw new IllegalArgumentException(
           "Directory name must not contain dots.");
     }
 
     final String normalizedPath = normalizePath(dirName);
     if (!FilterUtils.isValidJavaPackageDirPath(normalizedPath))
     {
       throw new IllegalArgumentException("Invalid path for packages: "
                                          + dirName);
     }
     final String packageName =
         StringUtils.replaceChars(normalizedPath, "/\\", "..");
     return packageName;
   }
 
   /**
    * Returns the normalized path where duplicate slashes are removed. If there
    * is a slash (or backslash) in front, it is removed, too.
    *
    * @param path the path to normalize.
    * @return the normalized path.
    */
   public static String normalizePath(final String path)
   {
     final File file = new File(path);
     final String normalized = file.getPath();
     if (normalized.length() > 0)
     {
       final char first = normalized.charAt(0);
       if (first == '\\' || first == '/')
       {
         return normalized.substring(1);
       }
     }
     return normalized;
   }
 
   /**
    * Checks if <code>root</code> points to a directory of file that is existing
    * and readable.
    *
    * @param root the directory or file name to check.
    * @return <code>true</code> if the directory of file exists,
    *         <code>false</code> otherwise.
    * @throws NullPointerException if the <code>root</code> argument is
    *           <code>null</code>.
    */
   public static boolean isRootAccessible(final String root)
     throws NullPointerException
   {
     final File file = new File(root);
     return file.canRead();
   }
 
   // --- object basics --------------------------------------------------------
 
 }