/*

  * 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 --------------------------------------------------------

 }