/*******************************************************************************
    * Copyright (c) 2008, 2011 Sonatype Inc. and others.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *    Sonatype Inc. - initial API and implementation
   *******************************************************************************/
  package com.simpligility.maven.plugins.androidndk.common;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
  import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
  import org.apache.maven.artifact.resolver.ArtifactResolver;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.codehaus.plexus.logging.Logger;
  
  import java.io.File;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  
  /**
   * Provides convenient functions for resolving artifacts.
   */
  public final class ArtifactResolverHelper
  {
      /**
       * Which dependency scopes should be excluded when packing dependencies into the apk.
       */
      public static final List<String> EXCLUDE_NON_PACKAGED_SCOPES = Arrays.asList(
              Artifact.SCOPE_PROVIDED, Artifact.SCOPE_IMPORT
      );
  
      private final ArtifactResolver artifactResolver;
      private final Logger log;
      private final List<ArtifactRepository> remoteArtifactRepositories;
  
      /**
       * Creates an ArtifactResolver that has no remote repositories to resolve against.
       */
      public ArtifactResolverHelper( ArtifactResolver artifactResolver, Logger log )
      {
          this( artifactResolver, log, Collections.<ArtifactRepository>emptyList() );
      }
  
      public ArtifactResolverHelper( ArtifactResolver artifactResolver, Logger log,
                                    final List<ArtifactRepository> remoteArtifactRepositories )
      {
          this.artifactResolver = artifactResolver;
          this.log = log;
          this.remoteArtifactRepositories = remoteArtifactRepositories;
      }
  
      /**
       * Filters provided artifacts and selects only defined types based on {@code types} argument
       * or all types if {@code types} argument is empty.
       *
       * @param allArtifacts artifacts to be filtered
       * @param types artifact types to be selected
       * @return a {@code List} of all project dependencies. Never {@code null}.
       *      This excludes artifacts of the {@code EXCLUDED_DEPENDENCY_SCOPES} scopes.
       *      And this should maintain dependency order to comply with library project resource precedence.
       */
      public Set<Artifact> getFilteredArtifacts( Iterable<Artifact> allArtifacts, String... types )
      {
          return getFilteredArtifacts( EXCLUDE_NON_PACKAGED_SCOPES, allArtifacts, types );
      }
  
      /**
       * Filters provided artifacts and selects only defined types based on {@code types} argument
       * or all types if {@code types} argument is empty.
       *
       * @param filteredScopes scopes to be filtered
       * @param allArtifacts artifacts to be filtered
       * @param types artifact types to be selected
       * @return a {@code List} of all project dependencies. Never {@code null}.
       *      This should maintain dependency order to comply with library project resource precedence.
       */
      public Set<Artifact> getFilteredArtifacts( List<String> filteredScopes,
                                                 Iterable<Artifact> allArtifacts, String... types )
      {
          final List<String> acceptTypeList = Arrays.asList( types );
          boolean acceptAllArtifacts = acceptTypeList.isEmpty();
          final Set<Artifact> results = new LinkedHashSet<Artifact>();
          for ( Artifact artifact : allArtifacts )
          {
              if ( artifact == null )
              {
                  continue;
              }
  
              if ( filteredScopes.contains( artifact.getScope() ) )
             {
                 continue;
             }
 
             if ( acceptAllArtifacts || acceptTypeList.contains( artifact.getType() ) )
             {
                 results.add( artifact );
             }
         }
         return results;
     }
 
     /**
      * Attempts to resolve an {@link org.apache.maven.artifact.Artifact} to a {@link java.io.File}.
      *
      * @param artifact to resolve
      * @return a {@link java.io.File} to the resolved artifact, never <code>null</code>.
      * @throws org.apache.maven.plugin.MojoExecutionException if the artifact could not be resolved.
      */
     public File resolveArtifactToFile( Artifact artifact ) throws MojoExecutionException
     {
         final Artifact resolvedArtifact = resolveArtifact( artifact );
         final File jar = resolvedArtifact.getFile();
         if ( jar == null )
         {
             throw new MojoExecutionException( "Could not resolve artifact " + artifact.getId()
                     + ". Please install it with \"mvn install:install-file ...\" or deploy it to a repository "
                     + "with \"mvn deploy:deploy-file ...\"" );
         }
         return jar;
     }
 
     public Set<Artifact> resolveArtifacts( Collection<Artifact> artifacts ) throws MojoExecutionException
     {
         final Set<Artifact> resolvedArtifacts = new LinkedHashSet<Artifact>();
         for ( final Artifact artifact : artifacts )
         {
             resolvedArtifacts.add( resolveArtifact( artifact ) );
         }
         return resolvedArtifacts;
     }
 
     /**
      * Resolves an artifact to a particular repository.
      *
      * @param artifact  Artifact to resolve
      * @return fully resolved artifact.
      */
     private Artifact resolveArtifact( Artifact artifact ) throws MojoExecutionException
     {
         final ArtifactResolutionRequest artifactResolutionRequest = new ArtifactResolutionRequest();
         artifactResolutionRequest.setArtifact( artifact );
         if ( remoteArtifactRepositories != null && !remoteArtifactRepositories.isEmpty() )
         {
             artifactResolutionRequest.setRemoteRepositories( remoteArtifactRepositories );
         }
         final ArtifactResolutionResult resolutionResult = this.artifactResolver.resolve( artifactResolutionRequest );
 
         log.debug( "Resolving : " + artifact );
         if ( resolutionResult.getArtifacts().size() == 0 )
         {
             throw new MojoExecutionException( "Could not resolve artifact " + artifact
                     + ". Please install it with \"mvn install:install-file ...\" or deploy it to a repository "
                     + "with \"mvn deploy:deploy-file ...\"" );
         }
         if ( resolutionResult.getArtifacts().size() > 1 )
         {
             log.debug( "Resolved artifacts : " + resolutionResult.getArtifacts() );
             throw new MojoExecutionException( "Could not resolve artifact " + artifact
                     + " to single target. Found the following possible options : " + resolutionResult.getArtifacts() );
         }
 
         final Artifact resolvedArtifact = resolutionResult.getArtifacts().iterator().next();
         log.debug( "Resolved : " + resolvedArtifact );
         return resolvedArtifact;
     }
 }