/*
    * 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;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.stream.Collectors;
  
  import org.apache.maven.artifact.handler.ArtifactHandler;
  import org.apache.maven.artifact.handler.DefaultArtifactHandler;
  import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
  import org.apache.maven.repository.internal.artifact.MavenArtifactProperties;
  import org.eclipse.aether.DefaultRepositorySystemSession;
  import org.eclipse.aether.RepositorySystem;
  import org.eclipse.aether.RepositorySystemSession;
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.artifact.ArtifactProperties;
  import org.eclipse.aether.artifact.ArtifactType;
  import org.eclipse.aether.artifact.ArtifactTypeRegistry;
  import org.eclipse.aether.artifact.DefaultArtifact;
  import org.eclipse.aether.artifact.DefaultArtifactType;
  import org.eclipse.aether.graph.Dependency;
  import org.eclipse.aether.graph.DependencyFilter;
  import org.eclipse.aether.graph.DependencyNode;
  import org.eclipse.aether.graph.Exclusion;
  import org.eclipse.aether.repository.Authentication;
  import org.eclipse.aether.repository.LocalRepository;
  import org.eclipse.aether.repository.LocalRepositoryManager;
  import org.eclipse.aether.repository.Proxy;
  import org.eclipse.aether.repository.RemoteRepository;
  import org.eclipse.aether.repository.RepositoryPolicy;
  import org.eclipse.aether.repository.WorkspaceReader;
  import org.eclipse.aether.repository.WorkspaceRepository;
  import org.eclipse.aether.util.repository.AuthenticationBuilder;
  
  /**
   * <strong>Warning:</strong> This is an internal utility class that is only public for technical reasons, it is not part
   * of the public API. In particular, this class can be changed or deleted without prior notice.
   *
   */
  public class RepositoryUtils {
  
      private static String nullify(String string) {
          return (string == null || string.isEmpty()) ? null : string;
      }
  
      private static org.apache.maven.artifact.Artifact toArtifact(Dependency dependency) {
          if (dependency == null) {
              return null;
          }
  
          org.apache.maven.artifact.Artifact result = toArtifact(dependency.getArtifact());
          result.setScope(dependency.getScope());
          result.setOptional(dependency.isOptional());
  
          return result;
      }
  
      public static org.apache.maven.artifact.Artifact toArtifact(Artifact artifact) {
          if (artifact == null) {
              return null;
          }
  
          ArtifactHandler handler = newHandler(artifact);
  
          /*
           * NOTE: From Artifact.hasClassifier(), an empty string and a null both denote "no classifier". However, some
           * plugins only check for null, so be sure to nullify an empty classifier.
           */
          org.apache.maven.artifact.Artifact result = new org.apache.maven.artifact.DefaultArtifact(
                  artifact.getGroupId(),
                  artifact.getArtifactId(),
                  artifact.getVersion(),
                  null,
                 artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension()),
                 nullify(artifact.getClassifier()),
                 handler);
 
         result.setFile(artifact.getFile());
         result.setResolved(artifact.getFile() != null);
 
         List<String> trail = new ArrayList<>(1);
         trail.add(result.getId());
         result.setDependencyTrail(trail);
 
         return result;
     }
 
     public static void toArtifacts(
             Collection<org.apache.maven.artifact.Artifact> artifacts,
             Collection<? extends DependencyNode> nodes,
             List<String> trail,
             DependencyFilter filter) {
         for (DependencyNode node : nodes) {
             org.apache.maven.artifact.Artifact artifact = toArtifact(node.getDependency());
 
             List<String> nodeTrail = new ArrayList<>(trail.size() + 1);
             nodeTrail.addAll(trail);
             nodeTrail.add(artifact.getId());
 
             if (filter == null || filter.accept(node, Collections.emptyList())) {
                 artifact.setDependencyTrail(nodeTrail);
                 artifacts.add(artifact);
             }
 
             toArtifacts(artifacts, node.getChildren(), nodeTrail, filter);
         }
     }
 
     public static Artifact toArtifact(org.apache.maven.artifact.Artifact artifact) {
         if (artifact == null) {
             return null;
         }
 
         String version = artifact.getVersion();
         if (version == null && artifact.getVersionRange() != null) {
             version = artifact.getVersionRange().toString();
         }
 
         Map<String, String> props = null;
         if (org.apache.maven.artifact.Artifact.SCOPE_SYSTEM.equals(artifact.getScope())) {
             String localPath = (artifact.getFile() != null) ? artifact.getFile().getPath() : "";
             props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, localPath);
         }
 
         Artifact result = new DefaultArtifact(
                 artifact.getGroupId(),
                 artifact.getArtifactId(),
                 artifact.getClassifier(),
                 artifact.getArtifactHandler().getExtension(),
                 version,
                 props,
                 newArtifactType(artifact.getType(), artifact.getArtifactHandler()));
         result = result.setFile(artifact.getFile());
 
         return result;
     }
 
     public static Dependency toDependency(
             org.apache.maven.artifact.Artifact artifact, Collection<org.apache.maven.model.Exclusion> exclusions) {
         if (artifact == null) {
             return null;
         }
 
         Artifact result = toArtifact(artifact);
 
         List<Exclusion> excl = Optional.ofNullable(exclusions).orElse(Collections.emptyList()).stream()
                 .map(RepositoryUtils::toExclusion)
                 .collect(Collectors.toList());
         return new Dependency(result, artifact.getScope(), artifact.isOptional(), excl);
     }
 
     public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {
         return Optional.ofNullable(repos).orElse(Collections.emptyList()).stream()
                 .map(RepositoryUtils::toRepo)
                 .collect(Collectors.toList());
     }
 
     public static RemoteRepository toRepo(ArtifactRepository repo) {
         RemoteRepository result = null;
         if (repo != null) {
             RemoteRepository.Builder builder =
                     new RemoteRepository.Builder(repo.getId(), getLayout(repo), repo.getUrl());
             builder.setSnapshotPolicy(toPolicy(repo.getSnapshots()));
             builder.setReleasePolicy(toPolicy(repo.getReleases()));
             builder.setAuthentication(toAuthentication(repo.getAuthentication()));
             builder.setProxy(toProxy(repo.getProxy()));
             builder.setMirroredRepositories(toRepos(repo.getMirroredRepositories()));
             builder.setBlocked(repo.isBlocked());
             result = builder.build();
         }
         return result;
     }
 
     public static String getLayout(ArtifactRepository repo) {
         try {
             return repo.getLayout().getId();
         } catch (LinkageError e) {
             /*
              * NOTE: getId() was added in 3.x and is as such not implemented by plugins compiled against 2.x APIs.
              */
             String className = repo.getLayout().getClass().getSimpleName();
             if (className.endsWith("RepositoryLayout")) {
                 String layout = className.substring(0, className.length() - "RepositoryLayout".length());
                 if (!layout.isEmpty()) {
                     layout = Character.toLowerCase(layout.charAt(0)) + layout.substring(1);
                     return layout;
                 }
             }
             return "";
         }
     }
 
     private static RepositoryPolicy toPolicy(ArtifactRepositoryPolicy policy) {
         RepositoryPolicy result = null;
         if (policy != null) {
             result = new RepositoryPolicy(policy.isEnabled(), policy.getUpdatePolicy(), policy.getChecksumPolicy());
         }
         return result;
     }
 
     private static Authentication toAuthentication(org.apache.maven.artifact.repository.Authentication auth) {
         Authentication result = null;
         if (auth != null) {
             AuthenticationBuilder authBuilder = new AuthenticationBuilder();
             authBuilder.addUsername(auth.getUsername()).addPassword(auth.getPassword());
             authBuilder.addPrivateKey(auth.getPrivateKey(), auth.getPassphrase());
             result = authBuilder.build();
         }
         return result;
     }
 
     private static Proxy toProxy(org.apache.maven.repository.Proxy proxy) {
         Proxy result = null;
         if (proxy != null) {
             AuthenticationBuilder authBuilder = new AuthenticationBuilder();
             authBuilder.addUsername(proxy.getUserName()).addPassword(proxy.getPassword());
             result = new Proxy(proxy.getProtocol(), proxy.getHost(), proxy.getPort(), authBuilder.build());
         }
         return result;
     }
 
     public static ArtifactHandler newHandler(Artifact artifact) {
         String type = artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension());
         return new DefaultArtifactHandler(
                 type,
                 artifact.getExtension(),
                 null,
                 null,
                 null,
                 Boolean.parseBoolean(artifact.getProperty(MavenArtifactProperties.INCLUDES_DEPENDENCIES, "")),
                 artifact.getProperty(ArtifactProperties.LANGUAGE, null),
                 Boolean.parseBoolean(artifact.getProperty(MavenArtifactProperties.CONSTITUTES_BUILD_PATH, "")));
     }
 
     public static ArtifactType newArtifactType(String id, ArtifactHandler handler) {
         return new DefaultArtifactType(
                 id,
                 handler.getExtension(),
                 handler.getClassifier(),
                 handler.getLanguage(),
                 handler.isAddedToClasspath(),
                 handler.isIncludesDependencies());
     }
 
     public static Dependency toDependency(
             org.apache.maven.model.Dependency dependency, ArtifactTypeRegistry stereotypes) {
         ArtifactType stereotype = stereotypes.get(dependency.getType());
         if (stereotype == null) {
             stereotype = new DefaultArtifactType(dependency.getType());
         }
 
         boolean system =
                 dependency.getSystemPath() != null && dependency.getSystemPath().length() > 0;
 
         Map<String, String> props = null;
         if (system) {
             props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, dependency.getSystemPath());
         }
 
         Artifact artifact = new DefaultArtifact(
                 dependency.getGroupId(),
                 dependency.getArtifactId(),
                 dependency.getClassifier(),
                 null,
                 dependency.getVersion(),
                 props,
                 stereotype);
 
         List<Exclusion> exclusions = dependency.getExclusions().stream()
                 .map(RepositoryUtils::toExclusion)
                 .collect(Collectors.toList());
 
         return new Dependency(
                 artifact,
                 dependency.getScope(),
                 dependency.getOptional() != null ? dependency.isOptional() : null,
                 exclusions);
     }
 
     private static Exclusion toExclusion(org.apache.maven.model.Exclusion exclusion) {
         return new Exclusion(exclusion.getGroupId(), exclusion.getArtifactId(), "*", "*");
     }
 
     public static ArtifactTypeRegistry newArtifactTypeRegistry(ArtifactHandlerManager handlerManager) {
         return new MavenArtifactTypeRegistry(handlerManager);
     }
 
     static class MavenArtifactTypeRegistry implements ArtifactTypeRegistry {
 
         private final ArtifactHandlerManager handlerManager;
 
         MavenArtifactTypeRegistry(ArtifactHandlerManager handlerManager) {
             this.handlerManager = handlerManager;
         }
 
         public ArtifactType get(String stereotypeId) {
             ArtifactHandler handler = handlerManager.getArtifactHandler(stereotypeId);
             return newArtifactType(stereotypeId, handler);
         }
     }
 
     public static Collection<Artifact> toArtifacts(Collection<org.apache.maven.artifact.Artifact> artifactsToConvert) {
         return artifactsToConvert.stream().map(RepositoryUtils::toArtifact).collect(Collectors.toList());
     }
 
     public static WorkspaceRepository getWorkspace(RepositorySystemSession session) {
         WorkspaceReader reader = session.getWorkspaceReader();
         return (reader != null) ? reader.getRepository() : null;
     }
 
     public static boolean repositoriesEquals(List<RemoteRepository> r1, List<RemoteRepository> r2) {
         if (r1.size() != r2.size()) {
             return false;
         }
 
         for (Iterator<RemoteRepository> it1 = r1.iterator(), it2 = r2.iterator(); it1.hasNext(); ) {
             if (!repositoryEquals(it1.next(), it2.next())) {
                 return false;
             }
         }
 
         return true;
     }
 
     public static int repositoriesHashCode(List<RemoteRepository> repositories) {
         int result = 17;
         for (RemoteRepository repository : repositories) {
             result = 31 * result + repositoryHashCode(repository);
         }
         return result;
     }
 
     public static RepositorySystemSession overlay(
             ArtifactRepository repository, RepositorySystemSession session, RepositorySystem system) {
         if (repository == null || repository.getBasedir() == null) {
             return session;
         }
 
         DefaultRepositorySystemSession newSession;
         if (session != null) {
             LocalRepositoryManager lrm = session.getLocalRepositoryManager();
             if (lrm != null && lrm.getRepository().getBasedir().equals(new File(repository.getBasedir()))) {
                 return session;
             }
             newSession = new DefaultRepositorySystemSession(session);
         } else {
             newSession = new DefaultRepositorySystemSession(h -> false); // no close handle used
         }
 
         final LocalRepositoryManager llrm =
                 system.newLocalRepositoryManager(newSession, new LocalRepository(repository.getBasedir()));
         newSession.setLocalRepositoryManager(llrm);
         return newSession;
     }
 
     private static int repositoryHashCode(RemoteRepository repository) {
         int result = 17;
         Object obj = repository.getUrl();
         result = 31 * result + (obj != null ? obj.hashCode() : 0);
         return result;
     }
 
     private static boolean policyEquals(RepositoryPolicy p1, RepositoryPolicy p2) {
         if (p1 == p2) {
             return true;
         }
         // update policy doesn't affect contents
         return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getChecksumPolicy(), p2.getChecksumPolicy());
     }
 
     private static boolean repositoryEquals(RemoteRepository r1, RemoteRepository r2) {
         if (r1 == r2) {
             return true;
         }
 
         return Objects.equals(r1.getId(), r2.getId())
                 && Objects.equals(r1.getUrl(), r2.getUrl())
                 && policyEquals(r1.getPolicy(false), r2.getPolicy(false))
                 && policyEquals(r1.getPolicy(true), r2.getPolicy(true));
     }
 }