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;

 import static org.codehaus.plexus.util.StringUtils.isEmpty;

 /**

  * 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 value is

          * **/src/main/java. The Eclipse formatter will recursively inspect any directories matching these

          * patterns for *.java files

          * 

          * @parameter

          */

         private String[] includes = new String[] { "**/src/main/java" };

         /**

          * Regular expressions for directories to exclude from the process that scans for *.java files

          * 

          * @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;

         }

         protected void showDirs(List<File> srcDirs) {

                 getLog().info("Located " + srcDirs.size() + " source directories:");

                 for (File dir : srcDirs) {

                         getLog().info(dir.getAbsolutePath());

                 }

         }

         protected void showConfig(File eclipseBinary, File javaBinary) {

                 getLog().info("Eclipse Location: " + eclipseBinary.getAbsolutePath());

                 getLog().info("Java VM: " + javaBinary.getAbsolutePath());

                 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());

         }

         @Override

         public void execute() throws MojoExecutionException {

                 if (!fileExists(eclipseBinary)) {

                         throw new MojoExecutionException(eclipseBinary + " does not exist");

                 }

                 File eclipseBinaryFile = new File(eclipseBinary);

                 File javaBinary = getJavaBinary();

                 showConfig(eclipseBinaryFile, javaBinary);

                 List<File> dirs = getSourceDirectories();

                 if (dirs.size() == 0) {

                         getLog().info("No directories containing source code were located");

                         return;

                 }

                 showDirs(dirs);

                 super.setExecutable(eclipseBinaryFile.getAbsolutePath());

                 super.setArguments(getEclipseArguments(javaBinary, dirs));

                 super.execute();

         }

         protected boolean fileExists(String filename) {

                 return new File(filename).exists();

         }

         protected File getJavaBinary() throws MojoExecutionException {

                 // They provided us with a VM, and we found a file in the location they specified

                 if (!isEmpty(vm) && fileExists(vm)) {

                         return new File(vm);

                 }

                 // They asked us to use a specific VM, but it doesn't exist

                 if (!isEmpty(vm) && !fileExists(vm)) {

                         throw new MojoExecutionException(vm + " does not exist");

                 }

                 // They did not specify a VM, attempt to locate one

                 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;

                         }

                 }

                 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(File javaBinary, List<File> dirs) throws MojoExecutionException {

                 List<String> args = new ArrayList<String>();

                 args.add("-application");

                 args.add(application);

                 args.add("-vm");

                 args.add(javaBinary.getAbsolutePath());

                 args.add("-config");

                 args.add(getConfigAbsolutePath());

                 for (String arg : eclipseArgs) {

                         addIfNotEmpty(args, arg);

                 }

                 for (File dir : dirs) {

                         args.add(dir.getAbsolutePath());

                 }

                 return args;

         }

         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);

                         temp.deleteOnExit();

                         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;

         }

 }