package org.apache.maven.shared.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.ProjectDependenciesResolver;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
  import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
  import org.apache.maven.artifact.resolver.ArtifactResolutionException;
  import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
  import org.apache.maven.artifact.resolver.ArtifactResolver;
  import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.artifact.InvalidDependencyVersionException;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.Set;
  
  /**
   * Default implementation of {@link ProjectDependenciesResolver}. <strong>Warning:</strong> This is an internal utility
   * class that is only public for technical reasons, it is not part of the public API. In particular, this class can
   * be changed or deleted without prior notice.
   * 
   * @author jdcasey
   * 
   * @see ProjectDependenciesResolver
   * @plexus.component role="org.apache.maven.ProjectDependenciesResolver" role-hint="default"
   */
  public final class DefaultProjectDependenciesResolver
      implements ProjectDependenciesResolver
  {
  
      /**
       * @plexus.requirement
       */
      private ArtifactResolver resolver;
  
      /**
       * @plexus.requirement
       */
      private ArtifactFactory artifactFactory;
  
      /**
       * @plexus.requirement role-hint="maven"
       */
      private ArtifactMetadataSource metadataSource;
      
      // for plexus instantiation.
      public DefaultProjectDependenciesResolver()
      {
      }
  
      // for testing.
      DefaultProjectDependenciesResolver( ArtifactResolver resolver, ArtifactFactory artifactFactory,
                                          ArtifactMetadataSource metadataSource )
      {
          this.resolver = resolver;
          this.artifactFactory = artifactFactory;
          this.metadataSource = metadataSource;
      }
  
      /**
       * {@inheritDoc}
       */
      @SuppressWarnings( "unchecked" )
      public Set<Artifact> resolve( final Collection<? extends MavenProject> projects, final Collection<String> scopes,
                                    final MavenSession session )
          throws ArtifactResolutionException, ArtifactNotFoundException
      {
          Set<Artifact> resolved = new LinkedHashSet<Artifact>();
  
          if ( projects == null || projects.isEmpty() )
          {
              return resolved;
          }
  
         CumulativeScopeArtifactFilter scopeFilter = new CumulativeScopeArtifactFilter( scopes );
         
         for ( MavenProject proj : projects )
         {
             Set<Artifact> depArtifacts = proj.getDependencyArtifacts();
             if ( depArtifacts == null )
             {
                 try
                 {
                     depArtifacts = proj.createArtifacts( artifactFactory, null, scopeFilter );
                 }
                 catch ( InvalidDependencyVersionException e )
                 {
                     throw new ArtifactResolutionException( "Failed to create Artifact instances for project "
                         + "dependencies: " + e.getMessage(), null, e );
                 }
             }
             
             if ( depArtifacts == null || depArtifacts.isEmpty() )
             {
                 continue;
             }
             
             for ( Iterator<Artifact> it = depArtifacts.iterator(); it.hasNext(); )
             {
                 Artifact artifact = it.next();
                 if ( resolved.contains( artifact ) )
                 {
                     // already resolved, don't do it again.
                     it.remove();
                 }
             }
             
             Artifact projectArtifact = proj.getArtifact();
             if ( projectArtifact == null )
             {
                 projectArtifact = artifactFactory.createProjectArtifact( proj.getGroupId(), proj.getArtifactId(),
                                                                      proj.getVersion() );
             }
             
             try
             {
                 ArtifactResolutionResult result = resolver.resolveTransitively( depArtifacts, projectArtifact,
                                                                                 proj.getManagedVersionMap(),
                                                                                 session.getLocalRepository(),
                                                                                 proj.getRemoteArtifactRepositories(),
                                                                                 metadataSource, scopeFilter );
 
                 if ( result.getArtifacts() != null && !result.getArtifacts().isEmpty() )
                 {
                     resolved.addAll( result.getArtifacts() );
                 }
             }
             catch ( MultipleArtifactsNotFoundException me )
             {
                 Set<String> projectIds = getProjectIds( projects );
                 Collection<Artifact> missing = new HashSet<Artifact>( me.getMissingArtifacts() );
                 for ( Iterator<Artifact> it = missing.iterator(); it.hasNext(); )
                 {
                     Artifact artifact = it.next();
                     if ( projectIds.contains( getProjectReferenceId( artifact.getGroupId(), artifact.getArtifactId(),
                                                                      artifact.getVersion() ) ) )
                     {
                         it.remove();
                     }
                 }
 
                 if ( missing.isEmpty() )
                 {
                     resolved.addAll( me.getResolvedArtifacts() );
                 }
                 else
                 {
                     throw me;
                 }
             }
         }
         
         return resolved;
     }
 
     /**
      * {@inheritDoc}
      */
     public Set<Artifact> resolve( final MavenProject project, final Collection<String> scopes,
                                   final MavenSession session )
         throws ArtifactResolutionException, ArtifactNotFoundException
     {
         Collection<MavenProject> projects = Collections.singleton( project );
 
         return resolve( projects, scopes, session );
     }
 
     private Set<String> getProjectIds( final Collection<? extends MavenProject> projects )
     {
         Set<String> ids = new HashSet<String>();
         if ( projects != null && !projects.isEmpty() )
         {
             for ( MavenProject project : projects )
             {
                 ids.add( getProjectReferenceId( project.getGroupId(), project.getArtifactId(), project.getVersion() ) );
             }
         }
 
         return ids;
     }
 
     private static String getProjectReferenceId( String groupId, String artifactId, String version )
     {
         return groupId + ":" + artifactId + ":" + version;
     }
 
 }