package org.apache.maven.plugin.dependency.fromConfiguration;

 /*

  * 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.artifact.Artifact;

 import org.apache.maven.artifact.factory.ArtifactFactory;

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

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

 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionException;

 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;

 import org.apache.maven.artifact.versioning.VersionRange;

 import org.apache.maven.model.Dependency;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.dependency.AbstractDependencyMojo;

 import org.apache.maven.plugin.dependency.utils.DependencyUtil;

 import org.apache.maven.plugin.dependency.utils.filters.ArtifactItemFilter;

 import org.apache.maven.plugins.annotations.Component;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.util.Collections;

 import java.util.List;

 import java.util.Set;

 /**

  * Abstract parent class used by mojos that get Artifact information from the plugin configuration as an ArrayList of

  * ArtifactItems

  *

  * @author <a href="mailto:brianf@apache.org">Brian Fox</a>

  * @version $Id: AbstractFromConfigurationMojo.java 1397671 2012-10-12 18:28:52Z rfscholte $

  * @see ArtifactItem

  */

 public abstract class AbstractFromConfigurationMojo

     extends AbstractDependencyMojo

 {

     /**

      * Skip the execution

      *

      * @since 2.2

      */

     @Parameter( property = "mdep.skip", defaultValue = "false" )

     private boolean skip;

     /**

      * Default location used for mojo unless overridden in ArtifactItem

      *

      * @since 1.0

      */

     @Parameter( property = "outputDirectory", defaultValue = "${project.build.directory}/dependency" )

     private File outputDirectory;

     /**

      * Overwrite release artifacts

      *

      * @since 1.0

      */

     @Parameter( property = "mdep.overWriteReleases", defaultValue = "false" )

     private boolean overWriteReleases;

     /**

      * Overwrite snapshot artifacts

      *

      * @since 1.0

      */

     @Parameter( property = "mdep.overWriteSnapshots", defaultValue = "false" )

     private boolean overWriteSnapshots;

     /**

      * Overwrite if newer

      *

      * @since 2.0

      */

     @Parameter( property = "mdep.overIfNewer", defaultValue = "true" )

     private boolean overWriteIfNewer;

     /**

      * To search for artifacts within the reactor and ensure consistent behaviour between Maven 2 and Maven 3.

      */

     @Parameter( defaultValue = "${reactorProjects}", readonly = true, required = true )

     protected List<MavenProject> reactorProjects;

     /**

      * Collection of ArtifactItems to work on. (ArtifactItem contains groupId, artifactId, version, type, classifier,

      * outputDirectory, destFileName and overWrite.) See <a href="./usage.html">Usage</a> for details.

      *

      * @since 1.0

      */

     @Parameter

     private List<ArtifactItem> artifactItems;

     /**

      * To look up ArtifactRepository implementation

      */

     @Component

     private ArtifactRepositoryFactory artifactRepositoryManager;

     /**

      * Path to override default local repository during plugin's execution. To remove all downloaded artifacts as part

      * of the build, set this value to a location under your project's target directory

      *

      * @since 2.2

      */

     @Parameter

     private File localRepositoryDirectory;

     /**

      * To host and cache localRepositoryDirectory

      */

     private ArtifactRepository overrideLocalRepository;

     @Component

     private ArtifactFactory artifactFactory;

     abstract ArtifactItemFilter getMarkedArtifactFilter( ArtifactItem item );

     // artifactItems is filled by either field injection or by setArtifact()

     protected void verifyRequirements() throws MojoFailureException

     {

         if ( artifactItems == null || artifactItems.isEmpty() )

         {

             throw new MojoFailureException( "Either artifact or artifactItems is required " );

         }

     }

     /**

      * Preprocesses the list of ArtifactItems. This method defaults the outputDirectory if not set and creates the

      * output Directory if it doesn't exist.

      *

      * @param removeVersion remove the version from the filename.

      * @return An ArrayList of preprocessed ArtifactItems

      * @throws MojoExecutionException with a message if an error occurs.

      * @see ArtifactItem

      */

     protected List<ArtifactItem> getProcessedArtifactItems( boolean removeVersion )

         throws MojoExecutionException

     {

         if ( artifactItems == null || artifactItems.size() < 1 )

         {

             throw new MojoExecutionException( "There are no artifactItems configured." );

         }

         for ( ArtifactItem artifactItem : artifactItems )

         {

             this.getLog().info( "Configured Artifact: " + artifactItem.toString() );

             if ( artifactItem.getOutputDirectory() == null )

             {

                 artifactItem.setOutputDirectory( this.outputDirectory );

             }

             artifactItem.getOutputDirectory().mkdirs();

             // make sure we have a version.

             if ( StringUtils.isEmpty( artifactItem.getVersion() ) )

             {

                 fillMissingArtifactVersion( artifactItem );

             }

             artifactItem.setArtifact( this.getArtifact( artifactItem ) );

             if ( StringUtils.isEmpty( artifactItem.getDestFileName() ) )

             {

                 artifactItem.setDestFileName(

                     DependencyUtil.getFormattedFileName( artifactItem.getArtifact(), removeVersion ) );

             }

             try

             {

                 artifactItem.setNeedsProcessing( checkIfProcessingNeeded( artifactItem ) );

             }

             catch ( ArtifactFilterException e )

             {

                 throw new MojoExecutionException( e.getMessage(), e );

             }

         }

         return artifactItems;

     }

     private boolean checkIfProcessingNeeded( ArtifactItem item )

         throws MojoExecutionException, ArtifactFilterException

     {

         return StringUtils.equalsIgnoreCase( item.getOverWrite(), "true" )

             || getMarkedArtifactFilter( item ).isArtifactIncluded( item );

     }

     /**

      * Resolves the Artifact from the remote repository if necessary. If no version is specified, it will be retrieved

      * from the dependency list or from the DependencyManagement section of the pom.

      *

      * @param artifactItem containing information about artifact from plugin configuration.

      * @return Artifact object representing the specified file.

      * @throws MojoExecutionException with a message if the version can't be found in DependencyManagement.

      */

     protected Artifact getArtifact( ArtifactItem artifactItem )

         throws MojoExecutionException

     {

         Artifact artifact;

         // Map managedVersions = createManagedVersionMap( factory, project.getId(), project.getDependencyManagement() );

         VersionRange vr;

         try

         {

             vr = VersionRange.createFromVersionSpec( artifactItem.getVersion() );

         }

         catch ( InvalidVersionSpecificationException e1 )

         {

             // TODO Auto-generated catch block

             e1.printStackTrace();

             vr = VersionRange.createFromVersion( artifactItem.getVersion() );

         }

         if ( StringUtils.isEmpty( artifactItem.getClassifier() ) )

         {

             artifact = factory.createDependencyArtifact( artifactItem.getGroupId(), artifactItem.getArtifactId(), vr,

                                                          artifactItem.getType(), null, Artifact.SCOPE_COMPILE );

         }

         else

         {

             artifact = factory.createDependencyArtifact( artifactItem.getGroupId(), artifactItem.getArtifactId(), vr,

                                                          artifactItem.getType(), artifactItem.getClassifier(),

                                                          Artifact.SCOPE_COMPILE );

         }

         // Maven 3 will search the reactor for the artifact but Maven 2 does not

         // to keep consistent behaviour, we search the reactor ourselves.

         Artifact result = getArtifactFomReactor( artifact );

         if ( result != null )

         {

             return result;

         }

         try

         {

             // mdep-50 - rolledback for now because it's breaking some functionality.

             /*

              * List listeners = new ArrayList(); Set theSet = new HashSet(); theSet.add( artifact );

              * ArtifactResolutionResult artifactResolutionResult = artifactCollector.collect( theSet, project

              * .getArtifact(), managedVersions, this.local, project.getRemoteArtifactRepositories(),

              * artifactMetadataSource, null, listeners ); Iterator iter =

              * artifactResolutionResult.getArtifactResolutionNodes().iterator(); while ( iter.hasNext() ) {

              * ResolutionNode node = (ResolutionNode) iter.next(); artifact = node.getArtifact(); }

              */

             resolver.resolve( artifact, remoteRepos, getLocal() );

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( "Unable to resolve artifact.", e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( "Unable to find artifact.", e );

         }

         return artifact;

     }

     /**

      * Checks to see if the specified artifact is available from the reactor.

      *

      * @param artifact The artifact we are looking for.

      * @return The resolved artifact that is the same as the one we were looking for or <code>null</code> if one could

      *         not be found.

      */

     private Artifact getArtifactFomReactor( Artifact artifact )

     {

         // check project dependencies first off

         for ( Artifact a : (Set<Artifact>) project.getArtifacts() )

         {

             if ( equals( artifact, a ) && hasFile( a ) )

             {

                 return a;

             }

         }

         // check reactor projects

         for ( MavenProject p : reactorProjects == null ? Collections.<MavenProject>emptyList() : reactorProjects )

         {

             // check the main artifact

             if ( equals( artifact, p.getArtifact() ) && hasFile( p.getArtifact() ) )

             {

                 return p.getArtifact();

             }

             // check any side artifacts

             for ( Artifact a : (List<Artifact>) p.getAttachedArtifacts() )

             {

                 if ( equals( artifact, a ) && hasFile( a ) )

                 {

                     return a;

                 }

             }

         }

         // not available

         return null;

     }

     /**

      * Returns <code>true</code> if the artifact has a file.

      *

      * @param artifact the artifact (may be null)

      * @return <code>true</code> if and only if the artifact is non-null and has a file.

      */

     private static boolean hasFile( Artifact artifact )

     {

         return artifact != null && artifact.getFile() != null && artifact.getFile().isFile();

     }

     /**

      * Null-safe compare of two artifacts based on groupId, artifactId, version, type and classifier.

      *

      * @param a the first artifact.

      * @param b the second artifact.

      * @return <code>true</code> if and only if the two artifacts have the same groupId, artifactId, version,

      *         type and classifier.

      */

     private static boolean equals( Artifact a, Artifact b )

     {

         return a == b || !( a == null || b == null )

             && StringUtils.equals( a.getGroupId(), b.getGroupId() )

             && StringUtils.equals( a.getArtifactId(), b.getArtifactId() )

             && StringUtils.equals( a.getVersion(), b.getVersion() )

             && StringUtils.equals( a.getType(), b.getType() )

             && StringUtils.equals( a.getClassifier(), b.getClassifier() );

     }

     /**

      * Tries to find missing version from dependency list and dependency management. If found, the artifact is updated

      * with the correct version. It will first look for an exact match on artifactId/groupId/classifier/type and if it

      * doesn't find a match, it will try again looking for artifactId and groupId only.

      *

      * @param artifact representing configured file.

      * @throws MojoExecutionException

      */

     private void fillMissingArtifactVersion( ArtifactItem artifact )

         throws MojoExecutionException

     {

         @SuppressWarnings( "unchecked" ) List<Dependency> deps = project.getDependencies();

         @SuppressWarnings( "unchecked" ) List<Dependency> depMngt = project.getDependencyManagement() == null

             ? Collections.<Dependency>emptyList()

             : project.getDependencyManagement().getDependencies();

         if ( !findDependencyVersion( artifact, deps, false )

             && ( project.getDependencyManagement() == null || !findDependencyVersion( artifact, depMngt, false ) )

             && !findDependencyVersion( artifact, deps, true )

             && ( project.getDependencyManagement() == null || !findDependencyVersion( artifact, depMngt, true ) ) )

         {

             throw new MojoExecutionException(

                 "Unable to find artifact version of " + artifact.getGroupId() + ":" + artifact.getArtifactId()

                     + " in either dependency list or in project's dependency management." );

         }

     }

     /**

      * Tries to find missing version from a list of dependencies. If found, the artifact is updated with the correct

      * version.

      *

      * @param artifact     representing configured file.

      * @param dependencies list of dependencies to search.

      * @param looseMatch   only look at artifactId and groupId

      * @return the found dependency

      */

     private boolean findDependencyVersion( ArtifactItem artifact, List<Dependency> dependencies, boolean looseMatch )

     {

         for ( Dependency dependency : dependencies )

         {

             if ( StringUtils.equals( dependency.getArtifactId(), artifact.getArtifactId() )

                 && StringUtils.equals( dependency.getGroupId(), artifact.getGroupId() )

                 && ( looseMatch || StringUtils.equals( dependency.getClassifier(), artifact.getClassifier() ) )

                 && ( looseMatch || StringUtils.equals( dependency.getType(), artifact.getType() ) ) )

             {

                 artifact.setVersion( dependency.getVersion() );

                 return true;

             }

         }

         return false;

     }

     /*

      * private Map createManagedVersionMap( ArtifactFactory artifactFactory, String projectId, DependencyManagement

      * dependencyManagement ) throws MojoExecutionException { Map map; if ( dependencyManagement != null &&

      * dependencyManagement.getDependencies() != null ) { map = new HashMap(); for ( Iterator i =

      * dependencyManagement.getDependencies().iterator(); i.hasNext(); ) { Dependency d = (Dependency) i.next(); try {

      * VersionRange versionRange = VersionRange.createFromVersionSpec( d.getVersion() ); Artifact artifact =

      * artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(), versionRange, d.getType(), d

      * .getClassifier(), d.getScope(), d .isOptional() ); map.put( d.getManagementKey(), artifact ); } catch (

      * InvalidVersionSpecificationException e ) { throw new MojoExecutionException( "Unable to parse version", e ); } }

      * } else { map = Collections.EMPTY_MAP; } return map; }

      */

     /**

      * Override the base to

      *

      * @return Returns the local.

      */

     protected ArtifactRepository getLocal()

     {

         if ( this.overrideLocalRepository != null )

         {

             return this.overrideLocalRepository;

         }

         ArtifactRepository local = super.getLocal();

         if ( this.localRepositoryDirectory != null )

         {

             // create a new local repo using existing layout, snapshots, and releases policy

             String url = "file://" + this.localRepositoryDirectory.getAbsolutePath();

             this.overrideLocalRepository =

                 artifactRepositoryManager.createArtifactRepository( local.getId(), url, local.getLayout(),

                                                                     local.getSnapshots(), local.getReleases() );

             this.getLog().debug( "Execution local repository is at: " + this.overrideLocalRepository.getBasedir() );

         }

         else

         {

             this.overrideLocalRepository = local;

         }

         return this.overrideLocalRepository;

     }

     /**

      * @return Returns the artifactItems.

      */

     public List<ArtifactItem> getArtifactItems()

     {

         return this.artifactItems;

     }

     /**

      * @param theArtifactItems The artifactItems to set.

      */

     public void setArtifactItems( List<ArtifactItem> theArtifactItems )

     {

         this.artifactItems = theArtifactItems;

     }

     /**

      * @return Returns the outputDirectory.

      */

     public File getOutputDirectory()

     {

         return this.outputDirectory;

     }

     /**

      * @param theOutputDirectory The outputDirectory to set.

      */

     public void setOutputDirectory( File theOutputDirectory )

     {

         this.outputDirectory = theOutputDirectory;

     }

     /**

      * @return Returns the overWriteIfNewer.

      */

     public boolean isOverWriteIfNewer()

     {

         return this.overWriteIfNewer;

     }

     /**

      * @param theOverWriteIfNewer The overWriteIfNewer to set.

      */

     public void setOverWriteIfNewer( boolean theOverWriteIfNewer )

     {

         this.overWriteIfNewer = theOverWriteIfNewer;

     }

     /**

      * @return Returns the overWriteReleases.

      */

     public boolean isOverWriteReleases()

     {

         return this.overWriteReleases;

     }

     /**

      * @param theOverWriteReleases The overWriteReleases to set.

      */

     public void setOverWriteReleases( boolean theOverWriteReleases )

     {

         this.overWriteReleases = theOverWriteReleases;

     }

     /**

      * @return Returns the overWriteSnapshots.

      */

     public boolean isOverWriteSnapshots()

     {

         return this.overWriteSnapshots;

     }

     /**

      * @param theOverWriteSnapshots The overWriteSnapshots to set.

      */

     public void setOverWriteSnapshots( boolean theOverWriteSnapshots )

     {

         this.overWriteSnapshots = theOverWriteSnapshots;

     }

     public void setLocalRepositoryDirectory( File localRepositoryDirectory )

     {

         this.localRepositoryDirectory = localRepositoryDirectory;

     }

     public boolean isSkip()

     {

         return skip;

     }

     public void setSkip( boolean skip )

     {

         this.skip = skip;

     }

     public void setArtifact( String artifact )

         throws MojoFailureException

     {

         if ( artifact != null )

         {

             String packaging = "jar";

             String classifier;

             String[] tokens = StringUtils.split( artifact, ":" );

             if ( tokens.length < 3 || tokens.length > 5 )

             {

                 throw new MojoFailureException(

                     "Invalid artifact, you must specify groupId:artifactId:version[:packaging][:classifier] "

                         + artifact );

             }

             String groupId = tokens[0];

             String artifactId = tokens[1];

             String version = tokens[2];

             if ( tokens.length >= 4 )

             {

                 packaging = tokens[3];

             }

             if ( tokens.length == 5 )

             {

                 classifier = tokens[4];

             }

             else

             {

                 classifier = null;

             }

             Artifact toUnpack = classifier == null

             ? artifactFactory.createBuildArtifact( groupId, artifactId, version, packaging )

             : artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, packaging, classifier );

             setArtifactItems( Collections.singletonList( new ArtifactItem( toUnpack ) ) );

         }

     }

 }