package org.apache.maven.plugin;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.toolchain.Toolchain;
  import org.apache.maven.toolchain.ToolchainManager;
  import org.codehaus.plexus.compiler.Compiler;
  import org.codehaus.plexus.compiler.CompilerConfiguration;
  import org.codehaus.plexus.compiler.CompilerError;
  import org.codehaus.plexus.compiler.CompilerException;
  import org.codehaus.plexus.compiler.CompilerOutputStyle;
  import org.codehaus.plexus.compiler.manager.CompilerManager;
  import org.codehaus.plexus.compiler.manager.NoSuchCompilerException;
  import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
  import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
  import org.codehaus.plexus.compiler.util.scan.mapping.SingleTargetSourceMapping;
  import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
  import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
  import org.codehaus.plexus.util.ReaderFactory;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  /**
   * TODO: At least one step could be optimized, currently the plugin will do two
   * scans of all the source code if the compiler has to have the entire set of
   * sources. This is currently the case for at least the C# compiler and most
   * likely all the other .NET compilers too.
   *
   * @author others
   * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>
   * @version $Id: AbstractCompilerMojo.html 816619 2012-05-08 13:09:26Z hboutemy $
   * @since 2.0
   */
  public abstract class AbstractCompilerMojo
      extends AbstractMojo
  {
      // ----------------------------------------------------------------------
      // Configurables
      // ----------------------------------------------------------------------
  
      /**
       * Indicates whether the build will continue even if there are compilation errors.
       *
       * @parameter expression="${maven.compiler.failOnError}" default-value="true"
       * @since 2.0.2
       */
      private boolean failOnError = true;
  
      /**
       * Set to <code>true</code> to include debugging information in the compiled class files.
       *
       * @parameter expression="${maven.compiler.debug}" default-value="true"
       */
      private boolean debug = true;
  
      /**
       * Set to <code>true</code> to show messages about what the compiler is doing.
       *
       * @parameter expression="${maven.compiler.verbose}" default-value="false"
       */
      private boolean verbose;
  
      /**
       * Sets whether to show source locations where deprecated APIs are used.
       *
       * @parameter expression="${maven.compiler.showDeprecation}" default-value="false"
       */
      private boolean showDeprecation;
  
      /**
       * Set to <code>true</code> to optimize the compiled code using the compiler's optimization methods.
       *
       * @parameter expression="${maven.compiler.optimize}" default-value="false"
       */
     private boolean optimize;
 
     /**
      * Set to <code>true</code> to show compilation warnings.
      *
      * @parameter expression="${maven.compiler.showWarnings}" default-value="false"
      */
     private boolean showWarnings;
 
     /**
      * The -source argument for the Java compiler.
      *
      * @parameter expression="${maven.compiler.source}" default-value="1.5"
      */
     protected String source;
 
     /**
      * The -target argument for the Java compiler.
      *
      * @parameter expression="${maven.compiler.target}" default-value="1.5"
      */
     protected String target;
 
     /**
      * The -encoding argument for the Java compiler.
      *
      * @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
      * @since 2.1
      */
     private String encoding;
 
     /**
      * Sets the granularity in milliseconds of the last modification
      * date for testing whether a source needs recompilation.
      *
      * @parameter expression="${lastModGranularityMs}" default-value="0"
      */
     private int staleMillis;
 
     /**
      * The compiler id of the compiler to use. See this
      * <a href="non-javac-compilers.html">guide</a> for more information.
      *
      * @parameter expression="${maven.compiler.compilerId}" default-value="javac"
      */
     private String compilerId;
 
     /**
      * Version of the compiler to use, ex. "1.3", "1.5", if {@link #fork} is set to <code>true</code>.
      *
      * @parameter expression="${maven.compiler.compilerVersion}"
      */
     private String compilerVersion;
 
     /**
      * Allows running the compiler in a separate process.
      * If <code>false</code> it uses the built in compiler, while if <code>true</code> it will use an executable.
      *
      * @parameter expression="${maven.compiler.fork}" default-value="false"
      */
     private boolean fork;
 
     /**
      * Initial size, in megabytes, of the memory allocation pool, ex. "64", "64m"
      * if {@link #fork} is set to <code>true</code>.
      *
      * @parameter expression="${maven.compiler.meminitial}"
      * @since 2.0.1
      */
     private String meminitial;
 
     /**
      * Sets the maximum size, in megabytes, of the memory allocation pool, ex. "128", "128m"
      * if {@link #fork} is set to <code>true</code>.
      *
      * @parameter expression="${maven.compiler.maxmem}"
      * @since 2.0.1
      */
     private String maxmem;
 
     /**
      * Sets the executable of the compiler to use when {@link #fork} is <code>true</code>.
      *
      * @parameter expression="${maven.compiler.executable}"
      */
     private String executable;
 
     /**
      * <p>
      * Sets whether annotation processing is performed or not. Only applies to JDK 1.6+
      * If not set, both compilation and annotation processing are performed at the same time.
      * </p>
      * <p>
      * Allowed values are:
      * none - no annotation processing is performed.
      * only - only annotation processing is done, no compilation.
      * </p>
      *
      * @parameter
      * @since 2.2
      */
     private String proc;
 
     /**
      * <p>
      * Names of annotation processors to run. Only applies to JDK 1.6+
      * If not set, the default annotation processors discovery process applies.
      * </p>
      *
      * @parameter
      * @since 2.2
      */
     private String[] annotationProcessors;
 
     /**
      * <p>
      * Sets the arguments to be passed to the compiler (prepending a dash) if {@link #fork} is set to <code>true</code>.
      * </p>
      * <p>
      * This is because the list of valid arguments passed to a Java compiler
      * varies based on the compiler version.
      * </p>
      * <p>
      * To pass <code>-Xmaxerrs 1000 -Xlint -Xlint:-path -Averbose=true</code> you should include the following:
      * </p>
      * <pre>
      * &lt;compilerArguments&gt;
      *   &lt;Xmaxerrs&gt;1000&lt;/Xmaxerrs&gt;
      *   &lt;Xlint/&gt;
      *   &lt;Xlint:-path/&gt;
      *   &lt;Averbose&gt;true&lt;/Averbose&gt;
      * &lt;/compilerArguments&gt;
      * </pre>
      *
      * @parameter
      * @since 2.0.1
      */
     protected Map<String, String> compilerArguments;
 
     /**
      * <p>
      * Sets the unformatted single argument string to be passed to the compiler if {@link #fork} is set to <code>true</code>.
      * To pass multiple arguments such as <code>-Xmaxerrs 1000</code> (which are actually two arguments) you have to use {@link #compilerArguments}.
      * </p>
      * <p>
      * This is because the list of valid arguments passed to a Java compiler
      * varies based on the compiler version.
      * </p>
      *
      * @parameter
      */
     protected String compilerArgument;
 
     /**
      * Sets the name of the output file when compiling a set of
      * sources to a single file.
      *
      * @parameter expression="${project.build.finalName}"
      */
     private String outputFileName;
 
     /**
      * Keyword list to be appended to the -g  command-line switch. Legal values are none or a comma-separated list of the following keywords: lines, vars, and source.
      * If debuglevel is not specified, by default, nothing will be appended to -g. If debug is not turned on, this attribute will be ignored.
      *
      * @parameter expression="${maven.compiler.debuglevel}"
      * @since 2.1
      */
     private String debuglevel;
 
     /**
      * @component
      */
     private ToolchainManager toolchainManager;
 
     // ----------------------------------------------------------------------
     // Read-only parameters
     // ----------------------------------------------------------------------
 
     /**
      * The directory to run the compiler from if fork is true.
      *
      * @parameter default-value="${basedir}"
      * @required
      * @readonly
      */
     private File basedir;
 
     /**
      * The target directory of the compiler if fork is true.
      *
      * @parameter default-value="${project.build.directory}"
      * @required
      * @readonly
      */
     private File buildDirectory;
 
     /**
      * Plexus compiler manager.
      *
      * @component
      */
     private CompilerManager compilerManager;
 
     /**
      * The current build session instance. This is used for
      * toolchain manager API calls.
      *
      * @parameter default-value="${session}"
      * @required
      * @readonly
      */
     private MavenSession session;
 
     protected abstract SourceInclusionScanner getSourceInclusionScanner( int staleMillis );
 
     protected abstract SourceInclusionScanner getSourceInclusionScanner( String inputFileEnding );
 
     protected abstract List<String> getClasspathElements();
 
     protected abstract List<String> getCompileSourceRoots();
 
     protected abstract File getOutputDirectory();
 
     protected abstract String getSource();
 
     protected abstract String getTarget();
 
     protected abstract String getCompilerArgument();
 
     protected abstract Map<String, String> getCompilerArguments();
 
     protected abstract File getGeneratedSourcesDirectory();
 
     @SuppressWarnings( "unchecked" )
     public void execute()
         throws MojoExecutionException, CompilationFailureException
     {
         // ----------------------------------------------------------------------
         // Look up the compiler. This is done before other code than can
         // cause the mojo to return before the lookup is done possibly resulting
         // in misconfigured POMs still building.
         // ----------------------------------------------------------------------
 
         Compiler compiler;
 
         getLog().debug( "Using compiler '" + compilerId + "'." );
 
         try
         {
             compiler = compilerManager.getCompiler( compilerId );
         }
         catch ( NoSuchCompilerException e )
         {
             throw new MojoExecutionException( "No such compiler '" + e.getCompilerId() + "'." );
         }
 
         //-----------toolchains start here ----------------------------------
         //use the compilerId as identifier for toolchains as well.
         Toolchain tc = getToolchain();
         if ( tc != null )
         {
             getLog().info( "Toolchain in compiler-plugin: " + tc );
             if ( executable != null )
             {
                 getLog().warn( "Toolchains are ignored, 'executable' parameter is set to " + executable );
             }
             else
             {
                 fork = true;
                 //TODO somehow shaky dependency between compilerId and tool executable.
                 executable = tc.findTool( compilerId );
             }
         }
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         List<String> compileSourceRoots = removeEmptyCompileSourceRoots( getCompileSourceRoots() );
 
         if ( compileSourceRoots.isEmpty() )
         {
             getLog().info( "No sources to compile" );
 
             return;
         }
 
         if ( getLog().isDebugEnabled() )
         {
             getLog().debug( "Source directories: " + compileSourceRoots.toString().replace( ',', '\n' ) );
             getLog().debug( "Classpath: " + getClasspathElements().toString().replace( ',', '\n' ) );
             getLog().debug( "Output directory: " + getOutputDirectory() );
         }
 
         // ----------------------------------------------------------------------
         // Create the compiler configuration
         // ----------------------------------------------------------------------
 
         CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
 
         compilerConfiguration.setOutputLocation( getOutputDirectory().getAbsolutePath() );
 
         compilerConfiguration.setClasspathEntries( getClasspathElements() );
 
         compilerConfiguration.setSourceLocations( compileSourceRoots );
 
         compilerConfiguration.setOptimize( optimize );
 
         compilerConfiguration.setDebug( debug );
 
         if ( debug && StringUtils.isNotEmpty( debuglevel ) )
         {
             String[] split = StringUtils.split( debuglevel, "," );
             for ( int i = 0; i < split.length; i++ )
             {
                 if ( !( split[i].equalsIgnoreCase( "none" ) || split[i].equalsIgnoreCase( "lines" )
                     || split[i].equalsIgnoreCase( "vars" ) || split[i].equalsIgnoreCase( "source" ) ) )
                 {
                     throw new IllegalArgumentException( "The specified debug level: '" + split[i] + "' is unsupported. "
                                                             + "Legal values are 'none', 'lines', 'vars', and 'source'." );
                 }
             }
             compilerConfiguration.setDebugLevel( debuglevel );
         }
 
         compilerConfiguration.setVerbose( verbose );
 
         compilerConfiguration.setShowWarnings( showWarnings );
 
         compilerConfiguration.setShowDeprecation( showDeprecation );
 
         compilerConfiguration.setSourceVersion( getSource() );
 
         compilerConfiguration.setTargetVersion( getTarget() );
 
         compilerConfiguration.setProc( proc );
 
         compilerConfiguration.setGeneratedSourcesDirectory( getGeneratedSourcesDirectory() );
 
         compilerConfiguration.setAnnotationProcessors( annotationProcessors );
 
         compilerConfiguration.setSourceEncoding( encoding );
 
         Map<String, String> effectiveCompilerArguments = getCompilerArguments();
 
         String effectiveCompilerArgument = getCompilerArgument();
 
         if ( ( effectiveCompilerArguments != null ) || ( effectiveCompilerArgument != null ) )
         {
             LinkedHashMap<String, String> cplrArgsCopy = new LinkedHashMap<String, String>();
             if ( effectiveCompilerArguments != null )
             {
                 for ( Map.Entry<String, String> me : effectiveCompilerArguments.entrySet() )
                 {
                     String key = me.getKey();
                     String value = me.getValue();
                     if ( !key.startsWith( "-" ) )
                     {
                         key = "-" + key;
                     }
 
                     if ( key.startsWith( "-A" ) && StringUtils.isNotEmpty( value ) )
                     {
                         cplrArgsCopy.put( key + "=" + value, null );
                     }
                     else
                     {
                         cplrArgsCopy.put( key, value );
                     }
                 }
             }
             if ( !StringUtils.isEmpty( effectiveCompilerArgument ) )
             {
                 cplrArgsCopy.put( effectiveCompilerArgument, null );
             }
             compilerConfiguration.setCustomCompilerArguments( cplrArgsCopy );
         }
 
         compilerConfiguration.setFork( fork );
 
         if ( fork )
         {
             if ( !StringUtils.isEmpty( meminitial ) )
             {
                 String value = getMemoryValue( meminitial );
 
                 if ( value != null )
                 {
                     compilerConfiguration.setMeminitial( value );
                 }
                 else
                 {
                     getLog().info( "Invalid value for meminitial '" + meminitial + "'. Ignoring this option." );
                 }
             }
 
             if ( !StringUtils.isEmpty( maxmem ) )
             {
                 String value = getMemoryValue( maxmem );
 
                 if ( value != null )
                 {
                     compilerConfiguration.setMaxmem( value );
                 }
                 else
                 {
                     getLog().info( "Invalid value for maxmem '" + maxmem + "'. Ignoring this option." );
                 }
             }
         }
 
         compilerConfiguration.setExecutable( executable );
 
         compilerConfiguration.setWorkingDirectory( basedir );
 
         compilerConfiguration.setCompilerVersion( compilerVersion );
 
         compilerConfiguration.setBuildDirectory( buildDirectory );
 
         compilerConfiguration.setOutputFileName( outputFileName );
 
         // TODO: have an option to always compile (without need to clean)
         Set<File> staleSources;
 
         boolean canUpdateTarget;
 
         try
         {
             staleSources =
                 computeStaleSources( compilerConfiguration, compiler, getSourceInclusionScanner( staleMillis ) );
 
             canUpdateTarget = compiler.canUpdateTarget( compilerConfiguration );
 
             if ( compiler.getCompilerOutputStyle().equals( CompilerOutputStyle.ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES )
                 && !canUpdateTarget )
             {
                 getLog().info( "RESCANNING!" );
                 // TODO: This second scan for source files is sub-optimal
                 String inputFileEnding = compiler.getInputFileEnding( compilerConfiguration );
 
                 Set<File> sources = computeStaleSources( compilerConfiguration, compiler,
                                                          getSourceInclusionScanner( inputFileEnding ) );
 
                 compilerConfiguration.setSourceFiles( sources );
             }
             else
             {
                 compilerConfiguration.setSourceFiles( staleSources );
             }
         }
         catch ( CompilerException e )
         {
             throw new MojoExecutionException( "Error while computing stale sources.", e );
         }
 
         if ( staleSources.isEmpty() )
         {
             getLog().info( "Nothing to compile - all classes are up to date" );
 
             return;
         }
 
         // ----------------------------------------------------------------------
         // Dump configuration
         // ----------------------------------------------------------------------
 
         if ( getLog().isDebugEnabled() )
         {
             getLog().debug( "Classpath:" );
 
             for ( String s : getClasspathElements() )
             {
                 getLog().debug( " " + s );
             }
 
             getLog().debug( "Source roots:" );
 
             for ( String root : getCompileSourceRoots() )
             {
                 getLog().debug( " " + root );
             }
 
             try
             {
                 if ( fork )
                 {
                     if ( compilerConfiguration.getExecutable() != null )
                     {
                         getLog().debug( "Excutable: " );
                         getLog().debug( " " + compilerConfiguration.getExecutable() );
                     }
                 }
 
                 String[] cl = compiler.createCommandLine( compilerConfiguration );
                 if ( cl != null && cl.length > 0 )
                 {
                     StringBuilder sb = new StringBuilder();
                     sb.append( cl[0] );
                     for ( int i = 1; i < cl.length; i++ )
                     {
                         sb.append( " " );
                         sb.append( cl[i] );
                     }
                     getLog().debug( "Command line options:" );
                     getLog().debug( sb );
                 }
             }
             catch ( CompilerException ce )
             {
                 getLog().debug( ce );
             }
         }
 
         // ----------------------------------------------------------------------
         // Compile!
         // ----------------------------------------------------------------------
 
         if ( StringUtils.isEmpty( compilerConfiguration.getSourceEncoding() ) )
         {
             getLog().warn( "File encoding has not been set, using platform encoding " + ReaderFactory.FILE_ENCODING
                                + ", i.e. build is platform dependent!" );
         }
 
         List<CompilerError> messages;
 
         try
         {
             messages = compiler.compile( compilerConfiguration );
         }
         catch ( Exception e )
         {
             // TODO: don't catch Exception
             throw new MojoExecutionException( "Fatal error compiling", e );
         }
 
         List<CompilerError> warnings = new ArrayList<CompilerError>();
         List<CompilerError> errors = new ArrayList<CompilerError>();
         if ( messages != null )
         {
             for ( CompilerError message : messages )
             {
                 if ( message.isError() )
                 {
                     errors.add( message );
                 }
                 else
                 {
                     warnings.add( message );
                 }
             }
         }
 
         if ( failOnError && !errors.isEmpty() )
         {
             if ( !warnings.isEmpty() )
             {
                 getLog().info( "-------------------------------------------------------------" );
                 getLog().warn( "COMPILATION WARNING : " );
                 getLog().info( "-------------------------------------------------------------" );
                 for ( CompilerError warning : warnings )
                 {
                     getLog().warn( warning.toString() );
                 }
                 getLog().info( warnings.size() + ( ( warnings.size() > 1 ) ? " warnings " : " warning" ) );
                 getLog().info( "-------------------------------------------------------------" );
             }
 
             getLog().info( "-------------------------------------------------------------" );
             getLog().error( "COMPILATION ERROR : " );
             getLog().info( "-------------------------------------------------------------" );
 
             for ( CompilerError error : errors )
             {
                 getLog().error( error.toString() );
             }
             getLog().info( errors.size() + ( ( errors.size() > 1 ) ? " errors " : " error" ) );
             getLog().info( "-------------------------------------------------------------" );
 
             throw new CompilationFailureException( errors );
         }
         else
         {
             for ( CompilerError message : messages )
             {
                 getLog().warn( message.toString() );
             }
         }
     }
 
     private String getMemoryValue( String setting )
     {
         String value = null;
 
         // Allow '128' or '128m'
         if ( isDigits( setting ) )
         {
             value = setting + "m";
         }
         else
         {
             if ( ( isDigits( setting.substring( 0, setting.length() - 1 ) ) ) && ( setting.toLowerCase().endsWith(
                 "m" ) ) )
             {
                 value = setting;
             }
         }
         return value;
     }
 
     //TODO remove the part with ToolchainManager lookup once we depend on
     //3.0.9 (have it as prerequisite). Define as regular component field then.
     private Toolchain getToolchain()
     {
         Toolchain tc = null;
         if ( toolchainManager != null )
         {
             tc = toolchainManager.getToolchainFromBuildContext( "jdk", session );
         }
         return tc;
     }
 
     private boolean isDigits( String string )
     {
         for ( int i = 0; i < string.length(); i++ )
         {
             if ( !Character.isDigit( string.charAt( i ) ) )
             {
                 return false;
             }
         }
         return true;
     }
 
     @SuppressWarnings( "unchecked" )
     private Set<File> computeStaleSources( CompilerConfiguration compilerConfiguration, Compiler compiler,
                                            SourceInclusionScanner scanner )
         throws MojoExecutionException, CompilerException
     {
         CompilerOutputStyle outputStyle = compiler.getCompilerOutputStyle();
 
         SourceMapping mapping;
 
         File outputDirectory;
 
         if ( outputStyle == CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE )
         {
             mapping = new SuffixMapping( compiler.getInputFileEnding( compilerConfiguration ),
                                          compiler.getOutputFileEnding( compilerConfiguration ) );
 
             outputDirectory = getOutputDirectory();
         }
         else if ( outputStyle == CompilerOutputStyle.ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES )
         {
             mapping = new SingleTargetSourceMapping( compiler.getInputFileEnding( compilerConfiguration ),
                                                      compiler.getOutputFile( compilerConfiguration ) );
 
             outputDirectory = buildDirectory;
         }
         else
         {
             throw new MojoExecutionException( "Unknown compiler output style: '" + outputStyle + "'." );
         }
 
         scanner.addSourceMapping( mapping );
 
         Set<File> staleSources = new HashSet<File>();
 
         for ( String sourceRoot : getCompileSourceRoots() )
         {
             File rootFile = new File( sourceRoot );
 
             if ( !rootFile.isDirectory() )
             {
                 continue;
             }
 
             try
             {
                 staleSources.addAll( scanner.getIncludedSources( rootFile, outputDirectory ) );
             }
             catch ( InclusionScanException e )
             {
                 throw new MojoExecutionException(
                     "Error scanning source root: \'" + sourceRoot + "\' " + "for stale files to recompile.", e );
             }
         }
 
         return staleSources;
     }
 
     /**
      * @todo also in ant plugin. This should be resolved at some point so that it does not need to
      * be calculated continuously - or should the plugins accept empty source roots as is?
      */
     private static List<String> removeEmptyCompileSourceRoots( List<String> compileSourceRootsList )
     {
         List<String> newCompileSourceRootsList = new ArrayList<String>();
         if ( compileSourceRootsList != null )
         {
             // copy as I may be modifying it
             for ( String srcDir : compileSourceRootsList )
             {
                 if ( !newCompileSourceRootsList.contains( srcDir ) && new File( srcDir ).exists() )
                 {
                     newCompileSourceRootsList.add( srcDir );
                 }
             }
         }
         return newCompileSourceRootsList;
     }
 }