/*
 * 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.enforcer.rules.utils;

import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Predicate;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.model.Dependency;
import org.codehaus.plexus.util.StringUtils;

import static java.util.Optional.ofNullable;

/**
 * This class is used for matching Artifacts against a list of patterns.
 *
 * @author Jakub Senko
 */
public final class ArtifactMatcher {

    /**
     * @author I don't know
     */
    public static class Pattern {
        private final String pattern;

        private final String[] parts;
        private final Predicate<String>[] partsRegex;

        public Pattern(String pattern) {
            if (pattern == null) {
                throw new NullPointerException("pattern");
            }

            this.pattern = pattern;

            parts = pattern.split(":", 7);

            if (parts.length == 7) {
                throw new IllegalArgumentException("Pattern contains too many delimiters.");
            }

            for (String part : parts) {
                if ("".equals(part)) {
                    throw new IllegalArgumentException("Pattern or its part is empty.");
                }
            }
            partsRegex = new Predicate[parts.length];
        }

        public boolean match(Artifact artifact) {
            Objects.requireNonNull(artifact, "artifact must not be null");
            try {
                return match(
                        artifact.getGroupId(),
                        artifact.getArtifactId(),
                        artifact.getVersion(),
                        artifact.getType(),
                        artifact.getScope(),
                        artifact.getClassifier());
            } catch (InvalidVersionSpecificationException e) {
                throw new IllegalArgumentException(e);
            }
        }

        public boolean match(Dependency dependency) {
            Objects.requireNonNull(dependency, "dependency must not be null");
            try {
                return match(
                        dependency.getGroupId(),
                        dependency.getArtifactId(),
                        dependency.getVersion(),
                        dependency.getType(),
                        dependency.getScope(),
                        dependency.getClassifier());
            } catch (InvalidVersionSpecificationException e) {
                throw new IllegalArgumentException(e);
            }
        }

        private boolean match(
                String groupId, String artifactId, String version, String type, String scope, String classifier)
                throws InvalidVersionSpecificationException {
            switch (parts.length) {
                case 6:
                    if (!matches(5, classifier)) {
                        return false;
                    }
                case 5:
                    if (scope == null || scope.isEmpty()) {
                        scope = Artifact.SCOPE_COMPILE;
                    }

                    if (!matches(4, scope)) {
                        return false;
                    }
                case 4:
                    if (type == null || type.isEmpty()) {
                        type = "jar";
                    }

                    if (!matches(3, type)) {
                        return false;
                    }

                case 3:
                    if (!matches(2, version)) {
                        if (!containsVersion(
                                VersionRange.createFromVersionSpec(parts[2]), new DefaultArtifactVersion(version))) {
                            return false;
                        }
                    }

                case 2:
                    if (!matches(1, artifactId)) {
                        return false;
                    }
                case 1:
                    return matches(0, groupId);
                default:
                    throw new AssertionError();
            }
        }

        private boolean matches(int index, String input) {
            // TODO: Check if this can be done better or prevented earlier.
            if (input == null) {
                input = "";
            }
            if (partsRegex[index] == null) {
                String regex = parts[index]
                        .replace(".", "\\.")
                        .replace("*", ".*")
                        .replace(":", "\\:")
                        .replace('?', '.')
                        .replace("[", "\\[")
                        .replace("]", "\\]")
                        .replace("(", "\\(")
                        .replace(")", "\\)");

                if (".*".equals(regex)) {
                    partsRegex[index] = test -> true;
                } else {
                    partsRegex[index] = test ->
                            java.util.regex.Pattern.compile(regex).matcher(test).matches();
                }
            }
            return partsRegex[index].test(input);
        }

        @Override
        public String toString() {
            return pattern;
        }
    }

    private final Collection<Pattern> excludePatterns = new HashSet<>();

    private final Collection<Pattern> includePatterns = new HashSet<>();

    /**
     * Construct class by providing patterns as strings. Empty strings are ignored.
     *
     * @param excludeStrings includes
     * @param includeStrings excludes
     * @throws NullPointerException if any of the arguments is null
     */
    public ArtifactMatcher(final Collection<String> excludeStrings, final Collection<String> includeStrings) {
        ofNullable(excludeStrings).ifPresent(excludes -> excludes.stream()
                .filter(StringUtils::isNotEmpty)
                .map(Pattern::new)
                .forEach(excludePatterns::add));
        ofNullable(includeStrings).ifPresent(includes -> includes.stream()
                .filter(StringUtils::isNotEmpty)
                .map(Pattern::new)
                .forEach(includePatterns::add));
    }

    private boolean match(Function<Pattern, Boolean> matcher) {
        return excludePatterns.stream().anyMatch(matcher::apply)
                && includePatterns.stream().noneMatch(matcher::apply);
    }

    /**
     * Check if artifact matches patterns.
     *
     * @param artifact the artifact to match
     * @return {@code true} if artifact matches any {@link #excludePatterns} and none of the {@link #includePatterns}, otherwise
     *         {@code false}
     */
    public boolean match(Artifact artifact) {
        return match(p -> p.match(artifact));
    }

    /**
     * Check if dependency matches patterns.
     *
     * @param dependency the dependency to match
     * @return {@code true} if dependency matches any {@link #excludePatterns} and none of the {@link #includePatterns},
     *         otherwise {@code false}
     */
    public boolean match(Dependency dependency) {
        return match(p -> p.match(dependency));
    }

    /**
     * Copied from Artifact.VersionRange. This is tweaked to handle singular ranges properly. The default
     * containsVersion method assumes a singular version means allow everything.
     * This method assumes that "2.0.4" == "[2.0.4,)"
     *
     * @param allowedRange range of allowed versions
     * @param version the version to be checked
     * @return true if the version is contained by the range
     */
    public static boolean containsVersion(VersionRange allowedRange, ArtifactVersion version) {
        ArtifactVersion recommendedVersion = allowedRange.getRecommendedVersion();
        if (recommendedVersion == null) {
            return allowedRange.containsVersion(version);
        } else {
            // only singular versions ever have a recommendedVersion
            int compareTo = recommendedVersion.compareTo(version);
            return compareTo <= 0;
        }
    }

    /**
     * To be used for artifacts which are equivalent for the purposes of the {@link ArtifactMatcher}.
     */
    public static class MatchingArtifact {
        String artifactString;

        public MatchingArtifact(Artifact artifact) {
            artifactString = new StringBuilder()
                    .append(artifact.getGroupId())
                    .append(":")
                    .append(artifact.getArtifactId())
                    .append(":")
                    .append(artifact.getVersion())
                    .append(":")
                    .append(artifact.getType())
                    .append(":")
                    .append(artifact.getScope())
                    .append(":")
                    .append(artifact.getClassifier())
                    .toString();
        }

        @Override
        public int hashCode() {
            return artifactString.hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            MatchingArtifact other = (MatchingArtifact) obj;
            return Objects.equals(artifactString, other.artifactString);
        }

        @Override
        public String toString() {
            return artifactString;
        }
    }
}