/*
    * #%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.tasks;
  
  import org.apache.commons.lang.SystemUtils;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.plugin.logging.SystemStreamLog;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * Base Abstract Class for all of the Tasks.
   *
   * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
   */
  public abstract class AbstractTask
  {
      /**
       * The shared command line args.
       */
      protected CommandLineArguments cmdLineArgs;
  
      private Log log;
  
      private String maxmem;
  
      private List<Artifact> pluginClasspathList;
  
      private String taskClass;
  
      private boolean quiet;
  
      /**
       * Initialize AbstractTask.
       *
       * @param taskClassname the classname for the task.
       */
      protected AbstractTask( String taskClassname )
      {
          taskClass = taskClassname;
          cmdLineArgs = new CommandLineArguments();
          maxmem = "64m";
      }
  
      /**
       * Setter for <code>quiet</code>.
       *
       * @param quiet The quiet to set.
       */
      public void setQuiet( boolean quiet )
      {
          this.quiet = quiet;
      }
  
      /**
       * Getter for <code>quiet</code>.
       *
       * @return Returns the quiet.
       */
      public boolean isQuiet()
      {
          return quiet;
      }
  
      /**
       * Using the <code>${project.compileClasspathElements}</code> and the <code>${plugin.artifacts}</code>, create
       * a classpath string that is suitable to be used from a forked cobertura process.
       *
       * @return the classpath string
      * @throws MojoExecutionException if the pluginArtifacts cannot be properly resolved to a full system path.
      */
     public String createClasspath()
         throws MojoExecutionException
     {
 
         StringBuffer cpBuffer = new StringBuffer();
 
         for ( Iterator<Artifact> it = pluginClasspathList.iterator(); it.hasNext(); )
         {
             Artifact artifact = it.next();
 
             try
             {
                 cpBuffer.append( File.pathSeparator ).append( artifact.getFile().getCanonicalPath() );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException(
                     "Error while creating the canonical path for '" + artifact.getFile() + "'.", e );
             }
         }
 
         return cpBuffer.toString();
     }
 
     private String getLog4jConfigFile()
     {
         String resourceName = "cobertura-plugin/log4j-info.properties";
         if ( getLog().isDebugEnabled() )
         {
             resourceName = "cobertura-plugin/log4j-debug.properties";
         }
         if ( quiet )
         {
             resourceName = "cobertura-plugin/log4j-error.properties";
         }
 
         String path = null;
         try
         {
             File log4jconfigFile = File.createTempFile( "log4j", "config.properties" );
             URL log4jurl = this.getClass().getClassLoader().getResource( resourceName );
             FileUtils.copyURLToFile( log4jurl, log4jconfigFile );
             log4jconfigFile.deleteOnExit();
             path = log4jconfigFile.toURL().toExternalForm();
         }
         catch ( MalformedURLException e )
         {
             // ignore
         }
         catch ( IOException e )
         {
             // ignore
         }
         return path;
     }
 
     /**
      * Run the task.
      *
      * @throws MojoExecutionException for a full-out execution problem.
      * @throws MojoFailureException   for an anticipated failure.
      */
     public abstract void execute()
         throws MojoExecutionException, MojoFailureException;
 
     /**
      * Run a jvm to execute something.
      *
      * @return the exit code.
      * @throws MojoExecutionException for an error launching the jvm.
      */
     protected int executeJava()
         throws MojoExecutionException
     {
         Commandline cl = new Commandline();
         File java = new File( SystemUtils.getJavaHome(), "bin/java" );
         cl.setExecutable( java.getAbsolutePath() );
         cl.addEnvironment( "CLASSPATH", createClasspath() );
 
         String log4jConfig = getLog4jConfigFile();
         if ( log4jConfig != null )
         {
             cl.createArg().setValue( "-Dlog4j.configuration=" + log4jConfig );
         }
 
         cl.createArg().setValue( "-Xmx" + maxmem );
 
         cl.createArg().setValue( taskClass );
 
         if ( cmdLineArgs.useCommandsFile() )
         {
             String commandsFile;
             try
             {
                 commandsFile = cmdLineArgs.getCommandsFile();
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Unable to obtain CommandsFile location.", e );
             }
             if ( FileUtils.fileExists( commandsFile ) )
             {
                 cl.createArg().setValue( "--commandsfile" );
                 cl.createArg().setValue( commandsFile );
             }
             else
             {
                 throw new MojoExecutionException( "CommandsFile doesn't exist: " + commandsFile );
             }
         }
         else
         {
             Iterator<String> it = cmdLineArgs.iterator();
             while ( it.hasNext() )
             {
                 cl.createArg().setValue( it.next() );
             }
         }
 
         CommandLineUtils.StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer();
 
         CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();
 
         if ( quiet )
         {
             CommandLineUtils.StringStreamConsumer nullConsumer = new CommandLineUtils.StringStreamConsumer()
             {
                 public void consumeLine( String line )
                 {
                     // swallow
                 }
             };
             stdout = nullConsumer;
             stderr = nullConsumer;
         }
 
         getLog().debug( "Working Directory: " + cl.getWorkingDirectory() );
         try
         {
             String[] environmentVariables = cl.getEnvironmentVariables();
             for ( String environmentVariable : environmentVariables )
             {
                 getLog().debug( "Environment variable: " + environmentVariable );
             }
         }
         catch( CommandLineException e ) {
             // Ignore
         }
         getLog().debug( "Executing command line:" );
         getLog().debug( cl.toString() );
 
         int exitCode;
         try
         {
             exitCode = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
         }
         catch ( CommandLineException e )
         {
             throw new MojoExecutionException( "Unable to execute Cobertura.", e );
         }
 
         getLog().debug( "exit code: " + exitCode );
 
         String output = stdout.getOutput();
 
         if ( output.trim().length() > 0 )
         {
             getLog().debug( "--------------------" );
             getLog().debug( " Standard output from the Cobertura task:" );
             getLog().debug( "--------------------" );
             getLog().info( output );
             getLog().debug( "--------------------" );
         }
 
         String stream = stderr.getOutput();
 
         if ( stream.trim().length() > 0 )
         {
             getLog().debug( "--------------------" );
             getLog().debug( " Standard error from the Cobertura task:" );
             getLog().debug( "--------------------" );
             getLog().error( stderr.getOutput() );
             getLog().debug( "--------------------" );
         }
 
         return exitCode;
     }
 
     /**
      * Return the command line args.
      *
      * @return the command line args.
      */
     public CommandLineArguments getCmdLineArgs()
     {
         return cmdLineArgs;
     }
 
     /**
      * @return a log object.
      */
     public Log getLog()
     {
         if ( log == null )
         {
             log = new SystemStreamLog();
         }
 
         return log;
     }
 
     /**
      * @return the configured -Xmx option.
      */
     public String getMaxmem()
     {
         return maxmem;
     }
 
     /**
      * @return Returns the pluginClasspathList.
      */
     public List<Artifact> getPluginClasspathList()
     {
         return pluginClasspathList;
     }
 
     /**
      * Set the entire command line args.
      *
      * @param cmdLineArgs new args.
      */
     public void setCmdLineArgs( CommandLineArguments cmdLineArgs )
     {
         this.cmdLineArgs = cmdLineArgs;
     }
 
     /**
      * Set the logger.
      *
      * @param log the new logger.
      */
     public void setLog( Log log )
     {
         this.log = log;
     }
 
     /**
      * Set the -Xmx value for the jvm.
      *
      * @param maxmem the memory size.
      */
     public void setMaxmem( String maxmem )
     {
         this.maxmem = maxmem;
     }
 
     /**
      * @param pluginClasspathList The pluginClasspathList to set.
      */
     public void setPluginClasspathList( List<Artifact> pluginClasspathList )
     {
         this.pluginClasspathList = Collections.unmodifiableList( pluginClasspathList );
     }
 }