/*
    * 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.artifact;
  
  import java.io.File;
  import java.util.*;
  
  import org.apache.maven.artifact.handler.ArtifactHandler;
  import org.apache.maven.artifact.metadata.ArtifactMetadata;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
  import org.apache.maven.artifact.versioning.ArtifactVersion;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
  import org.apache.maven.artifact.versioning.VersionRange;
  
  /**
   * @author Jason van Zyl
   */
  public class DefaultArtifact implements Artifact {
      private String groupId;
  
      private String artifactId;
  
      private String baseVersion;
  
      private final String type;
  
      private final String classifier;
  
      private volatile String scope;
  
      private volatile File file;
  
      private ArtifactRepository repository;
  
      private String downloadUrl;
  
      private ArtifactFilter dependencyFilter;
  
      private ArtifactHandler artifactHandler;
  
      private List<String> dependencyTrail;
  
      private volatile String version;
  
      private VersionRange versionRange;
  
      private volatile boolean resolved;
  
      private boolean release;
  
      private List<ArtifactVersion> availableVersions;
  
      private Map<Object, ArtifactMetadata> metadataMap;
  
      private boolean optional;
  
      public DefaultArtifact(
              String groupId,
              String artifactId,
              String version,
              String scope,
              String type,
              String classifier,
              ArtifactHandler artifactHandler) {
          this(
                  groupId,
                  artifactId,
                  VersionRange.createFromVersion(version),
                  scope,
                  type,
                  classifier,
                  artifactHandler,
                  false);
      }
  
      public DefaultArtifact(
              String groupId,
              String artifactId,
              VersionRange versionRange,
              String scope,
              String type,
             String classifier,
             ArtifactHandler artifactHandler) {
         this(groupId, artifactId, versionRange, scope, type, classifier, artifactHandler, false);
     }
 
     @SuppressWarnings("checkstyle:parameternumber")
     public DefaultArtifact(
             String groupId,
             String artifactId,
             VersionRange versionRange,
             String scope,
             String type,
             String classifier,
             ArtifactHandler artifactHandler,
             boolean optional) {
         this.groupId = groupId;
 
         this.artifactId = artifactId;
 
         this.versionRange = versionRange;
 
         selectVersionFromNewRangeIfAvailable();
 
         this.artifactHandler = artifactHandler;
 
         this.scope = scope;
 
         this.type = type;
 
         if (classifier == null) {
             classifier = artifactHandler.getClassifier();
         }
 
         this.classifier = classifier;
 
         this.optional = optional;
 
         validateIdentity();
     }
 
     private void validateIdentity() {
         if (empty(groupId)) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The groupId cannot be empty.");
         }
 
         if (artifactId == null) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The artifactId cannot be empty.");
         }
 
         if (type == null) {
             throw new InvalidArtifactRTException(groupId, artifactId, getVersion(), type, "The type cannot be empty.");
         }
 
         if ((version == null) && (versionRange == null)) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The version cannot be empty.");
         }
     }
 
     private boolean empty(String value) {
         return (value == null) || (value.trim().length() < 1);
     }
 
     public String getClassifier() {
         return classifier;
     }
 
     public boolean hasClassifier() {
         return classifier != null && !classifier.isEmpty();
     }
 
     public String getScope() {
         return scope;
     }
 
     public String getGroupId() {
         return groupId;
     }
 
     public String getArtifactId() {
         return artifactId;
     }
 
     public String getVersion() {
         return version;
     }
 
     public void setVersion(String version) {
         this.version = version;
         setBaseVersionInternal(version);
         versionRange = null;
     }
 
     public String getType() {
         return type;
     }
 
     public void setFile(File file) {
         this.file = file;
     }
 
     public File getFile() {
         return file;
     }
 
     public ArtifactRepository getRepository() {
         return repository;
     }
 
     public void setRepository(ArtifactRepository repository) {
         this.repository = repository;
     }
 
     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------
 
     public String getId() {
         return getDependencyConflictId() + ":" + getBaseVersion();
     }
 
     public String getDependencyConflictId() {
         StringBuilder sb = new StringBuilder(128);
         sb.append(getGroupId());
         sb.append(':');
         appendArtifactTypeClassifierString(sb);
         return sb.toString();
     }
 
     private void appendArtifactTypeClassifierString(StringBuilder sb) {
         sb.append(getArtifactId());
         sb.append(':');
         sb.append(getType());
         if (hasClassifier()) {
             sb.append(':');
             sb.append(getClassifier());
         }
     }
 
     public void addMetadata(ArtifactMetadata metadata) {
         if (metadataMap == null) {
             metadataMap = new HashMap<>();
         }
 
         ArtifactMetadata m = metadataMap.get(metadata.getKey());
         if (m != null) {
             m.merge(metadata);
         } else {
             metadataMap.put(metadata.getKey(), metadata);
         }
     }
 
     public Collection<ArtifactMetadata> getMetadataList() {
         if (metadataMap == null) {
             return Collections.emptyList();
         }
 
         return Collections.unmodifiableCollection(metadataMap.values());
     }
 
     // ----------------------------------------------------------------------
     // Object overrides
     // ----------------------------------------------------------------------
 
     public String toString() {
         StringBuilder sb = new StringBuilder();
         if (getGroupId() != null) {
             sb.append(getGroupId());
             sb.append(':');
         }
         appendArtifactTypeClassifierString(sb);
         sb.append(':');
         if (getBaseVersionInternal() != null) {
             sb.append(getBaseVersionInternal());
         } else {
             sb.append(versionRange.toString());
         }
         if (scope != null) {
             sb.append(':');
             sb.append(scope);
         }
         return sb.toString();
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         DefaultArtifact that = (DefaultArtifact) o;
         return Objects.equals(groupId, that.groupId)
                 && Objects.equals(artifactId, that.artifactId)
                 && Objects.equals(type, that.type)
                 && Objects.equals(classifier, that.classifier)
                 && Objects.equals(version, that.version);
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(groupId, artifactId, type, classifier, version);
     }
 
     public String getBaseVersion() {
         if (baseVersion == null && version != null) {
             setBaseVersionInternal(version);
         }
 
         return baseVersion;
     }
 
     protected String getBaseVersionInternal() {
         if ((baseVersion == null) && (version != null)) {
             setBaseVersionInternal(version);
         }
 
         return baseVersion;
     }
 
     public void setBaseVersion(String baseVersion) {
         setBaseVersionInternal(baseVersion);
     }
 
     protected void setBaseVersionInternal(String baseVersion) {
         this.baseVersion = ArtifactUtils.toSnapshotVersion(baseVersion);
     }
 
     public int compareTo(Artifact a) {
         int result = groupId.compareTo(a.getGroupId());
         if (result == 0) {
             result = artifactId.compareTo(a.getArtifactId());
             if (result == 0) {
                 result = type.compareTo(a.getType());
                 if (result == 0) {
                     if (classifier == null) {
                         if (a.getClassifier() != null) {
                             result = 1;
                         }
                     } else {
                         if (a.getClassifier() != null) {
                             result = classifier.compareTo(a.getClassifier());
                         } else {
                             result = -1;
                         }
                     }
                     if (result == 0) {
                         // We don't consider the version range in the comparison, just the resolved version
                         result = new DefaultArtifactVersion(version)
                                 .compareTo(new DefaultArtifactVersion(a.getVersion()));
                     }
                 }
             }
         }
         return result;
     }
 
     public void updateVersion(String version, ArtifactRepository localRepository) {
         setResolvedVersion(version);
         setFile(new File(localRepository.getBasedir(), localRepository.pathOf(this)));
     }
 
     public String getDownloadUrl() {
         return downloadUrl;
     }
 
     public void setDownloadUrl(String downloadUrl) {
         this.downloadUrl = downloadUrl;
     }
 
     public ArtifactFilter getDependencyFilter() {
         return dependencyFilter;
     }
 
     public void setDependencyFilter(ArtifactFilter artifactFilter) {
         dependencyFilter = artifactFilter;
     }
 
     public ArtifactHandler getArtifactHandler() {
         return artifactHandler;
     }
 
     public List<String> getDependencyTrail() {
         return dependencyTrail;
     }
 
     public void setDependencyTrail(List<String> dependencyTrail) {
         this.dependencyTrail = dependencyTrail;
     }
 
     public void setScope(String scope) {
         this.scope = scope;
     }
 
     public VersionRange getVersionRange() {
         return versionRange;
     }
 
     public void setVersionRange(VersionRange versionRange) {
         this.versionRange = versionRange;
         selectVersionFromNewRangeIfAvailable();
     }
 
     private void selectVersionFromNewRangeIfAvailable() {
         if ((versionRange != null) && (versionRange.getRecommendedVersion() != null)) {
             selectVersion(versionRange.getRecommendedVersion().toString());
         } else {
             version = null;
             baseVersion = null;
         }
     }
 
     public void selectVersion(String version) {
         this.version = version;
         setBaseVersionInternal(version);
     }
 
     public void setGroupId(String groupId) {
         this.groupId = groupId;
     }
 
     public void setArtifactId(String artifactId) {
         this.artifactId = artifactId;
     }
 
     public boolean isSnapshot() {
         return getBaseVersion() != null
                 && (getBaseVersion().endsWith(SNAPSHOT_VERSION)
                         || getBaseVersion().equals(LATEST_VERSION));
     }
 
     public void setResolved(boolean resolved) {
         this.resolved = resolved;
     }
 
     public boolean isResolved() {
         return resolved;
     }
 
     public void setResolvedVersion(String version) {
         this.version = version;
         // retain baseVersion
     }
 
     public void setArtifactHandler(ArtifactHandler artifactHandler) {
         this.artifactHandler = artifactHandler;
     }
 
     public void setRelease(boolean release) {
         this.release = release;
     }
 
     public boolean isRelease() {
         return release;
     }
 
     public List<ArtifactVersion> getAvailableVersions() {
         return availableVersions;
     }
 
     public void setAvailableVersions(List<ArtifactVersion> availableVersions) {
         this.availableVersions = availableVersions;
     }
 
     public boolean isOptional() {
         return optional;
     }
 
     public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
         return versionRange.getSelectedVersion(this);
     }
 
     public boolean isSelectedVersionKnown() throws OverConstrainedVersionException {
         return versionRange.isSelectedVersionKnown(this);
     }
 
     public void setOptional(boolean optional) {
         this.optional = optional;
     }
 }