/*
    * 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.apache.maven.shared.artifact.filter;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Objects;
  import java.util.Set;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
  import org.apache.maven.artifact.versioning.VersionRange;
  import org.slf4j.Logger;
  
  /**
   * TODO: include in maven-artifact in future
   *
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   * @see StrictPatternIncludesArtifactFilter
   */
  public class GNPatternIncludesArtifactFilter implements ArtifactFilter, StatisticsReportingArtifactFilter {
      /** Holds the set of compiled patterns */
      private final Set<Pattern> patterns;
  
      /** Whether the dependency trail should be checked */
      private final boolean actTransitively;
  
      /** Set of patterns that have been triggered */
      private final Set<Pattern> patternsTriggered = new HashSet<>();
  
      /** Set of artifacts that have been filtered out */
      private final List<Artifact> filteredArtifact = new ArrayList<>();
  
      /**
       * <p>Constructor for PatternIncludesArtifactFilter.</p>
       *
       * @param patterns The pattern to be used.
       */
      public GNPatternIncludesArtifactFilter(final Collection<String> patterns) {
          this(patterns, false);
      }
  
      /**
       * <p>Constructor for PatternIncludesArtifactFilter.</p>
       *
       * @param patterns The pattern to be used.
       * @param actTransitively transitive yes/no.
       */
      public GNPatternIncludesArtifactFilter(final Collection<String> patterns, final boolean actTransitively) {
          this.actTransitively = actTransitively;
          final Set<Pattern> pat = new LinkedHashSet<>();
          if (patterns != null && !patterns.isEmpty()) {
              for (String pattern : patterns) {
  
                  Pattern p = compile(pattern);
                  pat.add(p);
              }
          }
          this.patterns = pat;
      }
  
      /** {@inheritDoc} */
      public boolean include(final Artifact artifact) {
          final boolean shouldInclude = patternMatches(artifact);
  
          if (!shouldInclude) {
              addFilteredArtifact(artifact);
          }
  
          return shouldInclude;
      }
  
      /**
       * <p>patternMatches.</p>
       *
       * @param artifact to check for.
       * @return true if the match is true false otherwise.
      */
     protected boolean patternMatches(final Artifact artifact) {
         // Check if the main artifact matches
         char[][] artifactGatvCharArray = new char[][] {
             emptyOrChars(artifact.getGroupId()),
             emptyOrChars(artifact.getArtifactId()),
             emptyOrChars(artifact.getType()),
             emptyOrChars(artifact.getClassifier()),
             emptyOrChars(artifact.getBaseVersion())
         };
         Boolean match = match(artifactGatvCharArray);
         if (match != null) {
             return match;
         }
 
         if (actTransitively) {
             final List<String> depTrail = artifact.getDependencyTrail();
 
             if (depTrail != null && depTrail.size() > 1) {
                 for (String trailItem : depTrail) {
                     char[][] depGatvCharArray = tokenizeAndSplit(trailItem);
                     match = match(depGatvCharArray);
                     if (match != null) {
                         return match;
                     }
                 }
             }
         }
 
         return false;
     }
 
     private Boolean match(char[][] gatvCharArray) {
         for (Pattern pattern : patterns) {
             if (pattern.matches(gatvCharArray)) {
                 patternsTriggered.add(pattern);
                 return !(pattern instanceof NegativePattern);
             }
         }
 
         return null;
     }
 
     /**
      * <p>addFilteredArtifact.</p>
      *
      * @param artifact add artifact to the filtered artifacts list.
      */
     protected void addFilteredArtifact(final Artifact artifact) {
         filteredArtifact.add(artifact);
     }
 
     /** {@inheritDoc} */
     public void reportMissedCriteria(final Logger logger) {
         // if there are no patterns, there is nothing to report.
         if (!patterns.isEmpty()) {
             final List<Pattern> missed = new ArrayList<>(patterns);
             missed.removeAll(patternsTriggered);
 
             if (!missed.isEmpty() && logger.isWarnEnabled()) {
                 final StringBuilder buffer = new StringBuilder();
 
                 buffer.append("The following patterns were never triggered in this ");
                 buffer.append(getFilterDescription());
                 buffer.append(':');
 
                 for (Pattern pattern : missed) {
                     buffer.append("\no  '").append(pattern).append("'");
                 }
 
                 buffer.append("\n");
 
                 logger.warn(buffer.toString());
             }
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public String toString() {
         return "Includes filter:" + getPatternsAsString();
     }
 
     /**
      * <p>getPatternsAsString.</p>
      *
      * @return pattern as a string.
      */
     protected String getPatternsAsString() {
         final StringBuilder buffer = new StringBuilder();
         for (Pattern pattern : patterns) {
             buffer.append("\no '").append(pattern).append("'");
         }
 
         return buffer.toString();
     }
 
     /**
      * <p>getFilterDescription.</p>
      *
      * @return description.
      */
     protected String getFilterDescription() {
         return "artifact inclusion filter";
     }
 
     /** {@inheritDoc} */
     public void reportFilteredArtifacts(final Logger logger) {
         if (!filteredArtifact.isEmpty() && logger.isDebugEnabled()) {
             final StringBuilder buffer =
                     new StringBuilder("The following artifacts were removed by this " + getFilterDescription() + ": ");
 
             for (Artifact artifactId : filteredArtifact) {
                 buffer.append('\n').append(artifactId.getId());
             }
 
             logger.debug(buffer.toString());
         }
     }
 
     /**
      * {@inheritDoc}
      *
      * @return a boolean.
      */
     public boolean hasMissedCriteria() {
         // if there are no patterns, there is nothing to report.
         if (!patterns.isEmpty()) {
             final List<Pattern> missed = new ArrayList<>(patterns);
             missed.removeAll(patternsTriggered);
 
             return !missed.isEmpty();
         }
 
         return false;
     }
 
     private static final char[] EMPTY = new char[0];
 
     private static final char[] ANY = new char[] {'*'};
 
     static char[] emptyOrChars(String str) {
         return str != null && str.length() > 0 ? str.toCharArray() : EMPTY;
     }
 
     static char[] anyOrChars(char[] str) {
         return str.length > 1 || (str.length == 1 && str[0] != '*') ? str : ANY;
     }
 
     static char[][] tokenizeAndSplit(String pattern) {
         String[] stokens = pattern.split(":");
         char[][] tokens = new char[stokens.length][];
         for (int i = 0; i < stokens.length; i++) {
             tokens[i] = emptyOrChars(stokens[i]);
         }
         return tokens;
     }
 
     @SuppressWarnings("InnerAssignment")
     static boolean match(char[] patArr, char[] strArr, boolean isVersion) {
         int patIdxStart = 0;
         int patIdxEnd = patArr.length - 1;
         int strIdxStart = 0;
         int strIdxEnd = strArr.length - 1;
         char ch;
 
         boolean containsStar = false;
         for (char aPatArr : patArr) {
             if (aPatArr == '*') {
                 containsStar = true;
                 break;
             }
         }
 
         if (!containsStar) {
             if (isVersion && (patArr[0] == '[' || patArr[0] == '(')) {
                 return isVersionIncludedInRange(String.valueOf(strArr), String.valueOf(patArr));
             }
             // No '*'s, so we make a shortcut
             if (patIdxEnd != strIdxEnd) {
                 return false; // Pattern and string do not have the same size
             }
             for (int i = 0; i <= patIdxEnd; i++) {
                 ch = patArr[i];
                 if (ch != '?' && ch != strArr[i]) {
                     return false; // Character mismatch
                 }
             }
             return true; // String matches against pattern
         }
 
         if (patIdxEnd == 0) {
             return true; // Pattern contains only '*', which matches anything
         }
 
         // Process characters before first star
         while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) {
             if (ch != '?' && ch != strArr[strIdxStart]) {
                 return false; // Character mismatch
             }
             patIdxStart++;
             strIdxStart++;
         }
         if (strIdxStart > strIdxEnd) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
             for (int i = patIdxStart; i <= patIdxEnd; i++) {
                 if (patArr[i] != '*') {
                     return false;
                 }
             }
             return true;
         }
 
         // Process characters after last star
         while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) {
             if (ch != '?' && ch != strArr[strIdxEnd]) {
                 return false; // Character mismatch
             }
             patIdxEnd--;
             strIdxEnd--;
         }
         if (strIdxStart > strIdxEnd) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
             for (int i = patIdxStart; i <= patIdxEnd; i++) {
                 if (patArr[i] != '*') {
                     return false;
                 }
             }
             return true;
         }
 
         // process pattern between stars. padIdxStart and patIdxEnd point
         // always to a '*'.
         while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
             int patIdxTmp = -1;
             for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
                 if (patArr[i] == '*') {
                     patIdxTmp = i;
                     break;
                 }
             }
             if (patIdxTmp == patIdxStart + 1) {
                 // Two stars next to each other, skip the first one.
                 patIdxStart++;
                 continue;
             }
             // Find the pattern between padIdxStart & padIdxTmp in str between
             // strIdxStart & strIdxEnd
             int patLength = (patIdxTmp - patIdxStart - 1);
             int strLength = (strIdxEnd - strIdxStart + 1);
             int foundIdx = -1;
             strLoop:
             for (int i = 0; i <= strLength - patLength; i++) {
                 for (int j = 0; j < patLength; j++) {
                     ch = patArr[patIdxStart + j + 1];
                     if (ch != '?' && ch != strArr[strIdxStart + i + j]) {
                         continue strLoop;
                     }
                 }
 
                 foundIdx = strIdxStart + i;
                 break;
             }
 
             if (foundIdx == -1) {
                 return false;
             }
 
             patIdxStart = patIdxTmp;
             strIdxStart = foundIdx + patLength;
         }
 
         // All characters in the string are used. Check if only '*'s are left
         // in the pattern. If so, we succeeded. Otherwise failure.
         for (int i = patIdxStart; i <= patIdxEnd; i++) {
             if (patArr[i] != '*') {
                 return false;
             }
         }
         return true;
     }
 
     static boolean isVersionIncludedInRange(final String version, final String range) {
         try {
             return VersionRange.createFromVersionSpec(range).containsVersion(new DefaultArtifactVersion(version));
         } catch (final InvalidVersionSpecificationException e) {
             return false;
         }
     }
 
     static Pattern compile(String pattern) {
         if (pattern.startsWith("!")) {
             return new NegativePattern(pattern, compile(pattern.substring(1)));
         } else {
             char[][] stokens = tokenizeAndSplit(pattern);
             char[][] tokens = new char[stokens.length][];
             for (int i = 0; i < stokens.length; i++) {
                 tokens[i] = anyOrChars(stokens[i]);
             }
             if (tokens.length > 5) {
                 throw new IllegalArgumentException("Invalid pattern: " + pattern);
             }
             //
             // Check the tokens and build an appropriate Pattern
             // Special care needs to be taken if the first or the last part is '*'
             // because this allows the '*' to match multiple tokens
             //
             if (tokens.length == 1) {
                 if (tokens[0] == ANY) {
                     // *
                     return all(pattern);
                 } else {
                     // [pat0]
                     return match(pattern, tokens[0], 0);
                 }
             }
             if (tokens.length == 2) {
                 if (tokens[0] == ANY) {
                     if (tokens[1] == ANY) {
                         // *:*
                         return all(pattern);
                     } else {
                         // *:[pat1]
                         return match(pattern, tokens[1], 0, 3);
                     }
                 } else {
                     if (tokens[1] == ANY) {
                         // [pat0]:*
                         return match(pattern, tokens[0], 0);
                     } else {
                         // [pat0]:[pat1]
                         Pattern m00 = match(tokens[0], 0);
                         Pattern m11 = match(tokens[1], 1);
                         return and(pattern, m00, m11);
                     }
                 }
             }
             if (tokens.length == 3) {
                 if (tokens[0] == ANY) {
                     if (tokens[1] == ANY) {
                         if (tokens[2] == ANY) {
                             // *:*:*
                             return all(pattern);
                         } else {
                             // *:*:[pat2]
                             return match(pattern, tokens[2], 2, 3);
                         }
                     } else {
                         if (tokens[2] == ANY) {
                             // *:[pat1]:*
                             return match(pattern, tokens[1], 1, 2);
                         } else {
                             // *:[pat1]:[pat2]
                             Pattern m11 = match(tokens[1], 1);
                             Pattern m12 = match(tokens[1], 2);
                             Pattern m22 = match(tokens[2], 2);
                             Pattern m23 = match(tokens[2], 3);
                             return or(pattern, and(m11, m22), and(m12, m23));
                         }
                     }
                 } else {
                     if (tokens[1] == ANY) {
                         if (tokens[2] == ANY) {
                             // [pat0]:*:*
                             return match(pattern, tokens[0], 0, 1);
                         } else {
                             // [pat0]:*:[pat2]
                             Pattern m00 = match(tokens[0], 0);
                             Pattern m223 = match(tokens[2], 2, 3);
                             return and(pattern, m00, m223);
                         }
                     } else {
                         if (tokens[2] == ANY) {
                             // [pat0]:[pat1]:*
                             Pattern m00 = match(tokens[0], 0);
                             Pattern m11 = match(tokens[1], 1);
                             return and(pattern, m00, m11);
                         } else {
                             // [pat0]:[pat1]:[pat2]
                             Pattern m00 = match(tokens[0], 0);
                             Pattern m11 = match(tokens[1], 1);
                             Pattern m22 = match(tokens[2], 2);
                             return and(pattern, m00, m11, m22);
                         }
                     }
                 }
             }
             if (tokens.length >= 4) {
                 List<Pattern> patterns = new ArrayList<>();
                 for (int i = 0; i < tokens.length; i++) {
                     if (tokens[i] != ANY) {
                         patterns.add(match(tokens[i], i));
                     }
                 }
                 return and(pattern, patterns.toArray(new Pattern[0]));
             }
             throw new IllegalStateException();
         }
     }
 
     /** Creates a positional matching pattern */
     private static Pattern match(String pattern, char[] token, int posVal) {
         return match(pattern, token, posVal, posVal);
     }
 
     /** Creates a positional matching pattern */
     private static Pattern match(char[] token, int posVal) {
         return match("", token, posVal, posVal);
     }
 
     /** Creates a positional matching pattern */
     private static Pattern match(String pattern, char[] token, int posMin, int posMax) {
         boolean hasWildcard = false;
         for (char ch : token) {
             if (ch == '*' || ch == '?') {
                 hasWildcard = true;
                 break;
             }
         }
         if (hasWildcard || posMax == 4) {
             return new PosPattern(pattern, token, posMin, posMax);
         } else {
             return new EqPattern(pattern, token, posMin, posMax);
         }
     }
 
     /** Creates a positional matching pattern */
     private static Pattern match(char[] token, int posMin, int posMax) {
         return new PosPattern("", token, posMin, posMax);
     }
 
     /** Creates an AND pattern */
     private static Pattern and(String pattern, Pattern... patterns) {
         return new AndPattern(pattern, patterns);
     }
 
     /** Creates an AND pattern */
     private static Pattern and(Pattern... patterns) {
         return and("", patterns);
     }
 
     /** Creates an OR pattern */
     private static Pattern or(String pattern, Pattern... patterns) {
         return new OrPattern(pattern, patterns);
     }
 
     /** Creates an OR pattern */
     private static Pattern or(Pattern... patterns) {
         return or("", patterns);
     }
 
     /** Creates a match-all pattern */
     private static Pattern all(String pattern) {
         return new MatchAllPattern(pattern);
     }
 
     /**
      * Abstract class for patterns
      */
     abstract static class Pattern {
         private final String pattern;
 
         Pattern(String pattern) {
             this.pattern = Objects.requireNonNull(pattern);
         }
 
         public abstract boolean matches(char[][] parts);
 
         /**
          * Returns a string containing a fixed artifact gatv coordinates
          * or null if the pattern can not be translated.
          */
         public String translateEquals() {
             return null;
         }
 
         /**
          * Check if the this pattern is a fixed pattern on the specified pos.
          */
         protected String translateEquals(int pos) {
             return null;
         }
 
         @Override
         public String toString() {
             return pattern;
         }
     }
 
     /**
      * Simple pattern which performs a logical AND between one or more patterns.
      */
     static class AndPattern extends Pattern {
         private final Pattern[] patterns;
 
         AndPattern(String pattern, Pattern[] patterns) {
             super(pattern);
             this.patterns = patterns;
         }
 
         @Override
         public boolean matches(char[][] parts) {
             for (Pattern pattern : patterns) {
                 if (!pattern.matches(parts)) {
                     return false;
                 }
             }
             return true;
         }
 
         @Override
         public String translateEquals() {
             String[] strings = new String[patterns.length];
             for (int i = 0; i < patterns.length; i++) {
                 strings[i] = patterns[i].translateEquals(i);
                 if (strings[i] == null) {
                     return null;
                 }
             }
             StringBuilder sb = new StringBuilder();
             for (int i = 0; i < strings.length; i++) {
                 if (i > 0) {
                     sb.append(":");
                 }
                 sb.append(strings[i]);
             }
             return sb.toString();
         }
     }
 
     /**
      * Simple pattern which performs a logical OR between one or more patterns.
      */
     static class OrPattern extends Pattern {
         private final Pattern[] patterns;
 
         OrPattern(String pattern, Pattern[] patterns) {
             super(pattern);
             this.patterns = patterns;
         }
 
         @Override
         public boolean matches(char[][] parts) {
             for (Pattern pattern : patterns) {
                 if (pattern.matches(parts)) {
                     return true;
                 }
             }
             return false;
         }
     }
 
     /**
      * A positional matching pattern, to check if a token in the gatv coordinates
      * having a position between posMin and posMax (both inclusives) can match
      * the pattern.
      */
     static class PosPattern extends Pattern {
         private final char[] patternCharArray;
         private final int posMin;
         private final int posMax;
 
         PosPattern(String pattern, char[] patternCharArray, int posMin, int posMax) {
             super(pattern);
             this.patternCharArray = patternCharArray;
             this.posMin = posMin;
             this.posMax = posMax;
         }
 
         @Override
         public boolean matches(char[][] parts) {
             for (int i = posMin; i <= posMax; i++) {
                 if (match(patternCharArray, parts[i], i == 4)) {
                     return true;
                 }
             }
             return false;
         }
     }
 
     /**
      * Looks for an exact match in the gatv coordinates between
      * posMin and posMax (both inclusives)
      */
     static class EqPattern extends Pattern {
         private final char[] token;
         private final int posMin;
         private final int posMax;
 
         EqPattern(String pattern, char[] patternCharArray, int posMin, int posMax) {
             super(pattern);
             this.token = patternCharArray;
             this.posMin = posMin;
             this.posMax = posMax;
         }
 
         @Override
         public boolean matches(char[][] parts) {
             for (int i = posMin; i <= posMax; i++) {
                 if (Arrays.equals(token, parts[i])) {
                     return true;
                 }
             }
             return false;
         }
 
         @Override
         public String translateEquals() {
             return translateEquals(0);
         }
 
         public String translateEquals(int pos) {
             return posMin == pos && posMax == pos && (pos < 3 || (token[0] != '[' && token[0] != '('))
                     ? String.valueOf(token)
                     : null;
         }
     }
 
     /**
      * Matches all input
      */
     static class MatchAllPattern extends Pattern {
         MatchAllPattern(String pattern) {
             super(pattern);
         }
 
         @Override
         public boolean matches(char[][] parts) {
             return true;
         }
     }
 
     /**
      * Negative pattern
      */
     static class NegativePattern extends Pattern {
         private final Pattern inner;
 
         NegativePattern(String pattern, Pattern inner) {
             super(pattern);
             this.inner = inner;
         }
 
         @Override
         public boolean matches(char[][] parts) {
             return inner.matches(parts);
         }
     }
 }