/*
    * #%L
    * Mojo's Maven plugin for Cobertura
    * %%
    * Copyright (C) 2005 - 2013 Codehaus
    * %%
    * 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.
   * #L%
   */
  package org.codehaus.mojo.cobertura;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.ArtifactUtils;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.handler.ArtifactHandler;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProjectHelper;
  import org.codehaus.mojo.cobertura.configuration.ConfigInstrumentation;
  import org.codehaus.mojo.cobertura.tasks.InstrumentTask;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.IOUtil;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  
  /**
   * Instrument the compiled classes.
   *
   * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
   * @goal instrument
   * @requiresDependencyResolution compile
   */
  public class CoberturaInstrumentMojo
      extends AbstractCoberturaMojo
  {
      /**
       * Artifact factory.
       *
       * @component
       */
      private ArtifactFactory factory;
  
      /**
       * Specifies whether or not to attach the Cobertura artifact to the project.
       *
       * @parameter expression="${cobertura.attach}" default-value="false"
       */
      private boolean attach;
  
      /**
       * Specifies the classifier to use for the attached ser artifact.
       *
       * @parameter expression="${cobertura.classifier}" default-value="cobertura"
       */
      private String classifier;
  
      /**
       * Used for attaching the source JAR to the project.
       *
       * @component
       */
      private MavenProjectHelper projectHelper;
  
      /**
       * The <a href="usage.html#Instrumentation">Instrumentation Configuration</a>.
       *
       * @parameter expression="${instrumentation}"
       */
      private ConfigInstrumentation instrumentation;
  
      /**
       * Build up a command line from the parameters and run Cobertura to instrument the code.
       *
       * @throws MojoExecutionException
       */
      public void execute()
          throws MojoExecutionException
      {
          if ( skipMojo() )
          {
              return;
          }
 
         ArtifactHandler artifactHandler = getProject().getArtifact().getArtifactHandler();
         if ( !"java".equals( artifactHandler.getLanguage() ) )
         {
             getLog().info(
                 "Not executing cobertura:instrument as the project is not a Java classpath-capable package" );
         }
         else
         {
             File instrumentedDirectory =
                 new File( getProject().getBuild().getDirectory(), "generated-classes/cobertura" );
 
             if ( !instrumentedDirectory.exists() )
             {
                 instrumentedDirectory.mkdirs();
             }
 
             // ensure that instrumentation config is set here, not via maven plugin api @required attribute, as this is
             // not a required object from the pom configuration's point of view.
             if ( instrumentation == null )
             {
                 instrumentation = new ConfigInstrumentation();
             }
 
             /* ensure that the default includes is set */
             if ( instrumentation.getIncludes().isEmpty() )
             {
                 instrumentation.addInclude( "**/*.class" );
             }
 
             File outputDirectory = new File( getProject().getBuild().getOutputDirectory() );
             if ( !outputDirectory.exists() )
             {
                 outputDirectory.mkdirs();
             }
 
             // Copy all of the classes into the instrumentation basedir.
             try
             {
                 FileUtils.copyDirectoryStructure( outputDirectory, instrumentedDirectory );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Unable to prepare instrumentation directory.", e );
             }
 
             instrumentation.setBasedir( instrumentedDirectory );
 
             // Cobertura requires an existing dir
             if ( !getDataFile().getParentFile().exists() )
             {
                 getDataFile().getParentFile().mkdirs();
             }
 
             // Execute the instrumentation task.
             InstrumentTask task = new InstrumentTask();
             setTaskDefaults( task );
             List<Artifact> classpath = new ArrayList<Artifact>();
             /* need project class path */
             classpath.addAll( pluginClasspathList );
             classpath.addAll( getProject().getArtifacts() );
             task.setPluginClasspathList( classpath );
             task.setConfig( instrumentation );
             task.setDestinationDir( instrumentedDirectory );
             task.setDataFile( getDataFile() );
 
             task.execute();
 
             addCoberturaDependenciesToTestClasspath();
 
             // Old, Broken way
             System.setProperty( "net.sourceforge.cobertura.datafile", getDataFile().getPath() );
 
             /*
              * New, Fixed way. See
              * https://sourceforge.net/tracker/index.php?func=detail&aid=1543280&group_id=130558&atid=720017 for patch
              * to Cobertura 1.8 that fixes the datafile location.
              */
             Properties props = new Properties();
             props.setProperty( "net.sourceforge.cobertura.datafile", getDataFile().getPath() );
 
             File coberturaPropertiesFile = new File( instrumentedDirectory, "cobertura.properties" );
             FileOutputStream fos = null;
             try
             {
                 fos = new FileOutputStream( coberturaPropertiesFile );
                 props.store( fos, "Generated by maven-cobertura-plugin for project " + getProject().getId() );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Unable to write cobertura.properties file.", e );
             }
             finally
             {
                 IOUtil.close( fos );
             }
 
             // Set the instrumented classes to be the new output directory (for other plugins to pick up)
             getProject().getBuild().setOutputDirectory( instrumentedDirectory.getPath() );
             System.setProperty( "project.build.outputDirectory", instrumentedDirectory.getPath() );
             attachCoberturaArtifactIfAppropriate();
         }
     }
 
     private void attachCoberturaArtifactIfAppropriate()
     {
         if ( attach )
         {
             if ( getDataFile().exists() )
             {
                 projectHelper.attachArtifact( getProject(), "ser", classifier, getDataFile() );
             }
             else
             {
                 getLog().info( "No cobertura ser file exists to include in the attached artifacts list." );
             }
         }
         else
         {
             getLog().info( "NOT adding cobertura ser file to attached artifacts list." );
         }
     }
 
     /**
      * We need to tweak our test classpath for cobertura.
      *
      * @throws MojoExecutionException
      */
     private void addCoberturaDependenciesToTestClasspath()
         throws MojoExecutionException
     {
         Map<String, Artifact> pluginArtifactMap = ArtifactUtils.artifactMapByVersionlessId( pluginClasspathList );
         Artifact coberturaArtifact = pluginArtifactMap.get( "net.sourceforge.cobertura:cobertura-runtime" );
 
         if ( coberturaArtifact == null )
         {
             getLog().error( "pluginArtifactMap: " + pluginArtifactMap );
 
             throw new MojoExecutionException( "Couldn't find 'cobertura' artifact in plugin dependencies" );
         }
 
         coberturaArtifact = artifactScopeToProvided( coberturaArtifact );
 
         if ( this.getProject().getDependencyArtifacts() != null )
         {
             Set<Artifact> set = new LinkedHashSet<Artifact>( this.getProject().getDependencyArtifacts() );
             set.add( coberturaArtifact );
             this.getProject().setDependencyArtifacts( set );
         }
     }
 
     /**
      * Use provided instead of just test, so it's available on both compile and test classpath (MCOBERTURA-26)
      *
      * @param artifact
      * @return re-scoped artifact
      */
     private Artifact artifactScopeToProvided( Artifact artifact )
     {
         return factory.createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(),
                                        Artifact.SCOPE_PROVIDED, artifact.getType() );
     }
 }