/*
    * 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.
   */
  package org.eclipse.aether.internal.impl.scope;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.Set;
  import java.util.concurrent.atomic.AtomicReference;
  import java.util.stream.Collectors;
  
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.collection.CollectResult;
  import org.eclipse.aether.collection.DependencyGraphTransformer;
  import org.eclipse.aether.collection.DependencySelector;
  import org.eclipse.aether.graph.DependencyFilter;
  import org.eclipse.aether.impl.scope.BuildPath;
  import org.eclipse.aether.impl.scope.BuildScope;
  import org.eclipse.aether.impl.scope.BuildScopeQuery;
  import org.eclipse.aether.impl.scope.BuildScopeSource;
  import org.eclipse.aether.impl.scope.InternalScopeManager;
  import org.eclipse.aether.impl.scope.ProjectPath;
  import org.eclipse.aether.impl.scope.ScopeManagerConfiguration;
  import org.eclipse.aether.scope.DependencyScope;
  import org.eclipse.aether.scope.ResolutionScope;
  import org.eclipse.aether.scope.SystemDependencyScope;
  import org.eclipse.aether.util.filter.ScopeDependencyFilter;
  import org.eclipse.aether.util.graph.selector.AndDependencySelector;
  import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector;
  import org.eclipse.aether.util.graph.transformer.ChainedDependencyGraphTransformer;
  import org.eclipse.aether.util.graph.transformer.ConfigurableVersionSelector;
  import org.eclipse.aether.util.graph.transformer.ConflictResolver;
  import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector;
  import org.eclipse.aether.util.graph.visitor.CloningDependencyVisitor;
  import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor;
  
  import static java.util.Objects.requireNonNull;
  
  public final class ScopeManagerImpl implements InternalScopeManager {
      private final String id;
      private final boolean strictDependencyScopes;
      private final boolean strictResolutionScopes;
      private final BuildScopeSource buildScopeSource;
      private final AtomicReference<SystemDependencyScopeImpl> systemDependencyScope;
      private final Map<String, DependencyScopeImpl> dependencyScopes;
      private final Map<String, ResolutionScopeImpl> resolutionScopes;
  
      public ScopeManagerImpl(ScopeManagerConfiguration configuration) {
          this.id = configuration.getId();
          this.strictDependencyScopes = configuration.isStrictDependencyScopes();
          this.strictResolutionScopes = configuration.isStrictResolutionScopes();
          this.buildScopeSource = configuration.getBuildScopeSource();
          this.systemDependencyScope = new AtomicReference<>(null);
          this.dependencyScopes = Collections.unmodifiableMap(buildDependencyScopes(configuration));
          this.resolutionScopes = Collections.unmodifiableMap(buildResolutionScopes(configuration));
      }
  
      private Map<String, DependencyScopeImpl> buildDependencyScopes(ScopeManagerConfiguration configuration) {
          Collection<DependencyScope> dependencyScopes = configuration.buildDependencyScopes(this);
          HashMap<String, DependencyScopeImpl> result = new HashMap<>(dependencyScopes.size());
          dependencyScopes.forEach(d -> result.put(d.getId(), (DependencyScopeImpl) d));
          return result;
      }
  
      private Map<String, ResolutionScopeImpl> buildResolutionScopes(ScopeManagerConfiguration configuration) {
          Collection<ResolutionScope> resolutionScopes = configuration.buildResolutionScopes(this);
          HashMap<String, ResolutionScopeImpl> result = new HashMap<>(resolutionScopes.size());
          resolutionScopes.forEach(r -> result.put(r.getId(), (ResolutionScopeImpl) r));
          return result;
      }
  
      @Override
      public String getId() {
          return id;
      }
  
      @Override
      public Optional<SystemDependencyScope> getSystemDependencyScope() {
         return Optional.ofNullable(systemDependencyScope.get());
     }
 
     @Override
     public Optional<DependencyScope> getDependencyScope(String id) {
         DependencyScope dependencyScope = dependencyScopes.get(id);
         if (strictDependencyScopes && dependencyScope == null) {
             throw new IllegalArgumentException("unknown dependency scope");
         }
         return Optional.ofNullable(dependencyScope);
     }
 
     @Override
     public Collection<DependencyScope> getDependencyScopeUniverse() {
         return new HashSet<>(dependencyScopes.values());
     }
 
     @Override
     public Optional<ResolutionScope> getResolutionScope(String id) {
         ResolutionScope resolutionScope = resolutionScopes.get(id);
         if (strictResolutionScopes && resolutionScope == null) {
             throw new IllegalArgumentException("unknown resolution scope");
         }
         return Optional.ofNullable(resolutionScope);
     }
 
     @Override
     public Collection<ResolutionScope> getResolutionScopeUniverse() {
         return new HashSet<>(resolutionScopes.values());
     }
 
     @Override
     public int getDependencyScopeWidth(DependencyScope dependencyScope) {
         return translate(dependencyScope).getWidth();
     }
 
     @Override
     public Optional<BuildScope> getDependencyScopeMainProjectBuildScope(DependencyScope dependencyScope) {
         return Optional.ofNullable(translate(dependencyScope).getMainBuildScope());
     }
 
     @Override
     public DependencySelector getDependencySelector(ResolutionScope resolutionScope) {
         ResolutionScopeImpl rs = translate(resolutionScope);
         Set<String> directlyExcludedLabels = getDirectlyExcludedLabels(rs);
         Set<String> transitivelyExcludedLabels = getTransitivelyExcludedLabels(rs);
 
         return new AndDependencySelector(
                 rs.getMode() == Mode.ELIMINATE
                         ? ScopeDependencySelector.fromTo(2, 2, null, directlyExcludedLabels)
                         : ScopeDependencySelector.fromTo(1, 2, null, directlyExcludedLabels),
                 ScopeDependencySelector.from(2, null, transitivelyExcludedLabels),
                 OptionalDependencySelector.fromDirect(),
                 new ExclusionDependencySelector());
     }
 
     @Override
     public DependencyGraphTransformer getDependencyGraphTransformer(ResolutionScope resolutionScope) {
         return new ChainedDependencyGraphTransformer(
                 new ConflictResolver(
                         new ConfigurableVersionSelector(), new ManagedScopeSelector(this),
                         new SimpleOptionalitySelector(), new ManagedScopeDeriver(this)),
                 new ManagedDependencyContextRefiner(this));
     }
 
     @Override
     public CollectResult postProcess(ResolutionScope resolutionScope, CollectResult collectResult) {
         ResolutionScopeImpl rs = translate(resolutionScope);
         if (rs.getMode() == Mode.ELIMINATE) {
             CloningDependencyVisitor cloning = new CloningDependencyVisitor();
             FilteringDependencyVisitor filter = new FilteringDependencyVisitor(
                     cloning, new ScopeDependencyFilter(null, getDirectlyExcludedLabels(rs)));
             collectResult.getRoot().accept(filter);
             collectResult.setRoot(cloning.getRootNode());
         }
         return collectResult;
     }
 
     @Override
     public DependencyFilter getDependencyFilter(ResolutionScope resolutionScope) {
         return new ScopeDependencyFilter(null, getDirectlyExcludedLabels(translate(resolutionScope)));
     }
 
     @Override
     public DependencyScope createDependencyScope(String id, boolean transitive, Collection<BuildScopeQuery> presence) {
         return new DependencyScopeImpl(id, transitive, presence);
     }
 
     @Override
     public SystemDependencyScope createSystemDependencyScope(
             String id, boolean transitive, Collection<BuildScopeQuery> presence, String systemPathProperty) {
         SystemDependencyScopeImpl system = new SystemDependencyScopeImpl(id, transitive, presence, systemPathProperty);
         if (systemDependencyScope.compareAndSet(null, system)) {
             return system;
         } else {
             throw new IllegalStateException("system dependency scope already created");
         }
     }
 
     @Override
     public ResolutionScope createResolutionScope(
             String id,
             Mode mode,
             Collection<BuildScopeQuery> wantedPresence,
             Collection<DependencyScope> explicitlyIncluded,
             Collection<DependencyScope> transitivelyExcluded) {
         return new ResolutionScopeImpl(id, mode, wantedPresence, explicitlyIncluded, transitivelyExcluded);
     }
 
     private Set<DependencyScope> collectScopes(Collection<BuildScopeQuery> wantedPresence) {
         HashSet<DependencyScope> result = new HashSet<>();
         for (BuildScope buildScope : buildScopeSource.query(wantedPresence)) {
             dependencyScopes.values().stream()
                     .filter(s -> buildScopeSource.query(s.getPresence()).contains(buildScope))
                     .filter(s -> systemDependencyScope.get() == null
                             || !systemDependencyScope.get().is(s.id)) // system scope must be always explicitly added
                     .forEach(result::add);
         }
         return result;
     }
 
     private int calculateDependencyScopeWidth(DependencyScopeImpl dependencyScope) {
         int result = 0;
         if (dependencyScope.isTransitive()) {
             result += 1000;
         }
         for (BuildScope buildScope : buildScopeSource.query(dependencyScope.getPresence())) {
             result += 1000
                     / buildScope.getProjectPaths().stream()
                             .map(ProjectPath::order)
                             .reduce(0, Integer::sum);
         }
         return result;
     }
 
     private BuildScope calculateMainProjectBuildScope(DependencyScopeImpl dependencyScope) {
         for (ProjectPath projectPath : buildScopeSource.allProjectPaths().stream()
                 .sorted(Comparator.comparing(ProjectPath::order))
                 .collect(Collectors.toList())) {
             for (BuildPath buildPath : buildScopeSource.allBuildPaths().stream()
                     .sorted(Comparator.comparing(BuildPath::order))
                     .collect(Collectors.toList())) {
                 for (BuildScope buildScope : buildScopeSource.query(dependencyScope.getPresence())) {
                     if (buildScope.getProjectPaths().contains(projectPath)
                             && buildScope.getBuildPaths().contains(buildPath)) {
                         return buildScope;
                     }
                 }
             }
         }
         return null;
     }
 
     /**
      * Visible for testing.
      */
     Set<String> getDirectlyIncludedLabels(ResolutionScope resolutionScope) {
         return translate(resolutionScope).getDirectlyIncluded().stream()
                 .map(DependencyScope::getId)
                 .collect(Collectors.toSet());
     }
 
     /**
      * Visible for testing.
      */
     Set<String> getDirectlyExcludedLabels(ResolutionScope resolutionScope) {
         ResolutionScopeImpl rs = translate(resolutionScope);
         return dependencyScopes.values().stream()
                 .filter(s -> !rs.getDirectlyIncluded().contains(s))
                 .map(DependencyScope::getId)
                 .collect(Collectors.toSet());
     }
 
     /**
      * Visible for testing.
      */
     Set<String> getTransitivelyExcludedLabels(ResolutionScope resolutionScope) {
         return translate(resolutionScope).getTransitivelyExcluded().stream()
                 .map(DependencyScope::getId)
                 .collect(Collectors.toSet());
     }
 
     /**
      * Visible for testing.
      */
     Set<BuildScopeQuery> getPresence(DependencyScope dependencyScope) {
         return translate(dependencyScope).getPresence();
     }
 
     /**
      * Visible for testing.
      */
     BuildScopeSource getBuildScopeSource() {
         return buildScopeSource;
     }
 
     private DependencyScopeImpl translate(DependencyScope dependencyScope) {
         return requireNonNull(dependencyScopes.get(dependencyScope.getId()), "unknown dependency scope");
     }
 
     private ResolutionScopeImpl translate(ResolutionScope resolutionScope) {
         return requireNonNull(resolutionScopes.get(resolutionScope.getId()), "unknown resolution scope");
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         ScopeManagerImpl that = (ScopeManagerImpl) o;
         return Objects.equals(id, that.id);
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(id);
     }
 
     @Override
     public String toString() {
         return id;
     }
 
     private class DependencyScopeImpl implements DependencyScope {
         private final String id;
         private final boolean transitive;
         private final Set<BuildScopeQuery> presence;
         private final BuildScope mainBuildScope;
         private final int width;
 
         private DependencyScopeImpl(String id, boolean transitive, Collection<BuildScopeQuery> presence) {
             this.id = requireNonNull(id, "id");
             this.transitive = transitive;
             this.presence = Collections.unmodifiableSet(new HashSet<>(presence));
             this.mainBuildScope = calculateMainProjectBuildScope(this);
             this.width = calculateDependencyScopeWidth(this);
         }
 
         @Override
         public String getId() {
             return id;
         }
 
         @Override
         public boolean isTransitive() {
             return transitive;
         }
 
         public Set<BuildScopeQuery> getPresence() {
             return presence;
         }
 
         public BuildScope getMainBuildScope() {
             return mainBuildScope;
         }
 
         public int getWidth() {
             return width;
         }
 
         @Override
         public boolean equals(Object o) {
             if (this == o) {
                 return true;
             }
             if (o == null || getClass() != o.getClass()) {
                 return false;
             }
             DependencyScopeImpl that = (DependencyScopeImpl) o;
             return Objects.equals(id, that.id);
         }
 
         @Override
         public int hashCode() {
             return Objects.hash(id);
         }
 
         @Override
         public String toString() {
             return id;
         }
     }
 
     private class SystemDependencyScopeImpl extends DependencyScopeImpl implements SystemDependencyScope {
         private final String systemPathProperty;
 
         private SystemDependencyScopeImpl(
                 String id, boolean transitive, Collection<BuildScopeQuery> presence, String systemPathProperty) {
             super(id, transitive, presence);
             this.systemPathProperty = requireNonNull(systemPathProperty);
         }
 
         @Override
         public String getSystemPath(Artifact artifact) {
             return artifact.getProperty(systemPathProperty, null);
         }
 
         @Override
         public void setSystemPath(Map<String, String> properties, String systemPath) {
             if (systemPath == null) {
                 properties.remove(systemPathProperty);
             } else {
                 properties.put(systemPathProperty, systemPath);
             }
         }
     }
 
     private class ResolutionScopeImpl implements ResolutionScope {
 
         private final String id;
         private final Mode mode;
         private final Set<BuildScopeQuery> wantedPresence;
         private final Set<DependencyScope> directlyIncluded;
         private final Set<DependencyScope> transitivelyExcluded;
 
         private ResolutionScopeImpl(
                 String id,
                 Mode mode,
                 Collection<BuildScopeQuery> wantedPresence,
                 Collection<DependencyScope> explicitlyIncluded,
                 Collection<DependencyScope> transitivelyExcluded) {
             this.id = requireNonNull(id, "id");
             this.mode = requireNonNull(mode, "mode");
             this.wantedPresence = Collections.unmodifiableSet(new HashSet<>(wantedPresence));
             Set<DependencyScope> included = collectScopes(wantedPresence);
             // here we may have null elements, based on existence of system scope
             if (explicitlyIncluded != null && !explicitlyIncluded.isEmpty()) {
                 explicitlyIncluded.stream().filter(Objects::nonNull).forEach(included::add);
             }
             this.directlyIncluded = Collections.unmodifiableSet(included);
             this.transitivelyExcluded = Collections.unmodifiableSet(
                     transitivelyExcluded.stream().filter(Objects::nonNull).collect(Collectors.toSet()));
         }
 
         @Override
         public String getId() {
             return id;
         }
 
         public Mode getMode() {
             return mode;
         }
 
         public Set<BuildScopeQuery> getWantedPresence() {
             return wantedPresence;
         }
 
         public Set<DependencyScope> getDirectlyIncluded() {
             return directlyIncluded;
         }
 
         public Set<DependencyScope> getTransitivelyExcluded() {
             return transitivelyExcluded;
         }
 
         @Override
         public boolean equals(Object o) {
             if (this == o) {
                 return true;
             }
             if (o == null || getClass() != o.getClass()) {
                 return false;
             }
             ResolutionScopeImpl that = (ResolutionScopeImpl) o;
             return Objects.equals(id, that.id);
         }
 
         @Override
         public int hashCode() {
             return Objects.hash(id);
         }
 
         @Override
         public String toString() {
             return id;
         }
     }
 }