/*
 * 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.graph;

import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;

import org.eclipse.aether.artifact.Artifact;

import static java.util.Objects.requireNonNull;

/**
 * A dependency to some artifact. <em>Note:</em> Instances of this class are immutable and the exposed mutators return
 * new objects rather than changing the current instance.
 */
public final class Dependency {

    private final Artifact artifact;

    private final String scope;

    private final Boolean optional;

    private final Set<Exclusion> exclusions;

    /**
     * Creates a mandatory dependency on the specified artifact with the given scope.
     *
     * @param artifact The artifact being depended on, must not be {@code null}.
     * @param scope The scope of the dependency, may be {@code null}.
     */
    public Dependency(Artifact artifact, String scope) {
        this(artifact, scope, false);
    }

    /**
     * Creates a dependency on the specified artifact with the given scope.
     *
     * @param artifact The artifact being depended on, must not be {@code null}.
     * @param scope The scope of the dependency, may be {@code null}.
     * @param optional A flag whether the dependency is optional or mandatory, may be {@code null}.
     */
    public Dependency(Artifact artifact, String scope, Boolean optional) {
        this(artifact, scope, optional, null);
    }

    /**
     * Creates a dependency on the specified artifact with the given scope and exclusions.
     *
     * @param artifact The artifact being depended on, must not be {@code null}.
     * @param scope The scope of the dependency, may be {@code null}.
     * @param optional A flag whether the dependency is optional or mandatory, may be {@code null}.
     * @param exclusions The exclusions that apply to transitive dependencies, may be {@code null} if none.
     */
    public Dependency(Artifact artifact, String scope, Boolean optional, Collection<Exclusion> exclusions) {
        this(artifact, scope, Exclusions.copy(exclusions), optional);
    }

    private Dependency(Artifact artifact, String scope, Set<Exclusion> exclusions, Boolean optional) {
        // NOTE: This constructor assumes immutability of the provided exclusion collection, for internal use only
        this.artifact = requireNonNull(artifact, "artifact cannot be null");
        this.scope = (scope != null) ? scope : "";
        this.optional = optional;
        this.exclusions = exclusions;
    }

    /**
     * Gets the artifact being depended on.
     *
     * @return The artifact, never {@code null}.
     */
    public Artifact getArtifact() {
        return artifact;
    }

    /**
     * Sets the artifact being depended on.
     *
     * @param artifact The artifact, must not be {@code null}.
     * @return The new dependency, never {@code null}.
     */
    public Dependency setArtifact(Artifact artifact) {
        if (this.artifact.equals(artifact)) {
            return this;
        }
        return new Dependency(artifact, scope, exclusions, optional);
    }

    /**
     * Gets the scope of the dependency. The scope defines in which context this dependency is relevant.
     *
     * @return The scope or an empty string if not set, never {@code null}.
     */
    public String getScope() {
        return scope;
    }

    /**
     * Sets the scope of the dependency, e.g. "compile".
     *
     * @param scope The scope of the dependency, may be {@code null}.
     * @return The new dependency, never {@code null}.
     */
    public Dependency setScope(String scope) {
        if (this.scope.equals(scope) || (scope == null && this.scope.isEmpty())) {
            return this;
        }
        return new Dependency(artifact, scope, exclusions, optional);
    }

    /**
     * Indicates whether this dependency is optional or not. Optional dependencies can be ignored in some contexts.
     *
     * @return {@code true} if the dependency is (definitively) optional, {@code false} otherwise.
     */
    public boolean isOptional() {
        return Boolean.TRUE.equals(optional);
    }

    /**
     * Gets the optional flag for the dependency. Note: Most clients will usually call {@link #isOptional()} to
     * determine the optional flag, this method is for advanced use cases where three-valued logic is required.
     *
     * @return The optional flag or {@code null} if unspecified.
     */
    public Boolean getOptional() {
        return optional;
    }

    /**
     * Sets the optional flag for the dependency.
     *
     * @param optional {@code true} if the dependency is optional, {@code false} if the dependency is mandatory, may be
     *            {@code null} if unspecified.
     * @return The new dependency, never {@code null}.
     */
    public Dependency setOptional(Boolean optional) {
        if (Objects.equals(this.optional, optional)) {
            return this;
        }
        return new Dependency(artifact, scope, exclusions, optional);
    }

    /**
     * Gets the exclusions for this dependency. Exclusions can be used to remove transitive dependencies during
     * resolution.
     *
     * @return The (read-only) exclusions, never {@code null}.
     */
    public Collection<Exclusion> getExclusions() {
        return exclusions;
    }

    /**
     * Sets the exclusions for the dependency.
     *
     * @param exclusions The exclusions, may be {@code null}.
     * @return The new dependency, never {@code null}.
     */
    public Dependency setExclusions(Collection<Exclusion> exclusions) {
        if (hasEquivalentExclusions(exclusions)) {
            return this;
        }
        return new Dependency(artifact, scope, optional, exclusions);
    }

    private boolean hasEquivalentExclusions(Collection<Exclusion> exclusions) {
        if (exclusions == null || exclusions.isEmpty()) {
            return this.exclusions.isEmpty();
        }
        if (exclusions instanceof Set) {
            return this.exclusions.equals(exclusions);
        }
        return exclusions.size() >= this.exclusions.size()
                && this.exclusions.containsAll(exclusions)
                && exclusions.containsAll(this.exclusions);
    }

    @Override
    public String toString() {
        return getArtifact() + " (" + getScope() + (isOptional() ? "?" : "") + ")";
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        } else if (obj == null || !getClass().equals(obj.getClass())) {
            return false;
        }

        Dependency that = (Dependency) obj;

        return Objects.equals(artifact, that.artifact)
                && Objects.equals(scope, that.scope)
                && Objects.equals(optional, that.optional)
                && Objects.equals(exclusions, that.exclusions);
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + artifact.hashCode();
        hash = hash * 31 + scope.hashCode();
        hash = hash * 31 + (optional != null ? optional.hashCode() : 0);
        hash = hash * 31 + exclusions.size();
        return hash;
    }

    private static class Exclusions extends AbstractSet<Exclusion> {

        private final Exclusion[] exclusions;

        public static Set<Exclusion> copy(Collection<Exclusion> exclusions) {
            if (exclusions == null || exclusions.isEmpty()) {
                return Collections.emptySet();
            }
            return new Exclusions(exclusions);
        }

        private Exclusions(Collection<Exclusion> exclusions) {
            if (exclusions.size() > 1 && !(exclusions instanceof Set)) {
                exclusions = new LinkedHashSet<>(exclusions);
            }
            this.exclusions = exclusions.toArray(new Exclusion[0]);
        }

        @Override
        public Iterator<Exclusion> iterator() {
            return new Iterator<Exclusion>() {

                private int cursor = 0;

                public boolean hasNext() {
                    return cursor < exclusions.length;
                }

                public Exclusion next() {
                    try {
                        Exclusion exclusion = exclusions[cursor];
                        cursor++;
                        return exclusion;
                    } catch (IndexOutOfBoundsException e) {
                        throw new NoSuchElementException();
                    }
                }

                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public int size() {
            return exclusions.length;
        }
    }
}