package org.apache.maven.artifact.resolver;

 /*

  * 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.metadata.ArtifactMetadataRetrievalException;

 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;

 import org.apache.maven.artifact.metadata.ResolutionGroup;

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

 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;

 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;

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

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

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

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

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.LinkedHashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

  * Default implementation of the artifact collector.

  *

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  * @version $Id: DefaultArtifactCollector.java 736543 2009-01-22 03:33:16Z jdcasey $

  */

 public class DefaultArtifactCollector

     implements ArtifactCollector

 {

     public ArtifactResolutionResult collect( Set artifacts, Artifact originatingArtifact,

                                              ArtifactRepository localRepository, List remoteRepositories,

                                              ArtifactMetadataSource source, ArtifactFilter filter, List listeners )

         throws ArtifactResolutionException

     {

         return collect( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository, remoteRepositories,

                         source, filter, listeners );

     }

     public ArtifactResolutionResult collect( Set artifacts, Artifact originatingArtifact, Map managedVersions,

                                              ArtifactRepository localRepository, List remoteRepositories,

                                              ArtifactMetadataSource source, ArtifactFilter filter, List listeners )

         throws ArtifactResolutionException

     {

         Map resolvedArtifacts = new LinkedHashMap();

         ResolutionNode root = new ResolutionNode( originatingArtifact, remoteRepositories );

         root.addDependencies( artifacts, remoteRepositories, filter );

         ManagedVersionMap versionMap = getManagedVersionsMap( originatingArtifact, managedVersions );

         recurse( originatingArtifact, root, resolvedArtifacts, versionMap, localRepository, remoteRepositories, source, filter,

                  listeners );

         Set set = new LinkedHashSet();

         for ( Iterator i = resolvedArtifacts.values().iterator(); i.hasNext(); )

         {

             List nodes = (List) i.next();

             for ( Iterator j = nodes.iterator(); j.hasNext(); )

             {

                 ResolutionNode node = (ResolutionNode) j.next();

                 if ( !node.equals( root ) && node.isActive() )

                 {

                     Artifact artifact = node.getArtifact();

                     if ( node.filterTrail( filter ) )

                     {

                         // If it was optional and not a direct dependency,

                         // we don't add it or its children, just allow the update of the version and scope

                         if ( node.isChildOfRootNode() || !artifact.isOptional() )

                         {

                             artifact.setDependencyTrail( node.getDependencyTrail() );

                             set.add( node );

                         }

                     }

                 }

             }

         }

         ArtifactResolutionResult result = new ArtifactResolutionResult();

         result.setArtifactResolutionNodes( set );

         return result;

     }

     /**

      * Get the map of managed versions, removing the originating artifact if it is also in managed versions

      * @param originatingArtifact artifact we are processing

      * @param managedVersions original managed versions

      */

     private ManagedVersionMap getManagedVersionsMap( Artifact originatingArtifact, Map managedVersions )

     {

         ManagedVersionMap versionMap;

         if ( managedVersions != null && managedVersions instanceof ManagedVersionMap )

         {

             versionMap = (ManagedVersionMap) managedVersions;

         }

         else

         {

             versionMap = new ManagedVersionMap( managedVersions );

         }

         /* remove the originating artifact if it is also in managed versions to avoid being modified during resolution */

         Artifact managedOriginatingArtifact = (Artifact) versionMap.get( originatingArtifact.getDependencyConflictId() );

         if ( managedOriginatingArtifact != null )

         {

             // TODO we probably want to warn the user that he is building an artifact with

             // different values than in dependencyManagement

             if ( managedVersions instanceof ManagedVersionMap )

             {

                 /* avoid modifying the managedVersions parameter creating a new map */

                 versionMap = new ManagedVersionMap( managedVersions );

             }

             versionMap.remove( originatingArtifact.getDependencyConflictId() );

         }

         return versionMap;

     }

     private void recurse( Artifact originatingArtifact, ResolutionNode node, Map resolvedArtifacts, ManagedVersionMap managedVersions,

                           ArtifactRepository localRepository, List remoteRepositories, ArtifactMetadataSource source,

                           ArtifactFilter filter, List listeners )

         throws CyclicDependencyException, ArtifactResolutionException, OverConstrainedVersionException

     {

         fireEvent( ResolutionListener.TEST_ARTIFACT, listeners, node );

         Object key = node.getKey();

         // TODO: Does this check need to happen here?  Had to add the same call

         // below when we iterate on child nodes -- will that suffice?

         if ( managedVersions.containsKey( key ))

         {

             manageArtifact( node, managedVersions, listeners );

         }

         List previousNodes = (List) resolvedArtifacts.get( key );

         if ( previousNodes != null )

         {

             for ( Iterator i = previousNodes.iterator(); i.hasNext(); )

             {

                 ResolutionNode previous = (ResolutionNode) i.next();

                 if ( previous.isActive() )

                 {

                     // Version mediation

                     VersionRange previousRange = previous.getArtifact().getVersionRange();

                     VersionRange currentRange = node.getArtifact().getVersionRange();

                     if ( previousRange != null && currentRange != null )

                     {

                         // TODO: shouldn't need to double up on this work, only done for simplicity of handling recommended

                         // version but the restriction is identical

                         VersionRange newRange = previousRange.restrict( currentRange );

                         // TODO: ick. this forces the OCE that should have come from the previous call. It is still correct

                         if ( newRange.isSelectedVersionKnown( previous.getArtifact() ) )

                         {

                             fireEvent( ResolutionListener.RESTRICT_RANGE, listeners, node, previous.getArtifact(),

                                        newRange );

                         }

                         previous.getArtifact().setVersionRange( newRange );

                         node.getArtifact().setVersionRange( currentRange.restrict( previousRange ) );

                         //Select an appropriate available version from the (now restricted) range

                         //Note this version was selected before to get the appropriate POM

                         //But it was reset by the call to setVersionRange on restricting the version

                         ResolutionNode[] resetNodes = {previous, node};

                         for ( int j = 0; j < 2; j++ )

                         {

                             Artifact resetArtifact = resetNodes[j].getArtifact();

                             //MNG-2123: if the previous node was not a range, then it wouldn't have any available

                             //versions. We just clobbered the selected version above. (why? i have no idea.)

                             //So since we are here and this is ranges we must go figure out the version (for a third time...)

                             if ( resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null )

                             {

                                 // go find the version. This is a total hack. See previous comment.

                                 List versions = resetArtifact.getAvailableVersions();

                                 if ( versions == null )

                                 {

                                     try

                                     {

                                         versions =

                                             source.retrieveAvailableVersions( resetArtifact, localRepository,

                                                                               remoteRepositories );

                                         resetArtifact.setAvailableVersions( versions );

                                     }

                                     catch ( ArtifactMetadataRetrievalException e )

                                     {

                                         resetArtifact.setDependencyTrail( node.getDependencyTrail() );

                                         throw new ArtifactResolutionException(

                                                                                "Unable to get dependency information: " +

                                                                                    e.getMessage(), resetArtifact,

                                                                                remoteRepositories, e );

                                     }

                                 }

                                 //end hack

                                 //MNG-2861: match version can return null

                                 ArtifactVersion selectedVersion = resetArtifact.getVersionRange().matchVersion( resetArtifact.getAvailableVersions() );

                                 if (selectedVersion != null)

                                 {

                                   resetArtifact.selectVersion( selectedVersion.toString() );

                                 }

                                 else

                                 {

                                   throw new OverConstrainedVersionException(" Unable to find a version in "+ resetArtifact.getAvailableVersions()+" to match the range "+ resetArtifact.getVersionRange(), resetArtifact);

                                 }

                                 fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, resetNodes[j] );

                             }

                         }

                     }

                     // Conflict Resolution

                     // TODO: use as conflict resolver(s), chain

                     // TODO: should this be part of mediation?

                     // previous one is more dominant

                     ResolutionNode nearest;

                     ResolutionNode farthest;

                     if ( previous.getDepth() <= node.getDepth() )

                     {

                         nearest = previous;

                         farthest = node;

                     }

                     else

                     {

                         nearest = node;

                         farthest = previous;

                     }

                     if ( checkScopeUpdate( farthest, nearest, listeners ) )

                     {

                         // if we need to update scope of nearest to use farthest scope, use the nearest version, but farthest scope

                         nearest.disable();

                         farthest.getArtifact().setVersion( nearest.getArtifact().getVersion() );

                         fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, nearest, farthest.getArtifact() );

                     }

                     else

                     {

                         farthest.disable();

                         fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, farthest, nearest.getArtifact() );

                     }

                 }

             }

         }

         else

         {

             previousNodes = new ArrayList();

             resolvedArtifacts.put( key, previousNodes );

         }

         previousNodes.add( node );

         if ( node.isActive() )

         {

             fireEvent( ResolutionListener.INCLUDE_ARTIFACT, listeners, node );

         }

         // don't pull in the transitive deps of a system-scoped dependency.

         if ( node.isActive() && !Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) )

         {

             fireEvent( ResolutionListener.PROCESS_CHILDREN, listeners, node );

             Artifact parentArtifact = node.getArtifact();

             for ( Iterator i = node.getChildrenIterator(); i.hasNext(); )

             {

                 ResolutionNode child = (ResolutionNode) i.next();

                 // We leave in optional ones, but don't pick up its dependencies

                 if ( !child.isResolved() && ( !child.getArtifact().isOptional() || child.isChildOfRootNode() ) )

                 {

                     List childRemoteRepositories = child.getRemoteRepositories();

                     Artifact artifact = child.getArtifact();

                     try

                     {

                         Object childKey;

                         do

                         {

                             childKey = child.getKey();

                             if ( managedVersions.containsKey( childKey ) )

                             {

                                 // If this child node is a managed dependency, ensure

                                 // we are using the dependency management version

                                 // of this child if applicable b/c we want to use the

                                 // managed version's POM, *not* any other version's POM.

                                 // We retrieve the POM below in the retrieval step.

                                 manageArtifact( child, managedVersions, listeners );

                                 // Also, we need to ensure that any exclusions it presents are

                                 // added to the artifact before we retrieve the metadata

                                 // for the artifact; otherwise we may end up with unwanted

                                 // dependencies.

                                 Artifact ma = (Artifact) managedVersions.get( childKey );

                                 ArtifactFilter managedExclusionFilter = ma.getDependencyFilter();

                                 if ( null != managedExclusionFilter )

                                 {

                                     if ( null != artifact.getDependencyFilter() )

                                     {

                                         AndArtifactFilter aaf = new AndArtifactFilter();

                                         aaf.add( artifact.getDependencyFilter() );

                                         aaf.add( managedExclusionFilter );

                                         artifact.setDependencyFilter( aaf );

                                     }

                                     else

                                     {

                                         artifact.setDependencyFilter( managedExclusionFilter );

                                     }

                                 }

                             }

                             if ( artifact.getVersion() == null )

                             {

                                 // set the recommended version

                                 // TODO: maybe its better to just pass the range through to retrieval and use a transformation?

                                 ArtifactVersion version;

                                 if ( artifact.isSelectedVersionKnown() )

                                 {

                                     version = artifact.getSelectedVersion();

                                 }

                                 else

                                 {

                                     //go find the version

                                     List versions = artifact.getAvailableVersions();

                                     if ( versions == null )

                                     {

                                         versions = source.retrieveAvailableVersions( artifact, localRepository,

                                                                                      childRemoteRepositories );

                                         artifact.setAvailableVersions( versions );

                                     }

                                     Collections.sort( versions );

                                     VersionRange versionRange = artifact.getVersionRange();

                                     version = versionRange.matchVersion( versions );

                                     if ( version == null )

                                     {

                                         // Getting the dependency trail so it can be logged in the exception

                                         artifact.setDependencyTrail( node.getDependencyTrail() );

                                         if ( versions.isEmpty() )

                                         {

                                             throw new OverConstrainedVersionException(

                                                 "No versions are present in the repository for the artifact with a range " +

                                                     versionRange, artifact, childRemoteRepositories );

                                         }

                                         throw new OverConstrainedVersionException( "Couldn't find a version in " +

                                             versions + " to match range " + versionRange, artifact,

                                             childRemoteRepositories );

                                     }

                                 }

                                 //this is dangerous because artifact.getSelectedVersion() can

                                 //return null. However it is ok here because we first check if the

                                 //selected version is known. As currently coded we can't get a null here.

                                 artifact.selectVersion( version.toString() );

                                 fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, child );

                             }

                             Artifact relocated = source.retrieveRelocatedArtifact( artifact, localRepository, childRemoteRepositories );

                             if ( !artifact.equals( relocated ) )

                             {

                                 relocated.setDependencyFilter( artifact.getDependencyFilter() );

                                 artifact = relocated;

                                 child.setArtifact( artifact );

                             }

                         }

                         while( !childKey.equals( child.getKey() ) );

                         if ( parentArtifact != null && parentArtifact.getDependencyFilter() != null && !parentArtifact.getDependencyFilter().include( artifact ) )

                         {

                             // MNG-3769: the [probably relocated] artifact is excluded. 

                             // We could process exclusions on relocated artifact details in the

                             // MavenMetadataSource.createArtifacts(..) step, BUT that would

                             // require resolving the POM from the repository very early on in

                             // the build.

                             continue;

                         }

                         artifact.setDependencyTrail( node.getDependencyTrail() );

                         ResolutionGroup rGroup = source.retrieve( artifact, localRepository, remoteRepositories );

                         //TODO might be better to have source.retrieve() throw a specific exception for this situation

                         //and catch here rather than have it return null

                         if ( rGroup == null )

                         {

                             //relocated dependency artifact is declared excluded, no need to add and recurse further

                             continue;

                         }

                         child.addDependencies( rGroup.getArtifacts(), rGroup.getResolutionRepositories(), filter );

                     }

                     catch ( CyclicDependencyException e )

                     {

                         // would like to throw this, but we have crappy stuff in the repo

                         fireEvent( ResolutionListener.OMIT_FOR_CYCLE, listeners,

                                    new ResolutionNode( e.getArtifact(), remoteRepositories, child ) );

                     }

                     catch ( ArtifactMetadataRetrievalException e )

                     {

                         artifact.setDependencyTrail( node.getDependencyTrail() );

                         throw new ArtifactResolutionException(

                             "Unable to get dependency information: " + e.getMessage(), artifact, remoteRepositories,

                             e );

                     }

                     recurse( originatingArtifact, child, resolvedArtifacts, managedVersions, localRepository, remoteRepositories, source,

                              filter, listeners );

                 }

             }

             fireEvent( ResolutionListener.FINISH_PROCESSING_CHILDREN, listeners, node );

         }

     }

     private void manageArtifact( ResolutionNode node, ManagedVersionMap managedVersions, List listeners )

     {

         Artifact artifact = (Artifact) managedVersions.get( node.getKey() );

         // Before we update the version of the artifact, we need to know

         // whether we are working on a transitive dependency or not.  This

         // allows depMgmt to always override transitive dependencies, while

         // explicit child override depMgmt (viz. depMgmt should only

         // provide defaults to children, but should override transitives).

         // We can do this by calling isChildOfRootNode on the current node.

         if ( artifact.getVersion() != null

                         && ( node.isChildOfRootNode() ? node.getArtifact().getVersion() == null : true ) )

         {

             fireEvent( ResolutionListener.MANAGE_ARTIFACT_VERSION, listeners, node, artifact );

             node.getArtifact().setVersion( artifact.getVersion() );

         }

         if ( artifact.getScope() != null

                         && ( node.isChildOfRootNode() ? node.getArtifact().getScope() == null : true ) )

         {

             fireEvent( ResolutionListener.MANAGE_ARTIFACT_SCOPE, listeners, node, artifact );

             node.getArtifact().setScope( artifact.getScope() );

         }

     }

     /**

      * Check if the scope needs to be updated.

      * <a href="http://docs.codehaus.org/x/IGU#DependencyMediationandConflictResolution-Scoperesolution">More info</a>.

      *

      * @param farthest  farthest resolution node

      * @param nearest   nearest resolution node

      * @param listeners

      */

     boolean checkScopeUpdate( ResolutionNode farthest, ResolutionNode nearest, List listeners )

     {

         boolean updateScope = false;

         Artifact farthestArtifact = farthest.getArtifact();

         Artifact nearestArtifact = nearest.getArtifact();

         /* farthest is runtime and nearest has lower priority, change to runtime */

         if ( Artifact.SCOPE_RUNTIME.equals( farthestArtifact.getScope() ) && (

             Artifact.SCOPE_TEST.equals( nearestArtifact.getScope() ) ||

                 Artifact.SCOPE_PROVIDED.equals( nearestArtifact.getScope() ) ) )

         {

             updateScope = true;

         }

         /* farthest is compile and nearest is not (has lower priority), change to compile */

         if ( Artifact.SCOPE_COMPILE.equals( farthestArtifact.getScope() ) &&

             !Artifact.SCOPE_COMPILE.equals( nearestArtifact.getScope() ) )

         {

             updateScope = true;

         }

         /* current POM rules all, if nearest is in current pom, do not update its scope */

         if ( nearest.getDepth() < 2 && updateScope )

         {

             updateScope = false;

             fireEvent( ResolutionListener.UPDATE_SCOPE_CURRENT_POM, listeners, nearest, farthestArtifact );

         }

         if ( updateScope )

         {

             fireEvent( ResolutionListener.UPDATE_SCOPE, listeners, nearest, farthestArtifact );

             // previously we cloned the artifact, but it is more effecient to just update the scope

             // if problems are later discovered that the original object needs its original scope value, cloning may

             // again be appropriate

             nearestArtifact.setScope( farthestArtifact.getScope() );

         }

         return updateScope;

     }

     private void fireEvent( int event, List listeners, ResolutionNode node )

     {

         fireEvent( event, listeners, node, null );

     }

     private void fireEvent( int event, List listeners, ResolutionNode node, Artifact replacement )

     {

         fireEvent( event, listeners, node, replacement, null );

     }

     private void fireEvent( int event, List listeners, ResolutionNode node, Artifact replacement,

                             VersionRange newRange )

     {

         for ( Iterator i = listeners.iterator(); i.hasNext(); )

         {

             ResolutionListener listener = (ResolutionListener) i.next();

             switch ( event )

             {

                 case ResolutionListener.TEST_ARTIFACT:

                     listener.testArtifact( node.getArtifact() );

                     break;

                 case ResolutionListener.PROCESS_CHILDREN:

                     listener.startProcessChildren( node.getArtifact() );

                     break;

                 case ResolutionListener.FINISH_PROCESSING_CHILDREN:

                     listener.endProcessChildren( node.getArtifact() );

                     break;

                 case ResolutionListener.INCLUDE_ARTIFACT:

                     listener.includeArtifact( node.getArtifact() );

                     break;

                 case ResolutionListener.OMIT_FOR_NEARER:

                     listener.omitForNearer( node.getArtifact(), replacement );

                     break;

                 case ResolutionListener.OMIT_FOR_CYCLE:

                     listener.omitForCycle( node.getArtifact() );

                     break;

                 case ResolutionListener.UPDATE_SCOPE:

                     listener.updateScope( node.getArtifact(), replacement.getScope() );

                     break;

                 case ResolutionListener.UPDATE_SCOPE_CURRENT_POM:

                     listener.updateScopeCurrentPom( node.getArtifact(), replacement.getScope() );

                     break;

                 case ResolutionListener.MANAGE_ARTIFACT_VERSION:

                     if (listener instanceof ResolutionListenerForDepMgmt) {

                         ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener;

                         asImpl.manageArtifactVersion( node.getArtifact(), replacement );

                     } else {

                         listener.manageArtifact( node.getArtifact(), replacement );

                     }

                     break;

                 case ResolutionListener.MANAGE_ARTIFACT_SCOPE:

                     if (listener instanceof ResolutionListenerForDepMgmt) {

                         ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener;

                         asImpl.manageArtifactScope( node.getArtifact(), replacement );

                     } else {

                         listener.manageArtifact( node.getArtifact(), replacement );

                     }

                     break;

                 case ResolutionListener.SELECT_VERSION_FROM_RANGE:

                     listener.selectVersionFromRange( node.getArtifact() );

                     break;

                 case ResolutionListener.RESTRICT_RANGE:

                     if ( node.getArtifact().getVersionRange().hasRestrictions() ||

                         replacement.getVersionRange().hasRestrictions() )

                     {

                         listener.restrictRange( node.getArtifact(), replacement, newRange );

                     }

                     break;

                 default:

                     throw new IllegalStateException( "Unknown event: " + event );

             }

         }

     }

 }