/*
    * #%L
    * Native ARchive plugin for Maven
    * %%
    * Copyright (C) 2002 - 2014 NAR Maven Plugin developers.
    * %%
    * 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 com.github.maven_nar;
  
  import java.io.File;
  import java.io.IOException;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.LifecyclePhase;
  import org.apache.maven.plugins.annotations.Mojo;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.codehaus.plexus.util.FileUtils;
  
  /**
   * Copies the GNU style source files to a target area, autogens and configures
   * them.
   * 
   * @author Mark Donszelmann
   */
  @Mojo(name = "nar-gnu-configure", requiresProject = true, defaultPhase = LifecyclePhase.PROCESS_SOURCES)
  public class NarGnuConfigureMojo extends AbstractGnuMojo {
  
    private static final String AUTOGEN = "autogen.sh";
  
    private static final String BUILDCONF = "buildconf";
  
    private static final String CONFIGURE = "configure";
  
    // JDK 1.4 compatibility
    private static String arraysToString(final Object[] a) {
      if (a == null) {
        return "null";
      }
      final int iMax = a.length - 1;
      if (iMax == -1) {
        return "[]";
      }
  
      final StringBuilder b = new StringBuilder();
      b.append('[');
      for (int i = 0;; i++) {
        b.append(String.valueOf(a[i]));
        if (i == iMax) {
          return b.append(']').toString();
        }
        b.append(", ");
      }
    }
  
    /**
     * If true, we run <code>./configure</code> in the source directory instead of
     * copying the
     * source code to the <code>target/</code> directory first (this saves disk
     * space but
     * violates Maven's paradigm of keeping generated files inside the
     * <code>target/</code> directory structure.
     */
    @Parameter(property = "nar.gnu.configure.in-place")
    private boolean gnuConfigureInPlace;
  
    /**
     * Skip running of autogen.sh (aka buildconf).
     */
    @Parameter(property = "nar.gnu.autogen.skip")
    private boolean gnuAutogenSkip;
  
    /**
     * Skip running of configure and therefore also autogen.sh
     */
    @Parameter(property = "nar.gnu.configure.skip")
    private boolean gnuConfigureSkip;
  
    /**
     * Arguments to pass to GNU configure.
     */
    @Parameter(property = "nar.gnu.configure.args", defaultValue = "")
    private String gnuConfigureArgs;
  
    /**
     * Arguments to pass to GNU buildconf.
     */
   @Parameter(property = "nar.gnu.buildconf.args", defaultValue = "")
   private String gnuBuildconfArgs;
 
   public NarGnuConfigureMojo() {
   }
 
   @Override
   public final void narExecute() throws MojoExecutionException, MojoFailureException {
 
     if (!useGnu()) {
       return;
     }
 
     final File sourceDir = getGnuSourceDirectory();
     if (sourceDir.exists()) {
       File targetDir;
 
       if (!this.gnuConfigureInPlace) {
         targetDir = getGnuAOLSourceDirectory();
 
         getLog().info("Copying GNU sources");
 
         try {
           FileUtils.mkdir(targetDir.getPath());
           NarUtil.copyDirectoryStructure(sourceDir, targetDir, null, null);
         } catch (final IOException e) {
           throw new MojoExecutionException("Failed to copy GNU sources", e);
         }
 
         if (!this.gnuConfigureSkip && !this.gnuAutogenSkip) {
           final File autogen = new File(targetDir, AUTOGEN);
           final File buildconf = new File(targetDir, BUILDCONF);
           if (autogen.exists()) {
             getLog().info("Running GNU " + AUTOGEN);
             runAutogen(autogen, targetDir, null);
           } else if (buildconf.exists()) {
             getLog().info("Running GNU " + BUILDCONF);
             String gnuBuildconfArgsArray[] = null;
             if (this.gnuBuildconfArgs != null) {
               gnuBuildconfArgsArray = this.gnuBuildconfArgs.split("\\s");
             }
             runAutogen(buildconf, targetDir, gnuBuildconfArgsArray);
           }
         }
       } else {
         targetDir = sourceDir;
       }
 
       final File configure = new File(targetDir, CONFIGURE);
       if (!this.gnuConfigureSkip && configure.exists()) {
         getLog().info("Running GNU " + CONFIGURE);
 
         NarUtil.makeExecutable(configure, getLog());
         String[] args = null;
 
         // create the array to hold constant and additional args
         if (this.gnuConfigureArgs != null) {
           final String[] a = this.gnuConfigureArgs.split(" ");
           args = new String[a.length + 2];
 
           System.arraycopy(a, 0, args, 2, a.length);
         } else {
           args = new String[2];
         }
 
         // first 2 args are constant
         args[0] = configure.getAbsolutePath();
         args[1] = "--prefix=" + getGnuAOLTargetDirectory().getAbsolutePath();
 
         final File buildDir = getGnuAOLSourceDirectory();
         FileUtils.mkdir(buildDir.getPath());
 
         getLog().info("args: " + arraysToString(args));
         final int result = NarUtil.runCommand("sh", args, buildDir, null, getLog());
         if (result != 0) {
           throw new MojoExecutionException("'" + CONFIGURE + "' errorcode: " + result);
         }
       }
     }
   }
 
   private void runAutogen(final File autogen, final File targetDir, final String args[])
       throws MojoExecutionException, MojoFailureException {
     // fix missing config directory
     final File configDir = new File(targetDir, "config");
     if (!configDir.exists()) {
       configDir.mkdirs();
     }
 
     NarUtil.makeExecutable(autogen, getLog());
     getLog().debug("running sh ./" + autogen.getName());
 
     String arguments[] = null;
     if (args != null) {
       arguments = new String[1 + args.length];
       System.arraycopy(args, 0, arguments, 1, args.length);
     } else {
       arguments = new String[1];
     }
     arguments[0] = "./" + autogen.getName();
 
     getLog().info("args: " + arraysToString(arguments));
 
     final int result = NarUtil.runCommand("sh", arguments, targetDir, null, getLog());
     if (result != 0) {
       throw new MojoExecutionException("'" + autogen.getName() + "' errorcode: " + result);
     }
   }
 
 }