/*
    * Copyright (C) 2000 - 2008 Grid Systems, S.A.
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU General Public License, version 2, as
    * published by the Free Software Foundation.
    *
    * This program is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  package com.gridsystems.maven.furabuild;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.PrintStream;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  import java.util.jar.Attributes;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import org.apache.maven.artifact.Artifact;
  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.versioning.VersionRange;
  import org.apache.maven.model.Dependency;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.codehaus.plexus.util.IOUtil;
  
  /**
   * Goal for parsing the tag file.
   *
   * @goal generate-plugin-descriptor
   * @phase generate-resources
   *
   * @author Rodrigo Ruiz
   */
  public class PluginGenMojo extends AbstractFuraBuildMojo {
  
    /**
     * {@inheritDoc}
     */
    public void execute() throws MojoExecutionException {
      Properties props = project.getProperties();
  
      String pluginName = props.getProperty("pluginName");
      String pluginClass = props.getProperty("pluginClass");
      String codeName = props.getProperty("codeName");
      String eula = props.getProperty("eula");
  
      if (pluginName == null || pluginClass == null) {
        getLog().info("No plugin name and/or class found. Descriptor not generated");
        return;
      }
  
      if (props.getProperty("tag.version") == null) {
        processLocation(props, location, "tag.version", defaultTag);
      }
  
      String year = project.getInceptionYear();
      String company = project.getOrganization().getName();
      String cright = "Copyright (c)" + year + " " + company;
  
      String descr = project.getDescription();
      if (descr == null) {
        descr = "";
      }
  
      getLog().debug("Generating plugin descriptor at " + outputDirectory);
  
      outputDirectory.mkdirs();
      File f = new File(outputDirectory, "plugin.xml");
  
      PrintStream out = null;
      try {
        out = new PrintStream(f);
        out.println("<?xml version='1.0' encoding='UTF-8'?>");
        out.println("<plugin>");
        printTag(out, "  name", pluginName);
        printTag(out, "  description", descr);
        printTag(out, "  copyright", cright);
        out.println("  <version>");
        printTag(out, "    major", props.getProperty("tag.version.major"));
        printTag(out, "    minor", props.getProperty("tag.version.minor"));
        printTag(out, "    release", props.getProperty("tag.version.release"));
        printTag(out, "    build", props.getProperty("tag.version.build"));
        printTag(out, "    codeName", codeName);
        out.println("  </version>");
       printTag(out, "  class", pluginClass);
 
       printDependencies(out);
 
       printTag(out, "  eula", eula);
       out.println("</plugin>");
     } catch (IOException e) {
       throw new MojoExecutionException("Error writing plugin.xml", e);
     } finally {
       IOUtil.close(out);
     }
 
     projectHelper.addResource(
       project,
       outputDirectory.getAbsolutePath(),
       Collections.singletonList("plugin.xml"),
       Collections.EMPTY_LIST
     );
   }
 
   /**
    * Gets the set of artifacts in the project.
    *
    * @return A Set containing all dependency artifacts
    */
   @SuppressWarnings("unchecked")
   private Set<Artifact> getArtifacts() {
     Set<Artifact> artifacts = project.getArtifacts();
     if (artifacts == null || artifacts.isEmpty()) {
       artifacts = createArtifacts();
       project.setArtifacts(artifacts);
     }
     return artifacts;
   }
 
   /**
    * Creates the set of artifacts for the project.
    *
    * @return A Set containing all dependency artifacts
    */
   @SuppressWarnings("unchecked")
   private Set<Artifact> createArtifacts() {
 
     List<?> dependencies = project.getDependencies();
     List<?> remoteRepositories = Collections.EMPTY_LIST;
     Set<Artifact> dependencyArtifacts = new HashSet<Artifact>();
 
     for (Iterator<?> it = dependencies.iterator(); it.hasNext();) {
       Dependency dep = (Dependency)it.next();
 
       VersionRange vr = VersionRange.createFromVersion(dep.getVersion());
 
       Artifact artifact = factory.createDependencyArtifact(
         dep.getGroupId(), dep.getArtifactId(), vr,
         dep.getType(), dep.getClassifier(), dep.getScope()
       );
       dependencyArtifacts.add(artifact);
     }
 
     try {
       ArtifactResolutionResult result = resolver.resolveTransitively(
         dependencyArtifacts, project.getArtifact(), remoteRepositories,
         local, source);
 
       return result.getArtifacts();
     } catch (ArtifactResolutionException e) {
       getLog().warn("Skipping: " + e.getArtifactId() + ". It cannot be resolved.");
     } catch (ArtifactNotFoundException e) {
       getLog().warn("Skipping: " + e.getArtifactId() + ". It cannot be resolved.");
     }
 
     return dependencyArtifacts;
   }
 
   /**
    * Prints the list of plugin dependencies.
    *
    * @param out Stream to print to
    */
   private void printDependencies(PrintStream out) throws MojoExecutionException {
     out.println("  <dependencies>");
 
     Set<?> artifacts = getArtifacts();
     if (artifacts == null || artifacts.isEmpty()) {
       getLog().info("No dependencies found in project " + project.getName());
 
     } else {
       getLog().debug("Found " + artifacts.size() + " artifacts");
       for (Iterator<?> it = artifacts.iterator(); it.hasNext();) {
         Artifact art = (Artifact)it.next();
         getLog().debug("Artifact found: " + art);
         try {
           JarFile f = new JarFile(art.getFile());
           Manifest manifest = f.getManifest();
           Attributes attrs = (manifest == null) ? null : manifest.getMainAttributes();
           if (attrs != null) {
             String pluginName = attrs.getValue("Plugin-Name");
             String version = attrs.getValue("Plugin-Version");
 
             if (pluginName != null && pluginName.length() > 0) {
               getLog().info("Found dependency on " + pluginName + ":" + version);
               out.print("    <plugin name='");
               out.print(pluginName);
               out.print("' version='");
               out.print(version);
               out.println("'/>");
             }
           }
           f.close();
         } catch (IOException e) {
           // ignore
         }
       }
     }
 
     out.println("  </dependencies>");
   }
 
   /**
    * Prints a tag into <tt>out</tt>.
    *
    * @param out  Stream to print to
    * @param tag  Indented tag name
    * @param text Tag contents
    */
   private void printTag(PrintStream out, String tag, String text) {
     if (text != null) {
       int pos = tag.lastIndexOf(' ');
       String indent = tag.substring(0, pos + 1);
       String tagName = tag.substring(pos + 1);
 
       out.print(indent);
       out.print('<');
       out.print(tagName);
       out.print('>');
       out.print(text);
       out.print("</");
       out.print(tagName);
       out.println('>');
     }
   }
 
 }