/*
    * 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.resolver.internal.ant.types;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.types.DataType;
  import org.apache.tools.ant.types.Reference;
  
  /**
   */
  public class Dependency extends DataType implements DependencyContainer {
  
      private String groupId;
  
      private String artifactId;
  
      private String version;
  
      private String classifier;
  
      private String type;
  
      private String scope;
  
      private File systemPath;
  
      private List<Exclusion> exclusions = new ArrayList<>();
  
      protected Dependency getRef() {
          return (Dependency) getCheckedRef();
      }
  
      public void validate(Task task) {
          if (isReference()) {
              getRef().validate(task);
          } else {
              if (groupId == null || groupId.length() <= 0) {
                  throw new BuildException("You must specify the 'groupId' for a dependency");
              }
              if (artifactId == null || artifactId.length() <= 0) {
                  throw new BuildException("You must specify the 'artifactId' for a dependency");
              }
              if (version == null || version.length() <= 0) {
                  throw new BuildException("You must specify the 'version' for a dependency");
              }
  
              if ("system".equals(scope)) {
                  if (systemPath == null) {
                      throw new BuildException("You must specify 'systemPath' for dependencies with scope=system");
                  }
              } else if (systemPath != null) {
                  throw new BuildException("You may only specify 'systemPath' for dependencies with scope=system");
              }
  
              if (scope != null
                      && !"compile".equals(scope)
                      && !"provided".equals(scope)
                      && !"system".equals(scope)
                      && !"runtime".equals(scope)
                      && !"test".equals(scope)) {
                  task.log("Unknown scope '" + scope + "' for dependency", Project.MSG_WARN);
              }
  
              for (Exclusion exclusion : exclusions) {
                  exclusion.validate(task);
              }
          }
      }
  
      public void setRefid(Reference ref) {
          if (groupId != null
                  || artifactId != null
                  || type != null
                  || classifier != null
                  || version != null
                 || scope != null
                 || systemPath != null) {
             throw tooManyAttributes();
         }
         if (!exclusions.isEmpty()) {
             throw noChildrenAllowed();
         }
         super.setRefid(ref);
     }
 
     public String getGroupId() {
         if (isReference()) {
             return getRef().getGroupId();
         }
         return groupId;
     }
 
     public void setGroupId(String groupId) {
         checkAttributesAllowed();
         if (this.groupId != null) {
             throw ambiguousCoords();
         }
         this.groupId = groupId;
     }
 
     public String getArtifactId() {
         if (isReference()) {
             return getRef().getArtifactId();
         }
         return artifactId;
     }
 
     public void setArtifactId(String artifactId) {
         checkAttributesAllowed();
         if (this.artifactId != null) {
             throw ambiguousCoords();
         }
         this.artifactId = artifactId;
     }
 
     public String getVersion() {
         if (isReference()) {
             return getRef().getVersion();
         }
         return version;
     }
 
     public void setVersion(String version) {
         checkAttributesAllowed();
         if (this.version != null) {
             throw ambiguousCoords();
         }
         this.version = version;
     }
 
     public String getClassifier() {
         if (isReference()) {
             return getRef().getClassifier();
         }
         return classifier;
     }
 
     public void setClassifier(String classifier) {
         checkAttributesAllowed();
         if (this.classifier != null) {
             throw ambiguousCoords();
         }
         this.classifier = classifier;
     }
 
     public String getType() {
         if (isReference()) {
             return getRef().getType();
         }
         return (type != null) ? type : "jar";
     }
 
     public void setType(String type) {
         checkAttributesAllowed();
         if (this.type != null) {
             throw ambiguousCoords();
         }
         this.type = type;
     }
 
     public String getScope() {
         if (isReference()) {
             return getRef().getScope();
         }
         return (scope != null) ? scope : "compile";
     }
 
     public void setScope(String scope) {
         checkAttributesAllowed();
         if (this.scope != null) {
             throw ambiguousCoords();
         }
         this.scope = scope;
     }
 
     public void setCoords(String coords) {
         checkAttributesAllowed();
         if (groupId != null
                 || artifactId != null
                 || version != null
                 || type != null
                 || classifier != null
                 || scope != null) {
             throw ambiguousCoords();
         }
         Pattern p = Pattern.compile("([^: ]+):([^: ]+):([^: ]+)((:([^: ]+)(:([^: ]+))?)?:([^: ]+))?");
         Matcher m = p.matcher(coords);
         if (!m.matches()) {
             throw new BuildException("Bad dependency coordinates '" + coords
                     + "', expected format is <groupId>:<artifactId>:<version>[[:<type>[:<classifier>]]:<scope>]");
         }
         groupId = m.group(1);
         artifactId = m.group(2);
         version = m.group(3);
         type = m.group(6);
         if (type == null || type.length() <= 0) {
             type = "jar";
         }
         classifier = m.group(8);
         if (classifier == null) {
             classifier = "";
         }
         scope = m.group(9);
     }
 
     public void setSystemPath(File systemPath) {
         checkAttributesAllowed();
         this.systemPath = systemPath;
     }
 
     public File getSystemPath() {
         if (isReference()) {
             return getRef().getSystemPath();
         }
         return systemPath;
     }
 
     public String getVersionlessKey() {
         if (isReference()) {
             return getRef().getVersionlessKey();
         }
         StringBuilder key = new StringBuilder(128);
         if (groupId != null) {
             key.append(groupId);
         }
         key.append(':');
         if (artifactId != null) {
             key.append(artifactId);
         }
         key.append(':');
         key.append((type != null) ? type : "jar");
         if (classifier != null && classifier.length() > 0) {
             key.append(':');
             key.append(classifier);
         }
         return key.toString();
     }
 
     public void addExclusion(Exclusion exclusion) {
         checkChildrenAllowed();
         this.exclusions.add(exclusion);
     }
 
     public List<Exclusion> getExclusions() {
         if (isReference()) {
             return getRef().getExclusions();
         }
         return exclusions;
     }
 
     private BuildException ambiguousCoords() {
         return new BuildException("You must not specify both 'coords' and "
                 + "('groupId', 'artifactId', 'version', 'extension', 'classifier', 'scope')");
     }
 }