/*
    * DaCapo Benchmark Maven Plugin
    * Copyright (C) 2010 Technische Universität Darmstadt
    * info@scalabench.org
    *
    * 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.
   */
  package org.scalabench.plugins.dacapo;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.toolchain.Toolchain;
  import org.apache.maven.toolchain.ToolchainManager;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  import org.dacapo.parser.Config;
  import org.scalabench.dacapo.callback.XmlSummaryCallback;
  import org.scalabench.plugins.dacapo.util.SizeNameComparator;
  import org.sonatype.aether.RepositorySystem;
  import org.sonatype.aether.RepositorySystemSession;
  import org.sonatype.aether.collection.CollectRequest;
  import org.sonatype.aether.graph.Dependency;
  import org.sonatype.aether.repository.RemoteRepository;
  import org.sonatype.aether.resolution.ArtifactRequest;
  import org.sonatype.aether.resolution.ArtifactResolutionException;
  import org.sonatype.aether.resolution.ArtifactResult;
  import org.sonatype.aether.resolution.DependencyRequest;
  import org.sonatype.aether.resolution.DependencyResolutionException;
  import org.sonatype.aether.resolution.DependencyResult;
  import org.sonatype.aether.util.artifact.DefaultArtifact;
  
  /**
   * Perform sanity checks for integration testing.
   * 
   * Note: This goal only runs the benchmarks (possibly for multiple invocations/iterations).
   * 
   * @since 0.1.0
   * 
   * @threadSafe
   * @goal integration-test
   * @phase integration-test
   * @requiresDependencyResolution runtime
   */
  public class IntegrationTestMojo extends AbstractIntegrationTestMojo {
      
      /**
       * The directory where the generated configuration file will be put.
       * 
       * @required
       * @readonly
       * @parameter expression="${project.build.outputDirectory}/cnf"
       */
      private File configurationDirectory;
      
      /**
       * The number of invocations to perform for each benchmark size.
       * 
       * @parameter default-value=1
       */
      private int testInvocations;
      
      /**
       * The number of iterations to perform for each invocation.
       * 
       * @parameter default-value=1
       */
      private int testIterations;
      
      /**
       * The summary file to write integration test results to.
       * 
       * @parameter default-value="${project.build.directory}/dacapo-benchmark-reports/dacapo-benchmark-summary.xml"
       */
      private File summaryFile;
      
      /**
       * The entry point to Aether.
      * 
      * @component
      */
     private RepositorySystem repoSystem;
     
     /**
      * The current repository/network configuration of Maven.
      * 
      * @readonly
      * @parameter default-value="${repositorySystemSession}"
      */
     private RepositorySystemSession repoSession;
     
     /**
      * The project's remote repositories to use for the resolution of plugins
      * and their dependencies.
      * 
      * @readonly
      * @parameter default-value="${project.remotePluginRepositories}"
      */
     private List<RemoteRepository> remoteRepos;
     
     /**
      * The entry point to Maven's toolchain support.
      * 
      * @component
      */
     private ToolchainManager toolchainManager;
     
     /**
      * The current build session instance. This is used for toolchain manager
      * API calls.
      *
      * @required
      * @readonly
      * @parameter expression="${session}"
      */
     private MavenSession session;
     
     private static final DefaultArtifact CALLBACK_ARTIFACT =
         new DefaultArtifact("org.scalabench.dacapo", "dacapo-benchmark-callback", "jar", "0.1.0-SNAPSHOT");
     
     public File getConfigurationFile() {
         return new File(getConfigurationDirectory(), getBenchmarkName() + ".cnf");
     }
     
     public File getConfigurationDirectory() {
         return configurationDirectory;
     }
     
     public int getTestInvocations() {
         return testInvocations;
     }
     
     public int getTestIterations() {
         return testIterations;
     }
     
     public File getSummaryFile() {
         return summaryFile;
     }
     
     @Override
     public void execute() throws MojoExecutionException, MojoFailureException {
         if (isSkipExecution()) {
             logInfo("Tests are skipped.");
         } else {
             integrationTestBenchmark();
         }
     }
     
     private void integrationTestBenchmark() throws MojoExecutionException, MojoFailureException {
         final String javaExecutable = getJavaExecutable();
         final Config config = Config.parse(getConfigurationFile());
         final List<String> sizes = new LinkedList<String>(config.getSizes());
         
         Collections.sort(sizes, new SizeNameComparator());
         
         for (final String size : sizes) {
             for (int invocation = 1; invocation <= getTestInvocations(); invocation++) {
                 logInfo("Running %4$d iterations with input size \"%1$s\" (invocation %2$d of %3$d)",
                         size, invocation, getTestInvocations(), getTestIterations());
                 performInvocation(javaExecutable, size);
             }
         }
     }
     
     private String getJavaExecutable() throws MojoExecutionException {
         String javaExecutable;
         
         if ((javaExecutable = getJavaPathFromBuildContext()) != null) {
             logInfo("Selected toolchain (JDK) from build context: %s", javaExecutable);
             return javaExecutable;
         } else if ((javaExecutable = getDefaultJavaPath()) != null) {
             logInfo("Selected default toolchain (JDK): %s", javaExecutable);
             return javaExecutable;
         } else {
             throw new MojoExecutionException("Unable to locate toolchain (JDK)");
         }
     }
     
     private String getJavaPathFromBuildContext() {
         final Toolchain toolchain = toolchainManager.getToolchainFromBuildContext("jdk", session);
         return toolchain == null ? null : toolchain.findTool("java");
     }
     
     private String getDefaultJavaPath() {
         final String javaHome = System.getProperty("java.home");
         return javaHome == null ? null : javaHome + File.separator + "bin" + File.separator + "java";
     }
     
     private void performInvocation(String javaExecutable, String size) throws MojoExecutionException, MojoFailureException {
         final File workingDirectory = createWorkingDirectory(size);
         logDebug("Created working directory: %s", workingDirectory);
         
         try {
             final Commandline cl = createCommandLine(javaExecutable, workingDirectory, size);
             logDebug("Forking command line: %s ",  cl);
             CommandLineUtils.executeCommandLine(cl, null, null, 0);
         } catch (CommandLineException e) {
             throw new MojoFailureException("Forked process failed", e);
         } finally {
             deleteWorkingDirectory(workingDirectory);
         }
     }
     
     private File createWorkingDirectory(String size) throws MojoFailureException {
         final File workingDirectory = FileUtils.createTempFile(getBenchmarkName(), size, null);
         
         if (!workingDirectory.mkdir())
             throw new MojoFailureException("Cannot create working directory: " + workingDirectory);
         
         return workingDirectory;
     }
     
     private void deleteWorkingDirectory(File workingDirectory) throws MojoFailureException {
         try {
             FileUtils.deleteDirectory(workingDirectory);
         } catch (IOException e) {
             throw new MojoFailureException("Cannot delete working directory", e);
         }
     }
     
     private Commandline createCommandLine(String javaExecutable, File workingDirectory, String size)
             throws MojoFailureException {
         final Commandline commandLine = new Commandline();
         
         commandLine.setExecutable(javaExecutable);
         commandLine.setWorkingDirectory(workingDirectory);
         commandLine.addArguments(new String[] {
                 "-D" + XmlSummaryCallback.SUMMARY_FILE_PROPERTY + "=" + getSummaryFile(),
                 "-classpath", StringUtils.join(getRuntimeClasspath().iterator(), File.pathSeparator),
                 "Harness",
                 getBenchmarkName(),
                 "--size", size,
                 "--iterations", Integer.toString(getTestIterations()),
                 "--callback", XmlSummaryCallback.class.getName()
         });
         
         return commandLine;
     }
     
     private ArrayList<File> getRuntimeClasspath() throws MojoFailureException {
         final ArrayList<File> classpath = new ArrayList<File>();
         
         classpath.addAll(getProjectClasspath());
         classpath.addAll(getCallbackClasspath());
         
         return classpath;
     }
     
     private List<File> getProjectClasspath() {
         final List<File> projectClasspath = new ArrayList<File>();
         
         projectClasspath.add(getProject().getArtifact().getFile());
         
         for (final Artifact artifact : getProject().getArtifacts())
             projectClasspath.add(artifact.getFile());
         
         return projectClasspath;
     }
     
     private List<File> getCallbackClasspath() throws MojoFailureException {
         try {
             final List<File> callbackClasspath = new ArrayList<File>();
             
             callbackClasspath.add(getCallbackArtifactFile());
             callbackClasspath.addAll(getCallbackDependencyFiles());
             
             return callbackClasspath;
         } catch (DependencyResolutionException e) {
             throw new MojoFailureException("Cannot construct classpath for benchmark callback", e);
         } catch (ArtifactResolutionException e) {
             throw new MojoFailureException("Cannot construct classpath for benchmark callback", e);
         }
     }
     
     private File getCallbackArtifactFile() throws ArtifactResolutionException {
         final ArtifactRequest request = new ArtifactRequest(CALLBACK_ARTIFACT, remoteRepos, null);
         final ArtifactResult result = repoSystem.resolveArtifact(repoSession, request);
         return result.getArtifact().getFile();
     }
     
     private List<File> getCallbackDependencyFiles() throws DependencyResolutionException {
         final Dependency callbackDependency = new Dependency(CALLBACK_ARTIFACT, Artifact.SCOPE_RUNTIME);
         final DependencyRequest request = new DependencyRequest(new CollectRequest(callbackDependency, remoteRepos), null);
         final DependencyResult results = repoSystem.resolveDependencies(repoSession, request);
         final List<File> dependencyFiles = new ArrayList<File>();
         
         for (final ArtifactResult artifactResult : results.getArtifactResults())
             dependencyFiles.add(artifactResult.getArtifact().getFile());
         
         return dependencyFiles;
     }
 }