/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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 de.smartics.properties.resource.maven.repository;
  
  import java.io.File;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
  import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
  import org.apache.maven.repository.internal.DefaultVersionResolver;
  import org.apache.maven.repository.internal.MavenRepositorySystemSession;
  import org.sonatype.aether.RepositorySystem;
  import org.sonatype.aether.RepositorySystemSession;
  import org.sonatype.aether.artifact.Artifact;
  import org.sonatype.aether.collection.CollectRequest;
  import org.sonatype.aether.connector.file.FileRepositoryConnectorFactory;
  import org.sonatype.aether.connector.wagon.WagonProvider;
  import org.sonatype.aether.connector.wagon.WagonRepositoryConnectorFactory;
  import org.sonatype.aether.graph.Dependency;
  import org.sonatype.aether.graph.DependencyFilter;
  import org.sonatype.aether.graph.DependencyNode;
  import org.sonatype.aether.impl.ArtifactDescriptorReader;
  import org.sonatype.aether.impl.VersionRangeResolver;
  import org.sonatype.aether.impl.VersionResolver;
  import org.sonatype.aether.impl.internal.DefaultServiceLocator;
  import org.sonatype.aether.repository.Authentication;
  import org.sonatype.aether.repository.LocalRepository;
  import org.sonatype.aether.repository.RemoteRepository;
  import org.sonatype.aether.resolution.DependencyRequest;
  import org.sonatype.aether.resolution.DependencyResolutionException;
  import org.sonatype.aether.resolution.DependencyResult;
  import org.sonatype.aether.spi.connector.RepositoryConnectorFactory;
  import org.sonatype.aether.util.graph.PreorderNodeListGenerator;
  
  import de.smartics.properties.resource.domain.ArtifactId;
  import de.smartics.properties.resource.domain.ArtifactRef;
  import de.smartics.properties.resource.domain.ClassPathEnvironment;
  
  /**
   * The repository to access artifacts to resolve for property descriptor
   * information.
   */
  public final class MavenRepository
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The remote artifact repository.
     */
    private final RemoteRepository remoteRepository;
  
    /**
     * The local artifact repository, where the remote artifacts are stored.
     */
    private final LocalRepository localRepository;
  
    /**
     * The internal repository system as the interface to the repository access
     * implementation.
     */
    private final RepositorySystem repositorySystem;
  
    /**
     * The list of dependency filters to apply to the dependency request.
     */
    private final List<DependencyFilter> dependencyFilters;
  
    /**
     * The flag to control accessing the local repository only.
     */
    private final boolean offline;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
    * Convenience constructor without dependency filters and no authentication.
    *
    * @param remoteRepositoryUrl the URL to the remote repository of artifacts.
    * @param localRepositoryPath the directory path to the local repository of
    *          artifacts.
    */
   public MavenRepository(final String remoteRepositoryUrl,
       final String localRepositoryPath)
   {
     this(remoteRepositoryUrl, null, localRepositoryPath,
         new ArrayList<DependencyFilter>(), false);
   }
 
   /**
    * Convenience constructor without dependency filters.
    *
    * @param remoteRepositoryUrl the URL to the remote repository of artifacts.
    * @param localRepositoryPath the directory path to the local repository of
    *          artifacts.
    */
   public MavenRepository(final String remoteRepositoryUrl,
       final Authentication auth, final String localRepositoryPath)
   {
     this(remoteRepositoryUrl, auth, localRepositoryPath,
         new ArrayList<DependencyFilter>(), false);
   }
 
   /**
    * Default constructor.
    *
    * @param remoteRepositoryUrl the URL to the remote repository of artifacts.
    * @param localRepositoryPath the directory path to the local repository of
    *          artifacts.
    * @param dependencyFilters the list of dependency filters to apply to the
    *          dependency request.
    */
   public MavenRepository(final String remoteRepositoryUrl,
       final Authentication auth, final String localRepositoryPath,
       final List<DependencyFilter> dependencyFilters, final boolean offline)
   {
     this.remoteRepository = createRemoteRepository(remoteRepositoryUrl, auth);
     this.localRepository = createLocalRepository(localRepositoryPath);
     this.repositorySystem = createRepositorySystem();
     this.dependencyFilters = new ArrayList<DependencyFilter>(dependencyFilters);
     this.offline = offline;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static RemoteRepository createRemoteRepository(
       final String remoteRepositoryUrl, final Authentication auth)
   {
     final RemoteRepository repo =
         new RemoteRepository("central", "default", remoteRepositoryUrl);
     if (auth != null)
     {
       repo.setAuthentication(auth);
     }
     return repo;
   }
 
   private static LocalRepository createLocalRepository(
       final String localRepositoryPath)
   {
     return new LocalRepository(localRepositoryPath);
   }
 
   private static RepositorySystem createRepositorySystem()
   {
     final DefaultServiceLocator locator = new DefaultServiceLocator();
 
     locator.addService(RepositoryConnectorFactory.class,
         FileRepositoryConnectorFactory.class);
     locator.addService(RepositoryConnectorFactory.class,
         WagonRepositoryConnectorFactory.class);
     locator.addService(VersionResolver.class, DefaultVersionResolver.class);
     locator.addService(VersionRangeResolver.class,
         DefaultVersionRangeResolver.class);
     locator.addService(ArtifactDescriptorReader.class,
         DefaultArtifactDescriptorReader.class);
 
     locator.setServices(WagonProvider.class, new RepositoryWagonProvider());
 
     return locator.getService(RepositorySystem.class);
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Creates a session to communicate with the repository.
    *
    * @return a new session instance.
    */
   public RepositorySystemSession createSession()
   {
     final MavenRepositorySystemSession session =
         new MavenRepositorySystemSession();
 
     session.setLocalRepositoryManager(repositorySystem
         .newLocalRepositoryManager(localRepository));
     session.setOffline(offline);
 
     session.setRepositoryListener(new ResourceRepositoryLogListener());
     // session.setTransferListener( new ConsoleTransferListener() );
 
     return session;
   }
 
   /**
    * Resolves the artifact so that it is locally accessible.
    *
    * @param session the session used for communication.
    * @param artifact the artifact to resolve.
    * @return the reference to the resolved artifact that is now stored locally
    *         ready for access.
    * @throws DependencyResolutionException if the dependency tree could not be
    *           built or any dependency artifact could not be resolved.
    */
   public ClassPathEnvironment resolve(final RepositorySystemSession session,
       final Artifact artifact) throws DependencyResolutionException
   {
     final Dependency dependency = createDependency(artifact);
 
     final DependencyRequest dependencyRequest = createRequest(dependency);
 
     try
     {
       final DependencyNode rootNode =
           repositorySystem.resolveDependencies(session, dependencyRequest)
               .getRoot();
       final PreorderNodeListGenerator generator =
           new PreorderNodeListGenerator();
       rootNode.accept(generator);
 
       final ClassPathEnvironment resources = createResult(generator);
       return resources;
     }
     catch (final NullPointerException e) // NOPMD aether problem
     {
       // Only occurs if a parent dependency of the resource cannot be resolved
       // TODO We should log this information somehow...
       throw new DependencyResolutionException(new DependencyResult(
           dependencyRequest), e);
     }
   }
 
   /**
    * Returns the URL to the remote repository.
    *
    * @return the URL to the remote repository.
    */
   public String getRemoteRepositoryUrl()
   {
     return remoteRepository.getUrl();
   }
 
   private static Dependency createDependency(final Artifact artifact)
   {
     final Dependency dependency = new Dependency(artifact, "runtime");
     return dependency;
   }
 
   private DependencyRequest createRequest(final Dependency dependency)
   {
     final CollectRequest collectRequest = new CollectRequest();
     collectRequest.setRoot(dependency);
     collectRequest.addRepository(remoteRepository);
 
     final DependencyRequest dependencyRequest = new DependencyRequest();
     dependencyRequest.setCollectRequest(collectRequest);
     for (final DependencyFilter filter : dependencyFilters)
     {
       dependencyRequest.setFilter(filter);
     }
     return dependencyRequest;
   }
 
   private static ClassPathEnvironment createResult(
       final PreorderNodeListGenerator generator)
   {
     final ClassPathEnvironment env = new ClassPathEnvironment();
     final List<DependencyNode> nodes = generator.getNodes();
 
     // TODO: Should we copy the artifacts to a local folder?
     for (final DependencyNode node : nodes)
     {
       final ArtifactRef artifactRef = createArtifact(node);
       env.addArchiveArtifactRef(artifactRef);
     }
 
     // final PropertySetClassesLoader declarationLoader =
     // new PropertySetClassesLoader();
     // final Set<Class<?>> declarations =
     // declarationLoader.getPropertySetTypes(urls);
     //
     // final PropertiesFilesLoader definitionLoader = new
     // PropertiesFilesLoader();
     // final Set<String> definitions =
     // definitionLoader.getPropertiesFiles(urls);
     //
     // final PropertiesResources resources =
     // new PropertiesResources(env, declarations, definitions);
     // return resources;
     return env;
   }
 
   private static URL toUrl(final File file) throws IllegalStateException
   {
     final URI uri = file.toURI();
     try
     {
       final URL url = uri.toURL();
       return url;
     }
     catch (final MalformedURLException e)
     {
       throw new IllegalStateException("Cannot resolve URL: "
                                       + uri.toASCIIString(), e); // FIXME
     }
   }
 
   private static ArtifactRef createArtifact(final DependencyNode node)
   {
     final Artifact artifact = node.getDependency().getArtifact();
     final ArtifactId.Builder builder = new ArtifactId.Builder();
     final String classifier = normalize(artifact);
     builder.withGroupId(artifact.getGroupId())
         .withName(artifact.getArtifactId()).withVersion(artifact.getVersion())
         .withArchiveType(artifact.getExtension()).withClassifier(classifier);
     final ArtifactId id = builder.build();
     final File file = artifact.getFile();
     final URL url = toUrl(file);
     final ArtifactRef ref = new ArtifactRef(id, url);
     return ref;
   }
 
   private static String normalize(final Artifact artifact)
   {
     String classifier = artifact.getClassifier();
     if (StringUtils.isBlank(classifier))
     {
       classifier = null;
     }
     return classifier;
   }
 
   // --- object basics --------------------------------------------------------
 
 }