package org.codehaus.mojo.rmic;
   
   /*
    * Copyright (c) 2004-2017, Codehaus.org
    *
    * Permission is hereby granted, free of charge, to any person obtaining a copy of
    * this software and associated documentation files (the "Software"), to deal in
    * the Software without restriction, including without limitation the rights to
    * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
   * of the Software, and to permit persons to whom the Software is furnished to do
   * so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in all
   * copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   * SOFTWARE.
   */
  
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
  import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
  import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.net.URI;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  /**
   * Generic super class of rmi compiler mojos.
   *
   * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>
   * @version $Id$
   */
  public abstract class AbstractRmiMojo
          extends AbstractMojo
  {
      private static final String STUB_CLASS_PATTERN = "**/*_Stub.class";
      // ----------------------------------------------------------------------
      // Configurable parameters
      // ----------------------------------------------------------------------
  
      private Source source;
      
      /**
       * A <code>List</code> of <code>Source</code> configurations to compile.
       */
      @Parameter
      private List<Source> sources;
  
      /**
       * A list of inclusions when searching for classes to compile.
       */
      @Parameter
      @SuppressWarnings( "unused" )
      protected Set<String> includes;
  
      /**
       * A list of exclusions when searching for classes to compile.
       */
      @Parameter
      @SuppressWarnings( "unused" )
      protected Set<String> excludes;
  
      /**
       * The id of the rmi compiler to use.
       */
      @Parameter( defaultValue = "sun" )
      protected String compiler;
  
      private RmiCompiler rmiCompiler = new BuiltInRmiCompiler();
  
      /**
       * The version of the rmi protocol to which the stubs should be compiled. Valid values include 1.1, 1.2, compat. See
       * the rmic documentation for more information. If nothing is specified the underlying rmi compiler will
       * choose the default value.  For example, in sun jdk 1.5 the default is 1.2.
       */
      @SuppressWarnings( "unused" )
      @Parameter
      private String version;
  
      /**
       * Create stubs for IIOP.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean iiop;
 
     /**
      * Do not create stubs optimized for same process.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean noLocalStubs;
 
     /**
      * Create IDL.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean idl;
 
     /**
      * Do not generate methods for valuetypes.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean noValueMethods;
 
     /**
      * Do not delete intermediate generated source files.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean keep;
 
     /**
      * Turn off rmic warnings.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean nowarn;
 
     /**
      * Enable poa generation.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean poa;
 
     /**
      * Enable verbose output.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "false" )
     private boolean verbose;
 
     /**
      * Time in milliseconds between automatic recompilations. A value of 0 means that up to date rmic output classes
      * will not be recompiled until the source classes change.
      */
     @SuppressWarnings( "unused" )
     @Parameter( defaultValue = "0" )
     private int staleMillis;
 
     // ----------------------------------------------------------------------
     // Constant parameters
     // ----------------------------------------------------------------------
 
     /**
      * The maven project.
      */
     @Parameter( defaultValue = "${project}", readonly = true )
     protected MavenProject project;
 
     /**
      * The interface between ths class and the rest of the world - unit tests replace the default implementation.
      */
     private DependenciesFacade dependencies = new DependenciesFacadeImpl();
 
     /**
      * The default implementation of the dependencies.
      */
     private static final DependenciesFacade DEPENDENCIES_FACADE = new DependenciesFacadeImpl();
 
     /**
      * Creates the abstract class using a production implementation of the dependencies.
      */
     AbstractRmiMojo()
     {
         this( DEPENDENCIES_FACADE );
     }
 
 
     /**
      * Creates the abstract class using the specified implementation of the dependencies.
      *
      * @param dependencies the implementation of the dependencies to use.
      */
     AbstractRmiMojo( DependenciesFacade dependencies )
     {
         this.dependencies = dependencies;
     }
 
     /**
      * Get the list of sub-configurations.
      */
     List<Source> getSources()
     {
         return sources;
     }
 
     /**
      * Get the list of elements to add to the classpath of rmic
      *
      * @return list of classpath elements
      */
     public abstract List<String> getProjectClasspathElements();
 
     /**
      * Get the directory where rmic generated class files are written.
      *
      * @return the directory
      */
     public abstract File getOutputDirectory();
 
     /**
      * Get the directory where Remote impl classes are located.
      *
      * @return path to compiled classes
      */
     public abstract File getClassesDirectory();
 
     /**
      * Main mojo execution.
      *
      * @throws MojoExecutionException if there is a problem executing the mojo.
      */
     public void execute() throws MojoExecutionException
     {
         if ( sources != null && source != null && source.getConfiguredOptions().length() > 0 )
         {
             throw new MojoExecutionException( "May not use <source> elements in addition to switches "
                     + "without a <source> element: " + source.getConfiguredOptions() );
         }
         if ( sources == null || sources.isEmpty() )
         {
             sources = Collections.singletonList( getSource() );
         }
 
         for ( Source source : sources )
         {
             doExecute( source );
         }
     }
 
     private void doExecute( Source source ) throws MojoExecutionException
     {
         rmiCompiler.setLog( getLog() );
 
         if ( source.isVerbose() )
         {
             getLog().debug( source.toString() );
         }
 
 
         if ( !getOutputDirectory().isDirectory() )
         {
             if ( !getOutputDirectory().mkdirs() )
             {
                 throw new MojoExecutionException( "Could not make output directory: " + "'"
                         + getOutputDirectory().getAbsolutePath() + "'." );
             }
         }
 
         try
         {
             // Get the list of classes to compile
             Set<File> remoteClassesToCompile = getRemoteClasses( source );
 
             if ( remoteClassesToCompile.size() == 0 )
             {
                 getLog().info( "No out of date rmi classes to process." );
                 return;
             }
 
             getLog().info( "Compiling " + remoteClassesToCompile.size() + " remote classes" );
             
             RmiCompilerConfiguration config = new RmiCompilerConfiguration();
             config.setClasspathEntries( getRmicClasspathElements() );
             config.addSourceLocation( getClassesDirectory().getPath() );
             config.setSourceFiles( remoteClassesToCompile );
             config.setIdl( source.isIdl() );
             config.setIiop( source.isIiop() );
             config.setKeep( source.isKeep() );
             config.setNoLocalStubs( source.isNoLocalStubs() );
             config.setNoValueMethods( source.isNoValueMethods() );
             config.setNowarn( source.isNowarn() );
             config.setOutputLocation( getOutputDirectory().getAbsolutePath() );
             config.setPoa( source.isPoa() );
             config.setVerbose( source.isVerbose() );
             config.setVersion( source.getVersion() );
             
             rmiCompiler.execute( config );
         }
         catch ( RmiCompilerException e )
         {
             throw new MojoExecutionException( "Error while executing the RMI compiler.", e );
         }
     }
     
 
     /**
      * Get the list of elements to add to the classpath of rmic
      *
      * @return list of classpath elements
      */
     private List<String> getRmicClasspathElements()
     {
         List<String> classpathElements = getProjectClasspathElements();
 
         if ( !classpathElements.contains( getClassesDirectory().getAbsolutePath() ) )
         {
             classpathElements.add( getClassesDirectory().getAbsolutePath() );
         }
 
         return classpathElements;
     }
 
     /**
      * Search the input directory for classes to compile.
      *
      * @param source the source element on which to operate
      * @return a list of class names to rmic
      */
     private Set<File> getRemoteClasses( Source source )
     {
         Set<File> remoteClasses = new HashSet<>();
 
         try
         {
             // Set up the classloader
             List<URL> classpathList = generateUrlCompileClasspath();
             URL[] classpathUrls = new URL[classpathList.size()];
             classpathUrls[0] = getClassesDirectory().toURI().toURL();
             classpathUrls = classpathList.toArray( classpathUrls );
             dependencies.defineUrlClassLoader( classpathUrls );
 
             // Scan for remote classes
 
             SourceInclusionScanner scanner = createScanner( source.getIncludes(), getExcludes( source ) );
             scanner.addSourceMapping( new SuffixMapping( ".class", "_Stub.class" ) );
             
             Collection<File> staleRemoteClasses
                     = scanner.getIncludedSources( getClassesDirectory(), getOutputDirectory() );
 
             for ( File file : staleRemoteClasses )
             {
                 URI relativeURI = getClassesDirectory().toURI().relativize( file.toURI() );
                 String className = fileToClassName( relativeURI.toString() );
                 Class<?> candidateClass = dependencies.loadClass( className );
                 if ( isRemoteRmiClass( candidateClass, source.isIiop() ) )
                 {
                     // file is absolute, we need relative files
                     remoteClasses.add( new File( relativeURI.toString() ) );
                 }
             }
 
             // Check for classes in a classpath jar
             for ( String include : source.getIncludes() )
             {
                 File includeFile = new File( getClassesDirectory(), include );
                 if ( ( include.contains( "*" ) ) || dependencies.fileExists( includeFile ) )
                 {
                     continue;
                 }
                 // We have found a class that is not in the classes dir.
                 remoteClasses.add( includeFile );
             }
         }
         catch ( Exception e )
         {
             getLog().warn( "Problem while scanning for classes: " + e );
         }
         return remoteClasses;
     }
 
     private SourceInclusionScanner createScanner( Set<String> includes, Set<String> excludes )
     {
         return dependencies.createScanner( staleMillis, includes, excludes );
     }
 
     private Set<String> getExcludes( Source source )
     {
         Set<String> excludes = source.getExcludes();
         excludes.add( STUB_CLASS_PATTERN );
         return excludes;
     }
 
     private static String fileToClassName( String classFileName )
     {
         return StringUtils.replace( StringUtils.replace( classFileName, ".class", "" ), "/", "." );
     }
 
     // Check that each class implements java.rmi.Remote, ignore interfaces unless in IIOP mode
     private boolean isRemoteRmiClass( Class<?> remoteClass, boolean isIiop )
     {
         return java.rmi.Remote.class.isAssignableFrom( remoteClass ) && ( !remoteClass.isInterface() || isIiop );
     }
 
     /**
      * Returns a list of URL objects that represent the classpath elements. This is useful for using a URLClassLoader
      *
      * @return list of url classpath elements
      */
     private List<URL> generateUrlCompileClasspath()
             throws MojoExecutionException
     {
         List<URL> rmiCompileClasspath = new ArrayList<>();
         try
         {
             rmiCompileClasspath.add( getClassesDirectory().toURI().toURL() );
             for ( String classpathElement : getRmicClasspathElements() )
             {
                 URL pathUrl = new File( classpathElement ).toURI().toURL();
                 rmiCompileClasspath.add( pathUrl );
             }
         }
         catch ( Exception e )
         {
             e.printStackTrace();
             throw new MojoExecutionException( "Problem while generating classpath: " + e.getMessage() );
         }
         return rmiCompileClasspath;
     }
 
     private Source getSource()
     {
         if ( source == null )
         {
             source = new Source();
         }
         return source;
     }
     
     // Plexus trick: if there's a setter for a @parameter, use the setter
 
     /**
      * Specifies files to include in rmic processing
      * @param includes a set of file name patterns
      */
     @SuppressWarnings( "unused" )
     public void setIncludes( Set<String> includes )
     {
         getSource().setIncludes( includes );
     }
 
     /**
      * Specifies files to exclude from rmic processing
      * @param excludes a set of file name patterns
      */
     public void setExcludes( Set<String> excludes )
     {
         getSource().setExcludes( excludes );
     }
 
     /**
      * Specifies a version to be passed to the compiler. Defaults to not passing one.
      * @param version the version to pass
      */
     public void setVersion( String version )
     {
         getSource().setVersion( version );
     }
 
     /**
      * Specifies whether the '-iiop' option will be passed to the compiler.
      * @param iiop if true, will pass the option
      */
     public void setIiop( Boolean iiop )
     {
         getSource().setIiop( iiop );
     }
 
     /**
      * Specifies whether the '-nolocalstubs' option will be passed to the compiler. Only applicable if the '-iiop'
      * option is also set.
      * @param noLocalStubs if true, will pass the option
      */
     public void setNoLocalStubs( Boolean noLocalStubs )
     {
         getSource().setNoLocalStubs( noLocalStubs );
     }
 
     /**
      * Specifies whether the '-idl' option will be passed to the compiler.
      * @param idl if true, will pass the option
      */
     @SuppressWarnings( "unused" )
     public void setIdl( Boolean idl )
     {
         getSource().setIdl( idl );
     }
 
     /**
      * Specifies whether the '-noValueMethods' option will be passed to the compiler. Only applicable if the '-idl'
      * option is also set.
      * @param noValueMethods if true, will pass the option
      */
     @SuppressWarnings( "unused" )
     public void setNoValueMethods( Boolean noValueMethods )
     {
         getSource().setNoValueMethods( noValueMethods );
     }
 
     /**
      * Specifies whether the '-keep' option will be passed to the compiler.
      * @param keep if true, will pass the option
      */
     @SuppressWarnings( "unused" )
     public void setKeep( Boolean keep )
     {
         getSource().setKeep( keep );
     }
 
     /**
      * Specifies whether the '-warn' option will be passed to the compiler.
      * @param nowarn if true, will pass the option
      */
     @SuppressWarnings( "unused" )
     public void setNowarn( Boolean nowarn )
     {
         getSource().setNowarn( nowarn );
     }
 
     /**
      * Specifies whether the '-poa' option will be passed to the compiler. Only applicable if the '-iiop' option
      * is also set.
      * @param poa if true, will pass the option
      */
     public void setPoa( Boolean poa )
     {
         getSource().setPoa( poa );
     }
 
     /**
      * Specifies whether the '-verbose' option will be passed to the compiler.
      * @param verbose if true, will pass the option
      */
     public void setVerbose( Boolean verbose )
     {
         getSource().setVerbose( verbose );
     }
     
     
     /**
      * An interface for dependencies on the file system and related mojo base classes.
      */
     interface DependenciesFacade
     {
         boolean fileExists( File includeFile );
 
         SourceInclusionScanner createScanner( int staleMillis, Set<String> includes, Set<String> excludes );
 
         Class<?> loadClass( String className ) throws ClassNotFoundException;
 
         void defineUrlClassLoader( URL[] classpathUrls );
     }
 
     /**
      * Standard file system and mojo dependencies.
      */
     private static class DependenciesFacadeImpl implements DependenciesFacade
     {
         private static URLClassLoader loader;
 
         public Class<?> loadClass( String className ) throws ClassNotFoundException
         {
             return loader.loadClass( className );
         }
 
         public void defineUrlClassLoader( URL[] classpathUrls )
         {
             loader = new URLClassLoader( classpathUrls );
         }
 
         public boolean fileExists( File includeFile )
         {
             return includeFile.exists();
         }
 
         public SourceInclusionScanner createScanner( int staleMillis, Set<String> includes, Set<String> excludes )
         {
             return new StaleSourceScanner( staleMillis, includes, excludes );
         }
     }
 }