package org.codehaus.mojo.exec;
   
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.util.ArrayList;
   import java.util.List;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.tools.ant.DirectoryScanner;
  import org.codehaus.plexus.util.StringUtils;
  import org.springframework.core.io.DefaultResourceLoader;
  import org.springframework.core.io.Resource;
  import org.springframework.core.io.ResourceLoader;
  
  /**
   * A plugin for executing the Eclipse java source code formatter
   * 
   * @author Jeff Caddel
   * @goal format
   * @aggregator
   */
  public class EclipseFormatterMojo extends ExecMojo {
      private static final String FS = System.getProperty("file.separator");
  
      /**
       * Binaries representing a Java VM. Default values are "javaw.exe", "java.exe", and "java". This list is searched in
       * order, stopping as soon as one is found.
       * 
       * @parameter
       */
      private String[] javaBinaries = new String[] { "javaw.exe", "java.exe", "java" };
  
      /**
       * Full path to the Eclipse executable binary
       * 
       * @parameter expression="${eclipse.binary}"
       * @required
       */
      private String eclipseBinary;
  
      /**
       * Full path to a Java VM. This gets filled in using the system property "java.home" unless a value is supplied
       * here.
       * 
       * @parameter expression="${eclipse.vm}"
       */
      private String vm;
  
      /**
       * This is the name of the Eclipse application that performs the formatting
       * 
       * @parameter expression="${eclipse.application}" default-value="org.eclipse.jdt.core.JavaCodeFormatter"
       * @required
       */
      private String application;
  
      /**
       * Pointer to an Eclipse "org.eclipse.jdt.core.prefs" file. Supports "classpath:" style notation
       * 
       * @parameter expression="${eclipse.formatterPreferences}" default-value="classpath:eclipse.prefs"
       * @required
       */
      private String formatterPreferences;
  
      /**
       * Any arguments specified here are passed to the Eclipse binary as additional command line arguments. Default
       * values are "-nosplash -verbose"
       * 
       * @parameter
       */
      private String[] eclipseArgs = new String[] { "-nosplash", "-verbose" };
  
      /**
       * Regular expressions for directories that contain Java source code to format. Default values are
       * **/src/main/java and **/src/test/java. The Eclipse formatter will recursively inspect any
       * directories matching these patterns for *.java files
       * 
       * @parameter
       */
      private String[] includes = new String[] { "**/src/main/java", "**/src/test/java" };
  
      /**
       * Regular expressions for directories to exclude from the formatting process.
       * 
       * @parameter
       */
      private String[] excludes = new String[] { "**/.settings", "**/.svn" };
  
      protected List<File> getSourceDirectories() {
          DirectoryScanner scanner = new DirectoryScanner();
          scanner.setBasedir(project.getBasedir());
          scanner.setIncludes(includes);
          scanner.setExcludes(excludes);
          scanner.scan();
          String[] includedDirs = scanner.getIncludedDirectories();
         List<File> dirs = new ArrayList<File>();
         for (String includedDir : includedDirs) {
             File file = new File(project.getBasedir().getAbsolutePath() + FS + includedDir);
             dirs.add(file);
         }
         return dirs;
     }
 
     @Override
     public void execute() throws MojoExecutionException {
         File file = new File(eclipseBinary);
         if (!file.exists()) {
             throw new MojoExecutionException(eclipseBinary + " does not exist");
         }
         getLog().info("Eclipse Location: " + file.getAbsolutePath());
         getLog().info("Java VM: " + getJavaBinary());
         getLog().info("Scanning directory: " + project.getBasedir());
         StringBuilder sb = new StringBuilder();
         for (String include : includes) {
             sb.append(include + " ");
         }
         getLog().info("Includes: " + sb.toString());
         sb = new StringBuilder();
         for (String exclude : excludes) {
             sb.append(exclude + " ");
         }
         getLog().info("Excludes: " + sb.toString());
         List<File> dirs = getSourceDirectories();
 
         if (dirs.size() == 0) {
             getLog().info("No directories containing source code were located");
             return;
         } else {
             getLog().info("Located " + dirs.size() + " source directories:");
             for (File dir : dirs) {
                 getLog().info(dir.getAbsolutePath());
             }
         }
 
         super.setExecutable(quote(eclipseBinary));
         super.setArguments(getEclipseArguments(dirs));
 
         super.execute();
     }
 
     protected String getJavaBinary() throws MojoExecutionException {
         if (!StringUtils.isEmpty(vm)) {
             return vm;
         }
         String javaHome = System.getProperty("java.home");
         String binaryHome = javaHome + FS + "bin";
         for (String binary : javaBinaries) {
             File file = new File(binaryHome + FS + binary);
             if (file.exists()) {
                 return file.getAbsolutePath();
             }
         }
         throw new MojoExecutionException(
                 "No Java VM location was supplied, and we could not locate one using the System property 'java.home'");
     }
 
     protected List<String> getEclipseArguments(List<File> dirs) throws MojoExecutionException {
         List<String> args = new ArrayList<String>();
         args.add("-application");
         args.add(quote(application));
         args.add("-vm");
         args.add(quote(getJavaBinary()));
         args.add("-config");
         args.add(quote(getConfigAbsolutePath()));
         for (String arg : eclipseArgs) {
             addIfNotEmpty(args, arg);
         }
         for (File dir : dirs) {
             args.add(quote(dir.getAbsolutePath()));
         }
         return args;
     }
 
     protected String quote(String s) {
         return '"' + s + '"';
     }
 
     protected String getConfigAbsolutePath() throws MojoExecutionException {
         File file = new File(formatterPreferences);
         if (file.exists()) {
             return file.getAbsolutePath();
         }
         ResourceLoader loader = new DefaultResourceLoader();
         Resource resource = loader.getResource(formatterPreferences);
         if (!resource.exists()) {
             throw new MojoExecutionException("Unable to locate " + formatterPreferences);
         }
         OutputStream out = null;
         InputStream in = null;
         try {
             File temp = File.createTempFile("eclipse.prefs.", null);
             out = new FileOutputStream(temp);
             in = resource.getInputStream();
             IOUtils.copy(in, out);
             return temp.getAbsolutePath();
         } catch (IOException e) {
             throw new MojoExecutionException("Error copying resource " + formatterPreferences, e);
         } finally {
             IOUtils.closeQuietly(out);
             IOUtils.closeQuietly(in);
         }
 
     }
 
     protected void addIfNotEmpty(List<String> list, String s) {
         if (StringUtils.isEmpty(s)) {
             return;
         }
         list.add(s);
     }
 
     public String getEclipseBinary() {
         return eclipseBinary;
     }
 
     public void setEclipseBinary(String eclipseExecutable) {
         this.eclipseBinary = eclipseExecutable;
     }
 
     public String getVm() {
         return vm;
     }
 
     public void setVm(String vm) {
         this.vm = vm;
     }
 
     public String getApplication() {
         return application;
     }
 
     public void setApplication(String application) {
         this.application = application;
     }
 
     public String[] getIncludes() {
         return includes;
     }
 
     public void setIncludes(String[] includes) {
         this.includes = includes;
     }
 
     public String[] getExcludes() {
         return excludes;
     }
 
     public void setExcludes(String[] excludes) {
         this.excludes = excludes;
     }
 
     public String[] getJavaBinaries() {
         return javaBinaries;
     }
 
     public void setJavaBinaries(String[] binaries) {
         this.javaBinaries = binaries;
     }
 
     public String getFormatterPreferences() {
         return formatterPreferences;
     }
 
     public void setFormatterPreferences(String formatterPreferences) {
         this.formatterPreferences = formatterPreferences;
     }
 
     public String[] getEclipseArgs() {
         return eclipseArgs;
     }
 
     public void setEclipseArgs(String[] args) {
         this.eclipseArgs = args;
     }
 
 }