/*
    * Licensed 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.basepom.mojo.dvc;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  
  import org.basepom.mojo.dvc.dependency.DependencyMap;
  import org.basepom.mojo.dvc.dependency.DependencyMapBuilder;
  import org.basepom.mojo.dvc.dependency.DependencyTreeResolver;
  import org.basepom.mojo.dvc.model.ResolverDefinition;
  import org.basepom.mojo.dvc.model.VersionCheckExcludes;
  import org.basepom.mojo.dvc.strategy.StrategyProvider;
  import org.basepom.mojo.dvc.version.VersionResolutionCollection;
  
  import java.util.Arrays;
  import java.util.List;
  
  import com.google.common.base.Strings;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableSet;
  import com.google.common.collect.ImmutableSetMultimap;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.Component;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.DefaultProjectBuildingRequest;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.ProjectBuilder;
  import org.apache.maven.project.ProjectBuildingRequest;
  import org.apache.maven.project.ProjectDependenciesResolver;
  import org.eclipse.aether.DefaultRepositorySystemSession;
  import org.eclipse.aether.RepositorySystem;
  import org.eclipse.aether.RepositorySystemSession;
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.resolution.VersionRangeRequest;
  import org.eclipse.aether.util.artifact.JavaScopes;
  import org.eclipse.aether.util.graph.version.SnapshotVersionFilter;
  
  /**
   * Base code for all the mojos. Contains the dependency resolvers and the common options.
   */
  public abstract class AbstractDependencyVersionsMojo
          extends AbstractMojo
          implements Context {
  
      private static final ImmutableSet<String> VALID_SCOPES = ImmutableSet.of(
              ScopeLimitingFilter.COMPILE_PLUS_RUNTIME,
              JavaScopes.COMPILE,
              JavaScopes.RUNTIME,
              JavaScopes.TEST);
  
      protected final PluginLog log = new PluginLog(this.getClass());
  
      @Parameter(defaultValue = "${project}", readonly = true)
      public MavenProject project;
  
      @Parameter(defaultValue = "${session}", readonly = true)
      public MavenSession mavenSession;
  
      @Parameter(defaultValue = "${reactorProjects}", readonly = true, required = true)
      public List<MavenProject> reactorProjects;
  
      @Component
      public ProjectBuilder mavenProjectBuilder;
  
      @Component
      public ProjectDependenciesResolver projectDependenciesResolver;
  
      @Component
      public RepositorySystem repositorySystem;
  
      /**
       * The strategy provider. This can be requested by other pieces to add additional strategies.
       */
      @Component
      public StrategyProvider strategyProvider;
  
      /**
       * List of version checks that will be removed from the version check. This allows potential conflicts to be excluded.
       * <br>
       * <pre>
       * &lt;exclusions&gt;
       *   &lt;exclusion&gt;
       *     &lt;dependency&gt;...&lt;/dependency&gt;
      *     &lt;expected&gt;...&lt;/expected&gt;
      *     &lt;resolved&gt;...&lt;/resolved&gt;
      *   &lt;/exclusion&gt;
      * &lt;/exclusions&gt;
      * </pre>
      * <p>
      * Each element consists of a dependency pattern <code>[groupId]:[artifactId]</code> that supports wildcards and an expected version (which is the version
      * is expected by the artifact) and a resolved version (the version that the dependency resolution has chosen).
      * </p>
      */
     @Parameter(alias = "exceptions")
     public VersionCheckExcludes[] exclusions = new VersionCheckExcludes[0];
 
     /**
      * Skip the plugin execution.
      */
     @Parameter(defaultValue = "false", property = "dvc.skip")
     public boolean skip = false;
 
     /**
      * Include POM projects when running on a multi-module project. Dependency resolution on a pom project almost never makes sense as it does not actually
      * build any artifacts.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.include-pom-projects")
     public boolean includePomProjects = false;
 
     /**
      * Silence all non-output and non-error messages.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.quiet")
     public boolean quiet = false;
 
     /**
      * Dependency resolution scope. Defaults to <code>test</code>. Valid choices are <code>compile+runtime</code>, <code>compile</code>,
      * <code>test</code> and <code>runtime</code>.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "test", property = "scope")
     public String scope = JavaScopes.TEST;
 
     /**
      * Use deep scan or regular scan. Deep scan looks at all dependencies in the dependency tree, while regular scan only looks one level deep into the direct
      * dependencies.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.deep-scan")
     public boolean deepScan = false;
 
     /**
      * List only direct dependencies or all dependencies.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.direct-only")
     public boolean directOnly = false;
 
     /**
      * List only managed dependencies or all dependencies.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.managed-only")
     public boolean managedOnly = false;
 
     /**
      * Run dependency resolution in parallel with multiple threads. Should only ever set to <code>false</code> if the plugin shows stability problems when
      * resolving dependencies. Please <a href="issue-management.html">file a bug</a> in that case, too.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "true", property = "dvc.fast-resolution")
     public boolean fastResolution = true;
 
     /**
      * Fail the build if an artifact in <code>system</code> scope can not be resolved. Those are notoriously dependent on the local build environment and some
      * outright fail (e.g. referencing the <code>tools.jar</code>, which no longer exists in a JDK8+ environment).
      * <br>
      * Setting this flag to <code>true</code> will fail the build if any <code>system</code> scoped artifact can not be resolved. This is almost never desired,
      * except when building a project with a direct <code>system</code> scoped dependency.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "false", property = "dvc.unresolved-system-artifacts-fail-build")
     protected boolean unresolvedSystemArtifactsFailBuild = false;
 
     /**
      * Require all optional dependencies to exist and fail the build if any optional dependency can not resolved. This is almost never needed and actually
      * causes problems for some projects that use large public dependencies from central that in turn pull in non-public dependencies as optional.
      *
      * @since 3.2.0
      */
     @Parameter(defaultValue = "false", property = "dvc.optional-dependencies-must-exist")
     protected boolean optionalDependenciesMustExist = false;
 
 
     /**
      * List of resolvers to apply specific strategies to dependencies.
      *
      * <pre>
      * &lt;resolvers&gt;
      *   &lt;resolver&gt;
      *     &lt;strategy&gt;...&lt;strategy&gt;
      *     &lt;includes&gt;
      *       &lt;include&gt;...&lt;include&gt;
      *     &lt;includes&gt;
      *   &lt;resolver&gt;
      * &lt;resolvers&gt;
      * </pre>
      * <p>
      * A resolver maps a specific strategy to a list of includes. The include syntax is <code>[group-id]:[artifact-id]</code> where each pattern segment
      * supports full and partial wildcards (<code>*</code>).
      * <br>
      * The plugin includes some default strategies: <code>apr</code>, <code>default</code>, <code>single-digit</code> and
      * <code>two-digits-backward-compatible</code>. Additional strategies can be defined and added to the plugin classpath.
      */
     @Parameter
     public ResolverDefinition[] resolvers = new ResolverDefinition[0];
 
     /**
      * Sets the default strategy to use to evaluate whether two dependency versions are compatible or not.
      * <p>
      * The <code>default</code> resolution strategy matches the Maven dependency resolution itself; any two dependencies that maven considers compatible will be
      * accepted.
      *
      * @since 3.0.0
      */
     @Parameter(defaultValue = "default", property = "dvc.default-strategy")
     public String defaultStrategy = "default";
 
     protected StrategyCache strategyCache;
     protected RepositorySystemSession snapshotFilteredSession;
 
     @Override
     @SuppressWarnings("PMD.AvoidRethrowingException")
     public void execute()
             throws MojoExecutionException, MojoFailureException {
         try {
             for (VersionCheckExcludes exclusion : exclusions) {
                 checkState(exclusion.isValid(), "Invalid exclusion specification: '%s'", exclusion);
             }
 
             checkState(!Strings.nullToEmpty(scope).trim().isEmpty() && VALID_SCOPES.contains(scope), "Scope '%s' is invalid", scope);
 
             if (skip) {
                 log.report(quiet, "Skipping plugin execution");
                 return;
             }
 
             if (!includePomProjects && "pom".equals(project.getPackaging())) {
                 log.report(quiet, "Ignoring POM project");
                 return;
             }
 
             log.debug("Starting %s mojo run!", this.getClass().getSimpleName());
 
             this.strategyCache = new StrategyCache(strategyProvider, resolvers, defaultStrategy);
             this.snapshotFilteredSession = new DefaultRepositorySystemSession(mavenSession.getRepositorySession())
                     .setVersionFilter(new SnapshotVersionFilter());
 
             final ScopeLimitingFilter scopeFilter = createScopeFilter();
             final DependencyMap rootDependencyMap = new DependencyMapBuilder(this).mapProject(project, scopeFilter);
 
             try (DependencyTreeResolver dependencyTreeResolver = new DependencyTreeResolver(this, rootDependencyMap)) {
                 final ImmutableSetMultimap<QualifiedName, VersionResolutionCollection> resolutionMap = dependencyTreeResolver.computeResolutionMap(project,
                         scopeFilter);
                 doExecute(resolutionMap, rootDependencyMap);
             }
         } catch (MojoExecutionException | MojoFailureException e) {
             throw e;
         } catch (Exception e) {
             throw new MojoExecutionException("While running mojo: ", e);
         } finally {
             log.debug("Ended %s mojo run!", this.getClass().getSimpleName());
         }
     }
 
     /**
      * Subclasses need to implement this method.
      *
      * @param resolutionMap     The prebuilt resolution map from qualified names to version resolution collections.
      * @param rootDependencyMap The prebuilt dependency map for all the root dependencies.
      * @throws Exception When an execution error occurs.
      */
     protected abstract void doExecute(ImmutableSetMultimap<QualifiedName, VersionResolutionCollection> resolutionMap, DependencyMap rootDependencyMap)
             throws Exception;
 
     /**
      * Defines the scope used to resolve the project dependencies. The project dependencies will be limited to the dependencies that match this filter. The list
      * mojo overrides this to limit the scope in which dependencies are listed. By default, include everything.
      *
      * @return The {@link ScopeLimitingFilter} instance for the project dependencies.
      */
     protected ScopeLimitingFilter createScopeFilter() {
         return ScopeLimitingFilter.computeDependencyScope(scope);
     }
 
     @Override
     public boolean useFastResolution() {
         return fastResolution;
     }
 
     @Override
     public boolean useDeepScan() {
         return deepScan;
     }
 
     @Override
     public boolean isOptionalDependenciesMustExist() {
         return optionalDependenciesMustExist;
     }
 
     @Override
     public StrategyCache getStrategyCache() {
         return strategyCache;
     }
 
     @Override
     public ProjectBuilder getProjectBuilder() {
         return mavenProjectBuilder;
     }
 
     @Override
     public ProjectDependenciesResolver getProjectDependenciesResolver() {
         return projectDependenciesResolver;
     }
 
     @Override
     public MavenProject getRootProject() {
         return project;
     }
 
     @Override
     public List<MavenProject> getReactorProjects() {
         return ImmutableList.copyOf(reactorProjects);
     }
 
     @Override
     public RepositorySystemSession getRepositorySystemSession() {
         return snapshotFilteredSession;
     }
 
     @Override
     public RepositorySystem getRepositorySystem() {
         return repositorySystem;
     }
 
     @Override
     public ProjectBuildingRequest createProjectBuildingRequest() {
         DefaultProjectBuildingRequest buildingRequest = new DefaultProjectBuildingRequest(mavenSession.getProjectBuildingRequest());
         buildingRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
         return buildingRequest;
     }
 
     @Override
     public VersionRangeRequest createVersionRangeRequest(Artifact artifact) {
         checkNotNull(artifact, "artifact is null");
         return new VersionRangeRequest(artifact, project.getRemoteProjectRepositories(), "");
     }
 
     @Override
     public List<VersionCheckExcludes> getExclusions() {
         return Arrays.asList(exclusions);
     }
 
     @Override
     public boolean isUnresolvedSystemArtifactsFailBuild() {
         return unresolvedSystemArtifactsFailBuild;
     }
 }