package com.atlassian.maven.plugins.licenses;
   
   import java.io.File;
   import java.net.MalformedURLException;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Set;
  import java.util.StringTokenizer;
  import java.util.TreeSet;
  import java.util.jar.JarFile;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
  import org.apache.maven.artifact.resolver.ArtifactResolutionException;
  import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
  import org.apache.maven.artifact.resolver.ArtifactResolver;
  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
  import org.apache.maven.model.License;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectBuilder;
  import org.apache.maven.project.ProjectBuildingException;
  import org.apache.oro.text.regex.MalformedPatternException;
  
  /**
   * Pre-resolves all transitive dependencies. Provides methods for iterating
   * through dependency projects, searching for the license in the JAR.
   * 
   * @requiresDependencyResolution
   * @author Sherali Karimov
   */
  public abstract class AbstractLicensesMojo extends AbstractMojo
  {
      /**
       * Various locations where people historically have placed their license
       * agreement text inside the JAR files
       */
      protected static final List LICENSE_PATH_OPTIONS = Arrays.asList(new String[]
      {
              "LICENSE",
              "LICENSE.txt", 
              "META-INF/LICENSE", 
              "META-INF/LICENSE.txt", 
              "license", 
              "license.txt",
              "META-INF/license", 
              "META-INF/license.txt", 
      });
  
      public static final String LICENSE_TYPE = "license";
  
      /**
       * @component
       */
      protected ArtifactResolver resolver;
  
      /**
       * @parameter expression="${localRepository}"
       */
      protected ArtifactRepository localRepository;
  
      /**
       * @parameter expression="${project.remoteArtifactRepositories}"
       */
      protected List remoteRepositories;
  
      /**
       * @component
       */
      protected ArtifactFactory artifactFactory;
  
      /**
       * @component role="org.apache.maven.artifact.metadata.ArtifactMetadataSource"
       *            hint="maven"
       */
      protected ArtifactMetadataSource artifactMetadataSource;
  
      /**
       * @component
       */
      protected MavenProjectBuilder mavenProjectBuilder;
  
      /**
       * @parameter expression="${project}"
       * @required
       * @readonly
       */
      private MavenProject project;
  
      /**
       * List of scopes of dependencies to be excluded
       * 
       * @parameter
      */
     protected List excludedScopeList;
 
     /**
      * Comma-separated list of scopes of dependencies to be excluded. This is a
      * command-line alternative to the excludedScope parameter, since List
      * parameters are not currently compatible with CLI specification.
      * 
      * @parameter expression="${licenses.excludedScopes}"
      */
     protected String excludedScopes;
 
     /**
      * List of dependencies to be excluded. Each item is a groupId:artifactId
      * combination. Wildcard expressions: groupId:* and *:artifactId are also
      * supported.
      * 
      * @parameter
      */
     protected List excludedLibraryList;
 
     /**
      * Comma-separated list of dependencies to be excluded. Each item is a
      * groupId:artifactId combination. Wildcard expressions: groupId:* and
      * *:artifactId are also supported. This is a command-line alternative to
      * the excludedScope parameter, since List parameters are not currently
      * compatible with CLI specification.
      * 
      * @parameter expression="${licenses.excludedLibraries}"
      */
     protected String excludedLibraries;
 
     /**
      * The projects in the reactor for aggregation report.
      * 
      * @parameter expression="${reactorProjects}"
      * @readonly
      */
     private List reactorProjects;
 
     /**
      * Whether to work at the root, or work on each module independently
      * 
      * @parameter expression="${licenses.aggregate}" default-value="true"
      */
     protected boolean aggregate;
 
     protected void visitDependencyProjects(ProjectVisitor visitor) throws MojoExecutionException
     {
         if (aggregate && !project.isExecutionRoot())
         {
             return;
         }
 
         final Set dependencies = resolveDependencies();
 
         visitor.onInit(dependencies.size());
 
         for (Iterator iterator = dependencies.iterator(); iterator.hasNext();)
         {
             final Artifact depArtifact = (Artifact) iterator.next();
             try
             {
                 // for each dependency we need to build a project in order to
                 // retrieve its licensing information
                 MavenProject depProject = mavenProjectBuilder.buildFromRepository(depArtifact, remoteRepositories,
                         localRepository);
                 visitor.visit(depProject);
             }
             catch (ProjectBuildingException e)
             {
                 throw new MojoExecutionException("Failed to build a project for artifact: " + depArtifact, e);
             }
         }
         visitor.onComplete();
     }
 
     /**
      * Attempts to extract the license location for the project. If that fails -
      * performs a search for other potential license locations inside the JAR as
      * defined in {@link #LICENSE_PATH_OPTIONS}
      * 
      * @param license -
      *            license object from the maven project. If this is null, this
      *            method will search the artifact location
      * @param artifact -
      *            artifact for which the license is being looked up
      * @return a valid URL to the license file or null if no valid JAR or entry
      *         is found
      */
     protected String createValidLicenseUrl(License license, Artifact artifact)
     {
         String urlString = findLicenseInRepository(artifact);
         if (urlString != null)
             return urlString;
 
         if (license != null)
         {
             urlString = license.getUrl();
         }
 
         if (urlString == null || urlString.startsWith("/") || urlString.startsWith("\\"))
         {
             // this is a path inside the JAr file - we need to turn it into a valid URL
             return findLicenseInJar(artifact, urlString);
         }
 
         // otherwise it is a remote URL
         return urlString;
     }
 
     /**
      * Returns a download URL of the corresponding artifact with classifier
      * 'license' for the given artifact or null if license isn't found in maven
      * repository.
      * 
      * @param artifact
      * @return a valid URL to the license file or null if no license isn't in
      *         maven repository
      */
     protected String findLicenseInRepository(Artifact artifact)
     {
         Artifact licenseArtifact = artifactFactory.createArtifact(artifact.getGroupId(), artifact.getArtifactId(),
                 artifact.getVersion(), null, LICENSE_TYPE);
         try
         {
             resolver.resolve(licenseArtifact, remoteRepositories, localRepository);
             if (licenseArtifact.getFile() != null)
             {
                 try
                 {
                     return licenseArtifact.getFile().toURL().toString();
                 }
                 catch (MalformedURLException e)
                 {
                     getLog().warn("Failed to convert " + licenseArtifact.getFile() + " to a URL", e);
                     return "file:" + licenseArtifact.getFile().getAbsolutePath();
                 }
             }
             else
                 return licenseArtifact.getDownloadUrl();
         }
         catch (ArtifactResolutionException e)
         {
             getLog().info("Failed to resolve license artifact " + licenseArtifact, e);
             return null;
         }
         catch (ArtifactNotFoundException e)
         {
             if (getLog().isDebugEnabled())
                 getLog().debug("License artifact " + licenseArtifact + " is not found", e);
             return null;
         }
     }
 
     /**
      * Attempts to find the JAR file for this artifact and then the given file
      * path in the JAR. If the entry does not exist - will try to search for
      * other potential license locations inside the JAR as defined in
      * {@link #LICENSE_PATH_OPTIONS}
      * 
      * @param artifact -
      *            will be used to lookup the JAR file for this artifact
      * @param filePath -
      *            path to the license inside the JAR
      * @return a valid URL to the license file or null if no valid JAR or entry
      *         is found
      */
     private String findLicenseInJar(Artifact artifact, String filePath)
     {
         final String jarPath = "jar:" + localRepository.getUrl() + File.separator + localRepository.pathOf(artifact);
 
         if (filePath != null && filePath.length() != 0)
         {
             // check the given URL if it is valid
             // make sure we do not much up the path as JAR entries are sensitive
             // to having "//" in them
             if (filePath.startsWith("/") || filePath.startsWith("\\"))
             {
                 filePath = "META-INF" + filePath;
             }
             else
             {
                 filePath = "META-INF/" + filePath;
             }
 
             // validate
             String url = toUrl(jarPath, filePath);
             if (url != null)
                 return url;
         }
 
         for (Iterator iter = LICENSE_PATH_OPTIONS.iterator(); iter.hasNext();)
         {
             String url = toUrl(jarPath, (String) iter.next());
             if (url != null)
                 return url;
         }
 
         return null;
     }
 
     /**
      * Returns a URL to the entry in the given JAr if both the JAR file and the
      * entry in it actually exist. Otherwise returns null.
      * 
      * @param jarPath -
      *            path to the JAR file to check
      * @param entry -
      *            path to the entry inside the JAr file to check
      * @return - a valid URL to the entry inside the JAR or null if either the
      *         JAr or the entry do not exist
      */
     private String toUrl(String jarPath, String entry)
     {
         try
         {
             if (new JarFile(jarPath).getEntry(entry) != null)
             {
                 return jarPath + "!/" + entry;
             }
             else
             {
                 if (getLog().isDebugEnabled())
                     getLog().debug("Entry " + entry + " is not found in " + jarPath);
                 return null;
             }
         }
         catch (Exception e)
         {
             if (getLog().isDebugEnabled())
                 getLog().debug("Path is invalid: " + jarPath, e);
             return null;
         }
     }
 
     private Set resolveDependencies() throws MojoExecutionException
     {
         // this is a list of direct dependencies as specified in the POM
         // excluding those with unwanted scopes
         Set dependencies = new TreeSet(project.getDependencyArtifacts());
 
         // then we gather all modules as direct dependencies
         for (Iterator i = reactorProjects.iterator(); i.hasNext();)
         {
             MavenProject subProject = (MavenProject) i.next();
             if (subProject != project)
             {
                 getLog().info("Aggregating dependency for " + subProject.getName());
                 dependencies.add(subProject.getArtifact());
             }
         }
 
         try
         {
             // now we need to resolve all the transitive dependencies too
             ArtifactFilter filter = createExclusionFilter();
             ArtifactResolutionResult result = resolver.resolveTransitively(dependencies, project.getArtifact(),
                     localRepository, remoteRepositories, artifactMetadataSource, filter);
             return result.getArtifacts();
         }
         catch (MalformedPatternException e)
         {
             throw new MojoExecutionException("Failed to parse an exclusion filter", e);
         }
         catch (ArtifactResolutionException e)
         {
             throw new MojoExecutionException("Failed to resolve transitively.", e);
         }
         catch (ArtifactNotFoundException e)
         {
             throw new MojoExecutionException("Failed to resolve transitively.", e);
         }
     }
 
     protected ArtifactExclusionFilter createExclusionFilter() throws MalformedPatternException
     {
         // make sure we have a non-null exclusion lists
         validateExclusionList();
         return new ArtifactExclusionFilter(excludedLibraryList, excludedScopeList);
     }
 
     /**
      * checks the List version and String version of the parameters and makes
      * sure the List is not null
      */
     private void validateExclusionList()
     {
         this.excludedScopeList = fillListIfNull(excludedScopes, excludedScopeList);
         this.excludedLibraryList = fillListIfNull(excludedLibraries, excludedLibraryList);
     }
 
     private static List fillListIfNull(String csvString, List list)
     {
         if (list == null)
         {
             list = new ArrayList();
             if (csvString != null && csvString.length() > 0)
             {
                 StringTokenizer tokenizer = new StringTokenizer(csvString, ",");
                 while (tokenizer.hasMoreTokens())
                     list.add(tokenizer.nextToken());
             }
         }
         return list;
     }
 }