/*
    * 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.util.graph.selector;
  
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.TreeSet;
  
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.collection.DependencyCollectionContext;
  import org.eclipse.aether.collection.DependencySelector;
  import org.eclipse.aether.graph.Dependency;
  import org.eclipse.aether.graph.Exclusion;
  
  import static java.util.Objects.requireNonNull;
  
  /**
   * A dependency selector that applies exclusions based on artifact coordinates.
   *
   * @see Dependency#getExclusions()
   */
  public final class ExclusionDependencySelector implements DependencySelector {
  
      // sorted and dupe-free array, faster to iterate than LinkedHashSet
      private final Exclusion[] exclusions;
  
      private int hashCode;
  
      /**
       * Creates a new selector without any exclusions.
       */
      public ExclusionDependencySelector() {
          this.exclusions = new Exclusion[0];
      }
  
      /**
       * Creates a new selector with the specified exclusions.
       *
       * @param exclusions The exclusions, may be {@code null}.
       */
      public ExclusionDependencySelector(Collection<Exclusion> exclusions) {
          if (exclusions != null && !exclusions.isEmpty()) {
              TreeSet<Exclusion> sorted = new TreeSet<>(ExclusionComparator.INSTANCE);
              sorted.addAll(exclusions);
              this.exclusions = sorted.toArray(new Exclusion[0]);
          } else {
              this.exclusions = new Exclusion[0];
          }
      }
  
      private ExclusionDependencySelector(Exclusion[] exclusions) {
          this.exclusions = exclusions;
      }
  
      public boolean selectDependency(Dependency dependency) {
          requireNonNull(dependency, "dependency cannot be null");
          Artifact artifact = dependency.getArtifact();
          for (Exclusion exclusion : exclusions) {
              if (matches(exclusion, artifact)) {
                  return false;
              }
          }
          return true;
      }
  
      private boolean matches(Exclusion exclusion, Artifact artifact) {
          if (!matches(exclusion.getArtifactId(), artifact.getArtifactId())) {
              return false;
          }
          if (!matches(exclusion.getGroupId(), artifact.getGroupId())) {
              return false;
          }
          if (!matches(exclusion.getExtension(), artifact.getExtension())) {
              return false;
          }
          return matches(exclusion.getClassifier(), artifact.getClassifier());
      }
  
      private boolean matches(String pattern, String value) {
          return "*".equals(pattern) || pattern.equals(value);
      }
  
     public DependencySelector deriveChildSelector(DependencyCollectionContext context) {
         requireNonNull(context, "context cannot be null");
         Dependency dependency = context.getDependency();
         Collection<Exclusion> exclusions = (dependency != null) ? dependency.getExclusions() : null;
         if (exclusions == null || exclusions.isEmpty()) {
             return this;
         }
 
         Exclusion[] merged = this.exclusions;
         int count = merged.length;
         for (Exclusion exclusion : exclusions) {
             int index = Arrays.binarySearch(merged, exclusion, ExclusionComparator.INSTANCE);
             if (index < 0) {
                 index = -(index + 1);
                 if (count >= merged.length) {
                     Exclusion[] tmp = new Exclusion[merged.length + exclusions.size()];
                     System.arraycopy(merged, 0, tmp, 0, index);
                     tmp[index] = exclusion;
                     System.arraycopy(merged, index, tmp, index + 1, count - index);
                     merged = tmp;
                 } else {
                     System.arraycopy(merged, index, merged, index + 1, count - index);
                     merged[index] = exclusion;
                 }
                 count++;
             }
         }
         if (merged == this.exclusions) {
             return this;
         }
         if (merged.length != count) {
             Exclusion[] tmp = new Exclusion[count];
             System.arraycopy(merged, 0, tmp, 0, count);
             merged = tmp;
         }
 
         return new ExclusionDependencySelector(merged);
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         } else if (null == obj || !getClass().equals(obj.getClass())) {
             return false;
         }
 
         ExclusionDependencySelector that = (ExclusionDependencySelector) obj;
         return Arrays.equals(exclusions, that.exclusions);
     }
 
     @Override
     public int hashCode() {
         if (hashCode == 0) {
             int hash = getClass().hashCode();
             hash = hash * 31 + Arrays.hashCode(exclusions);
             hashCode = hash;
         }
         return hashCode;
     }
 
     @Override
     public String toString() {
         StringBuilder builder =
                 new StringBuilder().append(this.getClass().getSimpleName()).append('(');
         for (int i = 0; i < this.exclusions.length; i++) {
             builder.append(this.exclusions[i]);
             if (i < this.exclusions.length - 1) {
                 builder.append(", ");
             }
         }
         return builder.append(')').toString();
     }
 
     private static class ExclusionComparator implements Comparator<Exclusion> {
 
         static final ExclusionComparator INSTANCE = new ExclusionComparator();
 
         public int compare(Exclusion e1, Exclusion e2) {
             if (e1 == null) {
                 return (e2 == null) ? 0 : 1;
             } else if (e2 == null) {
                 return -1;
             }
             int rel = e1.getArtifactId().compareTo(e2.getArtifactId());
             if (rel == 0) {
                 rel = e1.getGroupId().compareTo(e2.getGroupId());
                 if (rel == 0) {
                     rel = e1.getExtension().compareTo(e2.getExtension());
                     if (rel == 0) {
                         rel = e1.getClassifier().compareTo(e2.getClassifier());
                     }
                 }
             }
             return rel;
         }
     }
 }