package com.atlassian.maven.plugins.licenses;
   
   import java.io.BufferedOutputStream;
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.model.License;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.IOUtil;
  
  /**
   * After resolving all the dependencies of this project, for each one of them,
   * this mojo attemps to determine a valid URL for license location for this
   * project and download it.
   * 
   * First of all it attempts to extract the license location from the project
   * POM. If that fails - performs a search for other potential license locations
   * inside the JAR as defined in {@link #LICENSE_PATH_OPTIONS}
   * 
   * The file name is structured as artifactId-version-LICENSE. For projects
   * with multiple licenses the file name is artifactId-version-LICENSE-n
   * where n is a license counter (starting from 0).
   * 
   * @author Sherali Karimov
   * @goal download
   */
  public class DownloadMojo extends AbstractLicensesMojo
  {
      /**
       * Target directory where to save downloaded license files
       * 
       * @parameter expression="${licenses.outputDirectory}" default-value="${project.build.directory}/licenses/"
       * @required
       */
      protected String outputDirectory;
  
      public void execute() throws MojoExecutionException, MojoFailureException
      {
          visitDependencyProjects(new ProjectVisitor()
          {
              public void visit(MavenProject depProject) throws MojoExecutionException
              {
                  List licenses = depProject.getLicenses();
                  Artifact artifact = depProject.getArtifact();
                  String fileName = generatePathToSaveLicense(artifact);
  
                  if (licenses.isEmpty())
                  {
                      downloadLicense(depProject, null, fileName);
                      return;
                  }
                  int licenseCount = 0;
                  for (Iterator licIter = licenses.iterator(); licIter.hasNext();)
                  {
                      License license = (License) licIter.next();
                      if (getLog().isDebugEnabled())
                      {
                          getLog().debug("Attempting to fetch " + license.getName() + " for " + artifact);
                      }
  
                      // TODO - the file name fiddling doesn't delong here!
                      // find a better way of dealing with multiple licenses in a
                      // fileName
                      if (licenseCount > 0)
                          fileName += "-" + licenseCount;
                      licenseCount++;
                      downloadLicense(depProject, license, fileName);
                  }
              }
  
              public void onComplete()
              {/* nothing to do, really */
              }
  
              public void onInit(int numDeps)
              {/* nothing to do, really */
              }
          });
      }
  
      /**
       * Attemps to determine a valid URL for license location for this project
       * and download it.
       * 
       * @param depProject -
       *            maven project of the artifact for which the license is being
       *            looked up
       * @param license -
      *            license object from the maven project. If this is null, this
      *            method will search the artifact location
      * @param fileName -
      *            target file path where to save the license if found
      */
     protected void downloadLicense(MavenProject depProject, License license, String fileName)
             throws MojoExecutionException
     {
         Artifact artifact = depProject.getArtifact();
         String urlStr = createValidLicenseUrl(license, artifact);
         if (urlStr == null)
         {
             getLog().error(artifact + " contains no licensing information.");
             return;
         }
 
         try
         {
             URL url = new URL(urlStr);
             InputStream in = url.openStream();
 
             // make sure the directory exists
             File targetDir = new File(fileName).getParentFile();
             if (!targetDir.exists())
             {
                 getLog().debug("Creating directory " + targetDir.getPath());
                 targetDir.mkdirs();
             }
 
             OutputStream out = new BufferedOutputStream(new FileOutputStream(fileName));
             getLog().info("Loading license for " + artifact + " from " + urlStr + " into " + fileName);
 
             try
             {
                 IOUtil.copy(in, out);
             }
             finally
             {
                 IOUtil.close(out);
                 IOUtil.close(in);
             }
         }
         catch (MalformedURLException e)
         {
             getLog().error("Failed to download the license for " + artifact + ". URL is invalid: " + urlStr, e);
         }
         catch (FileNotFoundException e)
         {
             getLog().error("File name is invalid " + fileName, e);
         }
         catch (IOException e)
         {
             getLog().error("Failed to download the license for " + artifact, e);
         }
     }
 
     /**
      * The file name is structured as artifactId-version-LICENSE
      * 
      * @param artifact -
      *            artifact for which to generate the license output location
      * @return file name for the license output location
      */
     protected String generatePathToSaveLicense(Artifact artifact)
     {
         // TODO - infer the extension correctly from the URL
         return outputDirectory + File.separator + artifact.getArtifactId() + "-" + artifact.getVersion() + "-LICENSE";
     }
 }