/*
    * 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 static java.lang.String.format;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.model.Resource;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.codehaus.plexus.util.StringUtils;
  import org.scalabench.plugins.dacapo.config.BenchmarkConfiguration;
  import org.scalabench.plugins.dacapo.config.Size;
  import org.scalabench.plugins.dacapo.util.SizeNameComparator;
  
  /**
   * Generate the benchmark's configuration file (<code>.cnf</code>).
   * 
   * While most configuration options need to be configured explicitly, the benchmark's dependency declarations are derived
   * from the POM; all provided-scoped dependencies are assumed to be dependencies of the benchmark itself (as opposed to
   * dependencies of the harness).
   * 
   * @since 0.1.0
   * 
   * @threadSafe
   * @goal configuration
   * @phase generate-resources
   * @requiresDependencyResolution compile
   */
  public class ConfigurationMojo extends AbstractDacapoBenchmarkMojo {
      
      /**
       * The benchmark's configuration. If not present, a hand-crafted configuration file is assumed to be present.
       * 
       * @parameter
       */
      private BenchmarkConfiguration benchmark;
      
      /**
       * The directory where the resources generated by this plugin will be put.
       * 
       * @required
       * @readonly
       * @parameter expression="${project.build.directory}/generated-resources/dacapo-benchmark"
       */
      private File resourceOutputDirectory;
      
      @Override
      public void execute() throws MojoExecutionException, MojoFailureException {
          if (benchmark == null) {
              logInfo("No benchmark configuration found. Assuming hand-crafted configuration file is present.");
          } else {
              checkBenchmarkConfiguration();
              generateConfiguratonFile();
          }
      }
      
      private void checkBenchmarkConfiguration() {
          checkBenchmarkSizes();
          checkBenchmarkDescription();
      }
      
      private void checkBenchmarkSizes() {
          if (benchmark.getSizes().isEmpty()) {
              logWarn("No input sizes configured for benchmark");
          } else {
              logInfo("Input sizes configured for benchmark: %s" , StringUtils.join(getSizeNames().iterator(), ", "));
          }
      }
      
      private void checkBenchmarkDescription() {
          if (benchmark.getDescription() == null)
              logWarn("No benchmark description configured");
      }
      
      /**
       * Returns the names of the benchmark's input sizes, sorted according to common convention from smallest to largest.
      * 
      * @return the sorted list of input size names
      * 
      * @see org.scalabench.plugins.dacapo.util.SizeNameComparator
      */
     public List<String> getSizeNames() {
         final List<Size> sizes = benchmark.getSizes();
         final List<String> sizeNames = new ArrayList<String>(sizes.size());
         for (Size size : sizes)
             sizeNames.add(size.getName());
         Collections.sort(sizeNames, new SizeNameComparator());
         return sizeNames;
     }
     
     private void generateConfiguratonFile() throws MojoExecutionException {
         final File configurationDirectory = new File(resourceOutputDirectory, "cnf");
         final File configurationFile = new File(configurationDirectory, getBenchmarkName() + ".cnf");
         
         try {
             if (!configurationDirectory.exists() && !configurationDirectory.mkdirs())
                 throw new IOException(format("Cannot create configuration directory: %s", configurationDirectory));
             
             final ConfigrationWriter writer = new ConfigrationWriter(
                     getBenchmarkName(),
                     benchmark,
                     getLibraryJars());
             writer.writeConfiguration(configurationFile);
             
             final Resource resource = new Resource();
             resource.setDirectory(resourceOutputDirectory.getAbsolutePath());
             getProject().addResource(resource);
         } catch (IOException e) {
             throw new MojoExecutionException("Cannot generate configuration file", e);
         }
     }
     
     private List<String> getLibraryJars() throws MojoExecutionException {
         final Set<Artifact> libraries = getLibraries();
         final List<String> libraryJars = new ArrayList<String>(libraries.size());
         for (final Artifact library : libraries)
             libraryJars.add(library.getFile().getName());
         return libraryJars;
     }
 }