/*
    *   Copyright (C) 2005 Christian Schulte <cs@schulte.it>
    *   All rights reserved.
    *
    *   Redistribution and use in source and binary forms, with or without
    *   modification, are permitted provided that the following conditions
    *   are met:
    *
    *     o Redistributions of source code must retain the above copyright
   *       notice, this list of conditions and the following disclaimer.
   *
   *     o Redistributions in binary form must reproduce the above copyright
   *       notice, this list of conditions and the following disclaimer in
   *       the documentation and/or other materials provided with the
   *       distribution.
   *
   *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
   *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
   *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
   *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   *   $JOMC: AbstractAttachMojo.java 5325 2016-09-01 00:33:38Z schulte $
   *
   */
  package org.jomc.mojo;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import org.apache.maven.artifact.ArtifactUtils;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.descriptor.MojoDescriptor;
  import org.apache.maven.plugins.annotations.Component;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectHelper;
  
  /**
   * Base class for attaching artifacts to a project.
   *
   * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
   * @version $JOMC: AbstractAttachMojo.java 5325 2016-09-01 00:33:38Z schulte $
   */
  public abstract class AbstractAttachMojo extends AbstractMojo
  {
  
      /**
       * Constant for the name of the tool backing the mojo.
       */
      private static final String TOOLNAME = "MavenProjectHelper";
  
      /**
       * Prefix prepended to log messages.
       */
      private static final String LOG_PREFIX = "[JOMC] ";
  
      /**
       * The Maven project of the instance.
       */
      @Parameter( name = "mavenProject",
                  defaultValue = "${project}",
                  readonly = true,
                  required = true )
      private MavenProject mavenProject;
  
      /**
       * The Maven ProjectHelper of the instance.
       */
      @Component
      private MavenProjectHelper mavenProjectHelper;
  
      /**
       * The Maven session of the instance.
       *
       * @since 1.1
       */
      @Parameter( name = "mavenSession",
                  defaultValue = "${session}",
                  readonly = true,
                  required = true )
      private MavenSession mavenSession;
  
      /**
       * Directory holding the session related files of the project.
       *
       * @since 1.1
       */
     @Parameter( name = "sessionDirectory",
                 property = "jomc.sessionDirectory",
                 defaultValue = "${project.build.directory}/jomc-sessions" )
     private String sessionDirectory;
 
     /**
      * Controls verbosity of the plugin.
      *
      * @since 1.1
      */
     @Parameter( name = "verbose",
                 property = "jomc.verbose",
                 defaultValue = "false" )
     private boolean verbose;
 
     /**
      * Creates a new {@code AbstractAttachMojo} instance.
      */
     public AbstractAttachMojo()
     {
         super();
     }
 
     /**
      * Gets the Maven project of the instance.
      *
      * @return The Maven project of the instance.
      *
      * @throws MojoExecutionException if getting the Maven project of the instance fails.
      *
      * @since 1.1
      */
     protected MavenProject getMavenProject() throws MojoExecutionException
     {
         return this.mavenProject;
     }
 
     /**
      * Gets the Maven session of the instance.
      *
      * @return The Maven session of the instance.
      *
      * @throws MojoExecutionException if getting the Maven session of the instance fails.
      *
      * @since 1.1
      */
     protected MavenSession getMavenSession() throws MojoExecutionException
     {
         return this.mavenSession;
     }
 
     /**
      * Gets the Maven project helper of the instance.
      *
      * @return The Maven project helper of the instance.
      *
      * @throws MojoExecutionException if getting the Maven project helper of the instance fails.
      *
      * @since 1.1
      */
     protected MavenProjectHelper getMavenProjectHelper() throws MojoExecutionException
     {
         return this.mavenProjectHelper;
     }
 
     /**
      * Gets the directory holding the session related files of the project.
      *
      * @return The directory holding the session related files of the project.
      *
      * @throws MojoExecutionException if getting the directory fails.
      *
      * @since 1.1
      */
     protected File getSessionDirectory() throws MojoExecutionException
     {
         File directory = new File( this.sessionDirectory );
 
         if ( !directory.isAbsolute() )
         {
             directory = new File( this.getMavenProject().getBasedir(), this.sessionDirectory );
         }
 
         return directory;
     }
 
     /**
      * Gets a flag indicating verbose output is enabled.
      *
      * @return {@code true}, if verbose output is enabled; {@code false}, if information messages are suppressed.
      *
      * @throws MojoExecutionException if getting the flag fails.
      *
      * @since 1.1
      */
     protected final boolean isVerbose() throws MojoExecutionException
     {
         return this.verbose;
     }
 
     /**
      * Sets the flag indicating verbose output is enabled.
      *
      * @param value {@code true}, to enable verbose output; {@code false}, to suppress information messages.
      *
      * @throws MojoExecutionException if setting the flag fails.
      *
      * @since 1.1
      */
     protected final void setVerbose( final boolean value ) throws MojoExecutionException
     {
         this.verbose = value;
     }
 
     /**
      * Gets the file of the artifact to attach.
      *
      * @return The file of the artifact to attach.
      */
     protected abstract File getArtifactFile();
 
     /**
      * Gets the classifier of the artifact to attach.
      *
      * @return The classifier of the artifact to attach.
      */
     protected abstract String getArtifactClassifier();
 
     /**
      * Gets the type of the artifact to attach.
      *
      * @return The type of the artifact to attach.
      */
     protected abstract String getArtifactType();
 
     /**
      * Gets the execution strategy of the instance.
      *
      * @return The execution strategy of the instance.
      *
      * @since 1.1
      */
     protected abstract String getExecutionStrategy();
 
     public final void execute() throws MojoExecutionException, MojoFailureException
     {
         final File attachment =
             new File( this.getSessionDirectory(),
                       ArtifactUtils.versionlessKey( this.getMavenProject().getArtifact() ).hashCode()
                           + "-" + this.getArtifactClassifier()
                           + "-" + this.getMavenSession().getStartTime().getTime()
                           + "." + this.getArtifactType() );
 
         try
         {
             if ( this.isVerbose() && this.getLog().isInfoEnabled() )
             {
                 this.getLog().info( LOG_PREFIX + Messages.getMessage( "separator" ) );
                 this.getLog().info( LOG_PREFIX + Messages.getMessage( "title" ) );
             }
 
             if ( MojoDescriptor.MULTI_PASS_EXEC_STRATEGY.equals( this.getExecutionStrategy() )
                      || !attachment.exists() )
             {
                 if ( this.isVerbose() && this.getLog().isInfoEnabled() )
                 {
                     this.getLog().info( LOG_PREFIX + Messages.getMessage( "separator" ) );
                     this.getLog().info( LOG_PREFIX + Messages.getMessage(
                         "processingProject", TOOLNAME, this.getMavenProject().getName() == null
                                                            ? this.getMavenProject().getArtifactId()
                                                            : this.getMavenProject().getName() ) );
 
                 }
 
                 if ( this.getArtifactFile().isFile() )
                 {
                     if ( attachment.exists() && !attachment.delete() )
                     {
                         this.getLog().warn( LOG_PREFIX + Messages.getMessage(
                             "failedDeletingFile", attachment.getAbsolutePath() ) );
 
                     }
                     if ( !attachment.getParentFile().exists() && !attachment.getParentFile().mkdirs() )
                     {
                         throw new MojoExecutionException( Messages.getMessage(
                             "failedCreatingDirectory", attachment.getParentFile().getAbsolutePath() ) );
 
                     }
 
                     this.copyFile( this.getArtifactFile(), attachment );
                     this.getMavenProjectHelper().attachArtifact( this.getMavenProject(), this.getArtifactType(),
                                                                  this.getArtifactClassifier(), attachment );
 
                     if ( this.isVerbose() && this.getLog().isInfoEnabled() )
                     {
                         this.getLog().info( LOG_PREFIX + Messages.getMessage(
                             "creatingAttachment", this.getArtifactFile().getAbsolutePath(),
                             this.getArtifactClassifier(), this.getArtifactType() ) );
 
                         this.getLog().info( LOG_PREFIX + Messages.getMessage( "toolSuccess", TOOLNAME ) );
                     }
                 }
                 else if ( this.getLog().isWarnEnabled() )
                 {
                     this.getLog().warn( LOG_PREFIX + Messages.getMessage(
                         "artifactFileNotFound", this.getArtifactFile().getAbsolutePath() ) );
 
                 }
             }
             else if ( this.isVerbose() && this.getLog().isInfoEnabled() )
             {
                 this.getLog().info( LOG_PREFIX + Messages.getMessage( "executionSuppressed",
                                                                       this.getExecutionStrategy() ) );
 
             }
         }
         catch ( final IOException e )
         {
             final String message = Messages.getMessage( e );
             throw new MojoExecutionException( Messages.getMessage(
                 "failedCopying", this.getArtifactFile().getAbsolutePath(), attachment.getAbsolutePath(),
                 message != null ? message : "" ), e );
 
         }
         finally
         {
             if ( this.isVerbose() && this.getLog().isInfoEnabled() )
             {
                 this.getLog().info( LOG_PREFIX + Messages.getMessage( "separator" ) );
             }
         }
     }
 
     /**
      * Copies a file.
      *
      * @param source The file to copy.
      * @param target The file to copy the source file to.
      *
      * @throws IOException if copying fails.
      *
      * @since 1.10
      */
     protected final void copyFile( final File source, final File target ) throws IOException
     {
         InputStream in = null;
         OutputStream out = null;
         try
         {
             if ( !source.equals( target ) )
             {
                 in = new FileInputStream( source );
                 out = new FileOutputStream( target );
 
                 final byte[] buffer = new byte[ 65536 ];
 
                 for ( int read = in.read( buffer );
                       read >= 0;
                       out.write( buffer, 0, read ), read = in.read( buffer ) );
 
                 out.close();
                 out = null;
 
                 in.close();
                 in = null;
             }
         }
         finally
         {
             try
             {
                 if ( out != null )
                 {
                     out.close();
                 }
             }
             catch ( final IOException e )
             {
                 this.getLog().warn( e );
             }
             finally
             {
                 try
                 {
                     if ( in != null )
                     {
                         in.close();
                     }
                 }
                 catch ( final IOException e )
                 {
                     this.getLog().warn( e );
                 }
             }
         }
     }
 
 }