package org.andromda.maven.plugin.andromdapp;
   
   import java.io.File;
   import java.net.MalformedURLException;
   import java.net.URL;
   import java.net.URLClassLoader;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  import org.andromda.core.common.ClassUtils;
  import org.andromda.maven.plugin.andromdapp.script.ScriptClassGenerator;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.model.Dependency;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.project.MavenProject;
  
  /**
   * Allows for the {@link ScriptClassGenerator} mojo to be invoked.
   * on one or more given classes.
   *
   * @author Chad Brandon
   * @goal instrument-scripts
   * @phase compile
   * @requiresDependencyResolution
   */
  public class ScriptClassGeneratorMojo
      extends AbstractMojo
  {
      /**
       * Defines the java files who's classes will be instrumented.
       *
       * @required
       * @parameter
       */
      private Location[] locations;
  
      /**
       * Defines the fully qualified class name of the script wrapper implementation.
       *
       * @parameter
       * @required
       */
      private String scriptWrapper;
  
      /**
       * @parameter expression="${project}"
       * @required
       * @readonly
       */
      private MavenProject project;
  
      /**
       * @component role="org.apache.maven.artifact.factory.ArtifactFactory"
       * @required
       * @readonly
       */
      protected ArtifactFactory factory;
  
      /**
       * @parameter expression="${localRepository}"
       * @required
       * @readonly
       */
      protected ArtifactRepository localRepository;
  
      /**
       * The java file extension
       */
      private static final String JAVA_EXTENSION = ".java";
  
      /**
       * @see org.apache.maven.plugin.Mojo#execute()
       */
      public void execute()
          throws MojoExecutionException, MojoFailureException
      {
          try
          {
              final ScriptClassGenerator generator = ScriptClassGenerator.getInstance(this.scriptWrapper);
              if (this.locations != null)
              {
                  final List<String> classpathElements = new ArrayList<String>(this.getProvidedClasspathElements());
                  classpathElements.addAll(this.project.getRuntimeClasspathElements());
                  this.initializeClassLoader(classpathElements);
                  for (int ctr = 0; ctr < locations.length; ctr++)
                  {
                      final Location location = locations[ctr];
                      String rootPath = location.getRootPath();
                      for (final String path : location.getPaths())
                      {
                          final int extensionIndex = path.lastIndexOf(JAVA_EXTENSION);
                          if (extensionIndex != -1)
                          {
                             final String className = path.substring(
                                     0,
                                     extensionIndex).replaceAll(
                                     "\\\\|/",
                                     "\\.");
                             this.getLog().info("injecting script wrapper: " + className);
                             generator.modifyClass(
                                 rootPath,
                                 ClassUtils.loadClass(className));
                         }
                     }
                 }
             }
         }
         catch (final Throwable throwable)
         {
             throw new MojoExecutionException("Failed to inject script wrappers", throwable);
         }
     }
 
     /**
      * Adds any dependencies to the current project from the plugin
      * having the given <code>pluginArtifactId</code>.
      * This project artifact dependencies are added.
      * scope=PROVIDED the artifact scope in which to add them (runtime, compile, etc).
      * @return classpathElements
      */
     protected List<String> getProvidedClasspathElements()
     {
         final List<String> classpathElements = new ArrayList<String>();
         for (final Object dependency : this.project.getDependencies())
         {
             final Artifact artifact = this.getArtifact(
                 (Dependency)dependency,
                 Artifact.SCOPE_PROVIDED);
             if (artifact != null)
             {
                 classpathElements.add(artifact.getFile().getAbsolutePath());
             }
         }
         return classpathElements;
     }
 
     /**
      * Adds a dependency to the current project's dependencies.
      *
      * @param dependency
      * @param scope the scope of the artifact
      */
     private Artifact getArtifact(
         final Dependency dependency,
         final String scope)
     {
         Artifact artifact = null;
         final ArtifactRepository localRepository = this.localRepository;
         final MavenProject project = this.project;
         if (project != null && localRepository != null)
         {
             if (dependency != null)
             {
                 artifact =
                     this.factory.createArtifact(
                         dependency.getGroupId(),
                         dependency.getArtifactId(),
                         dependency.getVersion(),
                         scope,
                         dependency.getType());
                 final File file = new File(
                         localRepository.getBasedir(),
                         localRepository.pathOf(artifact));
                 artifact.setFile(file);
             }
         }
         return artifact;
     }
 
     /**
      * Sets the current context class loader from the given runtime classpath elements.
      * @param classpathFiles
      * @throws MalformedURLException
      */
     protected void initializeClassLoader(final Collection<String> classpathFiles)
         throws MalformedURLException
     {
         final Set<URL> classpathUrls = new LinkedHashSet<URL>();
         classpathUrls.add(new File(this.project.getBuild().getOutputDirectory()).toURI().toURL());
         if (classpathFiles != null)
         {
             for (String fileName : classpathFiles)
             {
                 final File file = new File(fileName);
                 if (this.getLog().isDebugEnabled())
                 {
                     getLog().debug("adding to classpath '" + file + '\'');
                 }
                 classpathUrls.add(file.toURI().toURL());
             }
         }
         final URLClassLoader loader =
             new URLClassLoader(classpathUrls.toArray(new URL[classpathUrls.size()]),
                 Thread.currentThread().getContextClassLoader());
         Thread.currentThread().setContextClassLoader(loader);
     }
 }