/*
    * @(#)$Id: JavafxdocUtil.java 69 2010-05-13 14:21:43Z nderwin $
    *
    * 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.
   * under the License.
   */
  
  package net.sf.jfxdplugin;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  import org.apache.commons.lang.SystemUtils;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.IOUtil;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  
  /**
   * Utility functions for the javafxdoc plugin.
   * <p>
   * Based on the Maven Javadoc Plugin version 2.6.
   *
   * @author Nathan Erwin
   * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
   * @version $Revision: 69 $ $Date: 2010-05-13 10:21:43 -0400 (Thu, 13 May 2010) $
   * @since 1.0
   * @see <a href="http://maven.apache.org/plugins/maven-javadoc-plugin/">
   * http://maven.apache.org/plugins/maven-javadoc-plugin/</a>
   */
  final class JavafxdocUtil {
  
      /**
       * List of source file extensions that can be documented.
       */
      private static final String[] EXTENSIONS = {"fx"};
  
      /**
       * Hidden utility class constructor.
       */
      private JavafxdocUtil() {
      }
  
      /**
       * Convenience method that gets the files to be included in the javafxdoc.
       *
       * @param sourceDirectory the directory where the source files are located
       * @param files the variable that contains the appended filenames of the
       * files to be included in the javafxdoc
       * @param excludePackages the packages to be excluded from the javafxdocs
       */
      static void addFilesFromSource(final List<String> files,
              final File sourceDirectory, final String[] excludePackages) {
          String[] fileList =
                  FileUtils.getFilesFromExtension(sourceDirectory.getPath(),
                  EXTENSIONS);
  
          if (fileList.length != 0) {
              List<String> tmpFiles = JavafxdocUtil.getIncludedFiles(
                      sourceDirectory, fileList, excludePackages);
              files.addAll(tmpFiles);
          }
      }
  
      /**
       * Method that gets all the source files to be excluded from the javafxdoc
       * on the given source paths.
       *
       * @param sourcePaths the path to the source files
       * @param subpackagesList list of subpackages to be included in the
       * javafxdoc
       * @param excludedPackages the package names to be excluded in the
       * javafxdoc
       * @return a List of the source files to be excluded in the generated
       * javafxdoc
       */
      static List<String> getExcludedNames(final List<String> sourcePaths,
              final String[] subpackagesList, final String[] excludedPackages) {
         List<String> excludedNames = new ArrayList<String>();
 
         for (String path : sourcePaths) {
             for (int i = 0; i < subpackagesList.length; i++) {
                 List<String> excludes = JavafxdocUtil.getExcludedPackages(path,
                         excludedPackages);
                 excludedNames.addAll(excludes);
             }
         }
 
         return excludedNames;
     }
 
     /**
      * Method that gets the complete package names (including subpackages) of
      * the packages that were defined in the excludePackageNames parameter.
      *
      * @param sourceDirectory the directory where the source files are located
      * @param excludePackagenames package names to be excluded in the javafxdoc
      * @return a List of the packagenames to be excluded
      */
     static List<String> getExcludedPackages(final String sourceDirectory,
             final String[] excludePackagenames) {
         List<String> files = new ArrayList<String>();
 
         String[] fileList = FileUtils.getFilesFromExtension(sourceDirectory,
                 EXTENSIONS);
 
         for (int i = 0; i < excludePackagenames.length; i++) {
             for (int j = 0; j < fileList.length; j++) {
                 String[] excludeName = excludePackagenames[i].split("[*]");
                 int u = 0;
                 while (u < excludeName.length) {
                     if ((!"".equals(excludeName[u].trim()))
                             && (fileList[j].indexOf(excludeName[u]) != -1)
                             && (sourceDirectory.indexOf(excludeName[u])
                             == -1)) {
                         files.add(fileList[j]);
                     }
                     u++;
                 }
             }
         }
 
         List<String> excluded = new ArrayList<String>();
         for (String file : files) {
             int idx = file.lastIndexOf(File.separatorChar);
             String tmpStr = file.substring(0, idx);
             tmpStr = tmpStr.replace('\\', '/');
             String[] srcSplit =
                     tmpStr.split(sourceDirectory.replace('\\', '/') + '/');
             String excludedPackage = srcSplit[1].replace('/', '.');
 
             if (!excluded.contains(excludedPackage)) {
                 excluded.add(excludedPackage);
             }
         }
 
         return excluded;
     }
 
     /**
      * Method that gets the files or classes that would be included in the
      * javafxdocs using the subpackages parameter.
      *
      * @param sourceDirectory the directory where the source files are located
      * @param fileList the list of all files found in the sourceDirectory
      * @param excludePackages package names to be excluded in the javafxdoc
      * @return a StringBuffer that contains the appended file names of the files
      * to be included in the javafxdoc
      */
     static List<String> getIncludedFiles(final File sourceDirectory,
             final String[] fileList, final String[] excludePackages) {
         List<String> files = new ArrayList<String>();
 
         for (int j = 0; j < fileList.length; j++) {
             boolean include = true;
             for (int k = 0; (include) && (k < excludePackages.length); k++) {
                 // handle wildcards (*) in the excludePackageNames
                 String[] excludeName = excludePackages[k].split("[*]");
 
                 if (excludeName.length == 0) {
                     continue;
                 }
 
                 if (excludeName.length > 1) {
                     int u = 0;
                     while (include && u < excludeName.length) {
                         if ((!"".equals(excludeName[u].trim()))
                                 && (fileList[j].indexOf(excludeName[u])
                                 != -1)) {
                             include = false;
                         }
                         u++;
                     }
                 } else {
                     if (fileList[j].startsWith(sourceDirectory.toString()
                             + File.separatorChar + excludeName[0])) {
                         if (excludeName[0].endsWith(String.valueOf(
                                 File.separatorChar))) {
                             int i = fileList[j].lastIndexOf(File.separatorChar);
                             String packageName =
                                     fileList[j].substring(0, i + 1);
                             File currentPackage = new File(packageName);
                             File excludedPackage = new File(sourceDirectory,
                                     excludeName[0]);
 
                             if (currentPackage.equals(excludedPackage)) {
                                 for (String ext : EXTENSIONS) {
                                     if (fileList[j].substring(i).indexOf("."
                                             + ext)
                                             != -1) {
                                         include = true;
                                     } else {
                                         include = false;
                                     }
                                 }
                             } else {
                                 include = false;
                             }
                         } else {
                             include = false;
                         }
                     }
                 }
             }
 
             if (include) {
                 files.add(JavafxdocUtil.quotedPathArgument(fileList[j]));
             }
         }
 
         return files;
     }
 
     /**
      * Call the Javafxdoc tool and parse its output to find its version.
      *
      * @param javafxdocExe not null file
      * @return the javafxdoc version as float
      * @throws CommandLineException if any
      * @throws FileNotFoundException if javafxdocExe is null, doesn't exist or
      * is not a file
      * @throws IllegalArgumentException if no output was found in the command
      * line
      * @see #parseJavadocVersion(String)
      */
     static float getJavafxdocVersion(final File javafxdocExe) throws
             CommandLineException, FileNotFoundException {
         if ((javafxdocExe == null) || (!javafxdocExe.exists())
                 || (!javafxdocExe.isFile())) {
             throw new FileNotFoundException();
         }
 
         Commandline cmd = new Commandline();
         cmd.setExecutable(javafxdocExe.getAbsolutePath());
         cmd.setWorkingDirectory(javafxdocExe.getParentFile());
         cmd.createArg().setValue("-version");
 
         CommandLineUtils.StringStreamConsumer out =
                 new CommandLineUtils.StringStreamConsumer();
         CommandLineUtils.StringStreamConsumer err =
                 new CommandLineUtils.StringStreamConsumer();
 
         int exitCode = CommandLineUtils.executeCommandLine(cmd, out, err);
 
         if (exitCode != 0) {
             StringBuilder msg = new StringBuilder(exitCode + " - " + err.
                     getOutput());
             msg.append(SystemUtils.LINE_SEPARATOR);
             msg.append(CommandLineUtils.toString(cmd.getCommandline()));
             throw new CommandLineException(msg.toString());
         }
 
         if (StringUtils.isNotEmpty(err.getOutput())) {
             return parseJavadocVersion(err.getOutput());
         } else if (StringUtils.isNotEmpty(out.getOutput())) {
             return parseJavadocVersion(out.getOutput());
         }
 
         throw new IllegalArgumentException();
     }
 
     /**
      * Method that removes the invalid directories in the specified directories.
      * <b>Note</b>: All elements in <code>dirs</code> could be absolute or
      * relative against the project's base directory <code>String</code> path.
      *
      * @param project the current Maven project
      * @param dirs the list of <code>String</code> directory paths that will be
      * validated
      * @return a List of valid <code>String</code> directory absolute paths
      */
     static List<String> pruneDirs(final MavenProject project,
             final List<String> dirs) {
         List<String> pruned = new ArrayList<String>(dirs.size());
 
         for (String dir : dirs) {
             if (null == dir) {
                 continue;
             }
 
             File directory = new File(dir);
             if (!directory.isAbsolute()) {
                 directory = new File(project.getBasedir(), directory.getPath());
             }
 
             if ((directory.isDirectory())
                     && (!pruned.contains(directory.getAbsolutePath()))) {
                 pruned.add(directory.getAbsolutePath());
             }
         }
 
         return pruned;
     }
 
     /**
      * Convenience method to wrap an argument value in single quotes
      * (i.e. <code>'</code>). Intended for values which may contain whitespaces.
      * <br />
      * To prevent javafxdoc errors, the line separators (i.e. <code>\n</code>)
      * are skipped.
      *
      * @param value the argument value
      * @return argument with quote
      */
     static String quotedArgument(final String value) {
         String arg = value;
 
         if (StringUtils.isNotEmpty(arg)) {
             if (arg.indexOf("'") != -1) {
                 arg = StringUtils.replace(arg, "'", "\\'");
             }
             arg = "'" + arg + "'";
 
             // To prevent javafxdoc error
             arg = StringUtils.replace(arg, "\n", " ");
         }
 
         return arg;
     }
 
     /**
      * Convenience method to format a path argument so that it is properly
      * interpreted by the javafxdoc tool. Intended for path values which may
      * contain whitespaces.
      *
      * @param value the argument value
      * @return path argument with quote
      */
     static String quotedPathArgument(final String value) {
         String path = value;
 
         if (StringUtils.isNotEmpty(path)) {
             path = path.replace('\\', '/');
             if (path.indexOf("\'") != -1) {
                 // pass negative number to split in case the string ends with
                 // one or more single quotes so we won't lose them
                 String[] split = path.split("\'", -1);
                 path = "";
 
                 for (int i = 0; i < split.length; i++) {
                     if (i != split.length - 1) {
                         path = path + split[i] + "\\'";
                     } else {
                         path = path + split[i];
                     }
                 }
             }
             path = "'" + path + "'";
         }
 
         return path;
     }
 
     /**
      * Validate if a charset is supported on this platform.
      *
      * @param charsetName the charsetName to be check.
      * @return <code>true</code> if the charset is supported by the JVM,
      * <code>false</code> otherwise.
      */
     static boolean validateEncoding(final String charsetName) {
         if (StringUtils.isEmpty(charsetName)) {
             return false;
         }
 
         OutputStream ost = new ByteArrayOutputStream();
         OutputStreamWriter osw = null;
         try {
             osw = new OutputStreamWriter(ost, charsetName);
         } catch (UnsupportedEncodingException exc) {
             return false;
         } finally {
             IOUtil.close(osw);
         }
         return true;
     }
 
     /**
      * Parse the output for 'javafxdoc -J-version' and return the javafxdoc
      * version recognized.
      *
      * @param output for 'javafxdoc -J-version'
      * @return the version of the javafxdoc for the output.
      * @throws PatternSyntaxException if the output doesn't match with the
      * output pattern
      * <tt>(?s).*?([0-9]+\\.[0-9]+)(\\.([0-9]+))?.*</tt>.
      * @throws IllegalArgumentException if the output is null
      */
     private static float parseJavadocVersion(final String output) {
         if (StringUtils.isEmpty(output)) {
             throw new IllegalArgumentException();
         }
 
         Pattern pattern = Pattern.compile(
                 "(?s).*?([0-9]+\\.[0-9]+)(\\.([0-9]+))?.*");
 
         Matcher matcher = pattern.matcher(output);
         if (!matcher.matches()) {
             throw new PatternSyntaxException("'" + output + "'",
                     pattern.pattern(), pattern.toString().length() - 1);
         }
 
         String version = matcher.group(3);
         if (version == null) {
             version = matcher.group(1);
         } else {
             version = matcher.group(1) + version;
         }
 
         return Float.parseFloat(version);
     }
 }