/*

  * 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.

  */

 package org.apache.maven.plugin.eclipse;

 import java.io.File;

 import java.io.IOException;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Properties;

 import java.util.jar.Attributes;

 import java.util.jar.JarFile;

 import java.util.jar.Manifest;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.logging.Log;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.MavenProjectBuilder;

 import org.apache.maven.project.ProjectBuildingException;

 import org.apache.maven.shared.osgi.Maven2OsgiConverter;

 import org.codehaus.plexus.archiver.ArchiverException;

 import org.codehaus.plexus.archiver.UnArchiver;

 import org.codehaus.plexus.archiver.manager.ArchiverManager;

 import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;

 import org.codehaus.plexus.components.interactivity.InputHandler;

 import org.codehaus.plexus.util.FileUtils;

 /**

  * Install plugins resolved from the Maven repository system into an Eclipse instance.

  * 

  * @goal install-plugins

  * @author jdcasey

  * @requiresDependencyResolution compile

  */

 public class InstallPluginsMojo

     extends AbstractMojo

 {

     /**

      * Set this property in a plugin POM's <properties/> section to determine whether that plugin should be

      * expanded during installation, or left as a jar file.

      */

     public static final String PROP_UNPACK_PLUGIN = "eclipse.unpack";

     /**

      * This is the installed base directory of the Eclipse instance you want to modify.

      * 

      * @parameter expression="${eclipseDir}"

      */

     private File eclipseDir;

     /**

      * Determines whether this mojo leaves existing installed plugins as-is, or overwrites them.

      * 

      * @parameter expression="${overwrite}" default-value="false"

      */

     private boolean overwrite;

     /**

      * The list of resolved dependencies from the current project. Since we're not resolving the dependencies by hand

      * here, the build will fail if some of these dependencies do not resolve.

      * 

      * @parameter default-value="${project.artifacts}"

      * @required

      * @readonly

      */

     private Collection artifacts;

     /**

      * Comma-delimited list of dependency <type/> values which will be installed in the eclipse instance's plugins

      * directory.

      * 

      * @parameter expression="${pluginDependencyTypes}" default-value="jar"

      */

     private String pluginDependencyTypes;

     /**

      * The location of the Maven local repository, from which to install resolved dependency plugins.

      * 

      * @parameter default-value="${localRepository}"

      * @required

      * @readonly

      */

     private ArtifactRepository localRepository;

     /**

      * Used to retrieve the project metadata (POM) associated with each plugin dependency, to help determine whether

      * that plugin should be installed as a jar, or expanded into a directory.

      * 

      * @component

      */

     private MavenProjectBuilder projectBuilder;

     /**

      * Used to configure and retrieve an appropriate tool for extracting each resolved plugin dependency. It is

      * conceivable that some resolved dependencies could be zip files, jar files, or other types, so the manager

      * approach is a convenient way to provide extensibility here.

      * 

      * @component

      */

     private ArchiverManager archiverManager;

     /**

      * Input handler, needed for comand line handling.

      * 

      * @component

      */

     private InputHandler inputHandler;

     // calculated below. Value will be ${eclipseDir}/plugins.

     private File pluginsDir;

     /**

      * @component

      */

     private Maven2OsgiConverter maven2OsgiConverter;

     public InstallPluginsMojo()

     {

         // used for plexus init.

     }

     // used primarily for testing.

     protected InstallPluginsMojo( File eclipseDir, boolean overwrite, List dependencyArtifacts,

                                   String pluginDependencyTypes, ArtifactRepository localRepository,

                                   MavenProjectBuilder projectBuilder, ArchiverManager archiverManager,

                                   InputHandler inputHandler, Log log )

     {

         this.eclipseDir = eclipseDir;

         this.overwrite = overwrite;

         artifacts = dependencyArtifacts;

         this.pluginDependencyTypes = pluginDependencyTypes;

         this.localRepository = localRepository;

         this.projectBuilder = projectBuilder;

         this.archiverManager = archiverManager;

         this.inputHandler = inputHandler;

         setLog( log );

     }

     /**

      * Traverse the list of resolved dependency artifacts. For each one having a type that is listed in the

      * pluginDependencyTypes parameter value, resolve the associated project metadata (POM), and perform install(..) on

      * that artifact.

      */

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         if ( eclipseDir == null )

         {

             getLog().info( "Eclipse directory? " );

             String eclipseDirString;

             try

             {

                 eclipseDirString = inputHandler.readLine();

             }

             catch ( IOException e )

             {

                 throw new MojoExecutionException( "Unable to read from standard input", e );

             }

             eclipseDir = new File( eclipseDirString );

         }

         if ( eclipseDir.exists() && !eclipseDir.isDirectory() )

         {

             throw new MojoFailureException( "Invalid Eclipse directory: " + eclipseDir );

         }

         else if ( !eclipseDir.exists() )

         {

             eclipseDir.mkdirs();

         }

         for ( Iterator it = artifacts.iterator(); it.hasNext(); )

         {

             Artifact artifact = (Artifact) it.next();

             if ( pluginDependencyTypes.indexOf( artifact.getType() ) > -1 )

             {

                 getLog().debug( "Processing Eclipse plugin dependency: " + artifact.getId() );

                 MavenProject project;

                 try

                 {

                     project =

                         projectBuilder.buildFromRepository( artifact, Collections.EMPTY_LIST, localRepository, true );

                 }

                 catch ( ProjectBuildingException e )

                 {

                     throw new MojoExecutionException( "Failed to load project metadata (POM) for: " + artifact.getId(),

                                                       e );

                 }

                 install( artifact, project );

             }

             else

             {

                 getLog().debug(

                                 "Skipping dependency: " + artifact.getId() +

                                     ". Set pluginDependencyTypes with a comma-separated list of types to change this." );

             }

         }

     }

     /**

      * <p>

      * Install the plugin into the eclipse instance's /plugins directory

      * </p>

      * <ol>

      * <li>Determine whether the plugin should be extracted into a directory or not</li>

      * <li>If the plugin's target location exists, or overwrite is set to true:

      * <ol type="a">

      * <li>if extract, ensure the plugin target location exists (mkdirs), and extract there.</li>

      * <li>copy the plugin file from the local repository to the target location</li>

      * </ol>

      * <p>

      * Warn whenever a plugin will overwrite an existing file or directory, and emit an INFO message whenever a plugin

      * installation is skipped because of an existing file and overwrite == false.

      * </p>

      * 

      * @param artifact The plugin dependency as it has been resolved.

      * @param project The project metadata for the accompanying plugin-dependency artifact, used to determine whether to

      *            install as a jar or as a directory

      * @throws MojoExecutionException In the event the plugin should be extracted but cannot, or the file copy fails (in

      *             the event it should not be extracted)

      * @throws MojoFailureException In the event that the plugins target directory (inside the Eclipse instance

      *             directory) does not exist, or is not a directory.

      */

     private void install( Artifact artifact, MavenProject project )

         throws MojoExecutionException, MojoFailureException

     {

         if ( pluginsDir == null )

         {

             pluginsDir = new File( eclipseDir, "plugins" );

         }

         if ( !pluginsDir.exists() || !pluginsDir.isDirectory() )

         {

             throw new MojoFailureException( "Invalid Eclipse directory: " + eclipseDir +

                 " (plugins directory is missing or not a directory)." );

         }

         boolean installAsJar = true;

         Properties properties = project.getProperties();

         if ( properties != null )

         {

             installAsJar = !Boolean.valueOf( properties.getProperty( PROP_UNPACK_PLUGIN, "false" ) ).booleanValue();

         }

         Attributes attributes = null;

         try

         {

             // don't verify, plugins zipped by eclipse:make-artifacts could have a bad signature

             JarFile jar = new JarFile( artifact.getFile(), false );

             Manifest manifest = jar.getManifest();

             attributes = manifest.getMainAttributes();

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( "Unable to read manifest of plugin " +

                 artifact.getFile().getAbsolutePath(), e );

         }

         String bundleVersion = attributes.getValue( "Bundle-Version" );

         String pluginName = formatEclipsePluginName( artifact, bundleVersion );

         File pluginFile = new File( pluginsDir, pluginName + ".jar" );

         File pluginDir = new File( pluginsDir, pluginName );

         boolean skipped = true;

         /* check if artifact is an OSGi bundle and ignore if not */

         Object bundleName = attributes.getValue( "Bundle-Name" );

         if ( bundleName == null )

         {

             getLog().debug(

                             "Ignoring " + artifact.getArtifactId() +

                                 " as it is not an OSGi bundle (no Bundle-Name in manifest)" );

             return;

         }

         if ( overwrite )

         {

             if ( pluginFile.exists() || pluginDir.exists() )

             {

                 getLog().warn( "Overwriting old plugin with contents of: " + artifact.getId() );

                 getLog().debug( "Removing old plugin from both: " + pluginFile + " and: " + pluginDir );

                 try

                 {

                     FileUtils.forceDelete( pluginDir );

                     FileUtils.forceDelete( pluginFile );

                 }

                 catch ( IOException e )

                 {

                     throw new MojoExecutionException( "Failed to remove old plugin from: " + pluginFile + " or: " +

                         pluginDir, e );

                 }

                 getLog().debug( "Removal of old plugin is complete; proceeding with plugin installation." );

             }

             performFileOperations( installAsJar, artifact, pluginFile, pluginDir );

             skipped = false;

         }

         else if ( installAsJar && !pluginFile.exists() )

         {

             performFileOperations( installAsJar, artifact, pluginFile, pluginDir );

             skipped = false;

         }

         else if ( !installAsJar && !pluginDir.exists() )

         {

             performFileOperations( installAsJar, artifact, pluginFile, pluginDir );

             skipped = false;

         }

         if ( skipped )

         {

             if ( installAsJar )

             {

                 getLog().info(

                                "Skipping plugin installation for: " + artifact.getId() + "; file: " + pluginFile +

                                    " already exists. Set overwrite = true to override this." );

             }

             else if ( !installAsJar )

             {

                 getLog().info(

                                "Skipping plugin installation for: " + artifact.getId() + "; directory: " + pluginDir +

                                    " already exists. Set overwrite = true to override this." );

             }

         }

     }

     private void performFileOperations( boolean installAsJar, Artifact artifact, File pluginFile, File pluginDir )

         throws MojoExecutionException

     {

         File artifactFile = artifact.getFile();

         if ( installAsJar )

         {

             try

             {

                 getLog().debug( "Copying: " + artifact.getId() + " to: " + pluginFile );

                 FileUtils.copyFile( artifactFile, pluginFile );

             }

             catch ( IOException e )

             {

                 throw new MojoExecutionException( "Failed to copy Eclipse plugin: " + artifact.getId() + "\nfrom: " +

                     artifact.getFile() + "\nto: " + pluginFile, e );

             }

         }

         else

         {

             try

             {

                 getLog().debug( "Expanding: " + artifact.getId() + " into: " + pluginDir );

                 pluginDir.mkdirs();

                 UnArchiver unarchiver = archiverManager.getUnArchiver( artifactFile );

                 unarchiver.setSourceFile( artifactFile );

                 unarchiver.setDestDirectory( pluginDir );

                 unarchiver.extract();

             }

             catch ( NoSuchArchiverException e )

             {

                 throw new MojoExecutionException( "Could not find unarchiver for: " + artifactFile, e );

             }

             catch ( ArchiverException e )

             {

                 throw new MojoExecutionException( "Could not extract: " + artifactFile, e );

             }

             catch ( IOException e )

             {

                 throw new MojoExecutionException( "Could not extract: " + artifactFile, e );

             }

         }

     }

     /**

      * <p>

      * Format the artifact information into an Eclipse-friendly plugin name. Currently, this is just:

      * <code>artifactId + "_" + bundle version</code> if bundle version is not null.

      * </p>

      */

     private String formatEclipsePluginName( Artifact artifact, String bundleVersion )

     {

         return maven2OsgiConverter.getBundleSymbolicName( artifact ) + "_" +

             maven2OsgiConverter.getVersion( artifact.getVersion() );

     }

 }