/*
    * 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.List;
  import java.util.SortedMap;
  import java.util.TreeMap;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.scalabench.dacapo.callback.MarshallingSupport;
  import org.scalabench.dacapo.callback.summary.Invocation;
  import org.scalabench.dacapo.callback.summary.Iteration;
  import org.scalabench.dacapo.callback.summary.Summary;
  import org.scalabench.plugins.dacapo.util.SizeNameComparator;
  
  /**
   * Perform sanity checks for integration testing.
   * 
   * Note: This goal only verifies the results. 
   * 
   * @since 0.1.0
   * 
   * @threadSafe
   * @goal verify
   * @phase verify
   */
  public class VerifyMojo extends AbstractIntegrationTestMojo {
      
      /**
       * Set this to <code>true</code> to ignore failures during testing. Its use is <em>not recommended</em>, but quite
       * convenient on occasion.
       * 
       * @parameter default-value="false" expression="${maven.test.failure.ignore}"
       */
      private boolean testFailureIgnore;
      
      /**
       * 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;
      
      public boolean isTestFailureIgnore() {
          return testFailureIgnore;
      }
      
      @Override
      public void execute() throws MojoExecutionException, MojoFailureException {
          if (isSkipExecution()) {
              logInfo("Tests are skipped.");
          } else { 
              verifySummaryFile();
          }
      }
      
      private void verifySummaryFile() throws MojoExecutionException, MojoFailureException {
          final Summary summary = loadSummaryFromFile();
          reportBenchmarkInvocations(summary);
      }
      
      private Summary loadSummaryFromFile() throws MojoExecutionException {
          final Summary summary;
          
          logInfo("Verifying DaCapo benchmark summary file: %s", summaryFile);
          
          try {
              summary = MarshallingSupport.loadSummary(summaryFile);
          } catch (IOException e) {
              throw new MojoExecutionException(format("Failed to load summary file: %s", summaryFile), e);
          }
          
          if (!getBenchmarkName().equals(summary.getBenchmark()))
              throw new MojoExecutionException(format("Found summary for wrong benchmark: %s", summary.getBenchmark()));
          
          return summary;
      }
      
     public void reportBenchmarkInvocations(Summary result) throws MojoFailureException {
         final SortedMap<String, List<Invocation>> invocationsPerSize =
             new TreeMap<String, List<Invocation>>(new SizeNameComparator());
         
         for (Invocation invocation : result.getInvocations()) {
             List<Invocation> invocations;
             if ((invocations = invocationsPerSize.get(invocation.getSize())) == null)
                 invocationsPerSize.put(invocation.getSize(), invocations = new ArrayList<Invocation>());
             invocations.add(invocation);
         }
         
         int failedInvocations = 0;
         
         for (String size : invocationsPerSize.keySet()) {
             for (Invocation invocation : invocationsPerSize.get(size)) {
                 final int failedIterations = countFailedIterations(invocation.getIterations());
                 if (failedIterations > 0) {
                     logError("Failed %2$d iterations of \"%1$s\" input size",  size, failedIterations);
                     failedInvocations++;
                 }
             }
             
             if (failedInvocations > 0) {
                 logError("Failed %2$d invocations of \"%1$s\" input size", size, failedInvocations);
             }
         }
         
         if (failedInvocations != 0) {
             if (isTestFailureIgnore())
                 logError("There are test failures.");
             else
                 throw new MojoFailureException("There are test failures.");
         }
     }
     
     public static int countFailedIterations(List<? extends Iteration> iterations) {
         int failedIterations = 0;
         
         for (Iteration iteration : iterations)
             if (!iteration.isValid())
                 failedIterations++;
         
         return failedIterations;
     }
 }