/**
    * Copyright (c) 2012, University of Konstanz, Distributed Systems Group
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * * Redistributions of source code must retain the above copyright
    * notice, this list of conditions and the following disclaimer.
    * * 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.
   * * Neither the name of the University of Konstanz nor the
   * names of its contributors may be used to endorse or promote products
   * derived from this software without specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 <COPYRIGHT HOLDER> 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.
   */
  package org.perfidix;
  
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Hashtable;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Random;
  import java.util.Set;
  
  import org.perfidix.AbstractConfig.StandardConfig;
  import org.perfidix.annotation.AfterBenchClass;
  import org.perfidix.annotation.BeforeBenchClass;
  import org.perfidix.annotation.Bench;
  import org.perfidix.element.AbstractMethodArrangement;
  import org.perfidix.element.BenchmarkElement;
  import org.perfidix.element.BenchmarkExecutor;
  import org.perfidix.element.BenchmarkMethod;
  import org.perfidix.exceptions.PerfidixMethodCheckException;
  import org.perfidix.exceptions.PerfidixMethodInvocationException;
  import org.perfidix.meter.AbstractMeter;
  import org.perfidix.result.BenchmarkResult;
  
  /**
   * Class to hold all classes which want to be benchmarked.
   * <p>
   * 
   * <pre>
   * 
   * 
   * public class MyBenchmark {
   * 
   *     public static void main(final String[] args) {
   *         // Build up own config
   *         final AbstractConfig config = new MyConfig();
   * 
   *         // Initialise benchmark with config
   *         final Benchmark benchmark = new Benchmark(config);
   * 
   *         // Adding Classes to benchmark
   *         benchmark.add(Class1.class);
   *         benchmark.add(Class2.class);
   *         benchmark.add(Object3); // of Class3, every class is allowed to be inserted only once
   * 
   *         // Running benchmark
   *         final BenchmarkResult result = benchmark.run();
   * 
   *         // Printing out Result in a Tabular, every AbstractOutput implementing class is allowed.
   *         new TabularSummaryOutput().visitBenchmark(result);
   * 
   *     }
   * }
   * 
   * </pre>
   * 
   * </p>
   * 
   * @see AbstractConfig
   * @see BenchmarkResult
   * @author Sebastian Graf, University of Konstanz
   */
  public final class Benchmark {
  
      /** Set with all used classes. */
      private transient final Set<Class<?>> clazzes;
  
      /** Already instantiated objects */
      private transient final Set<Object> objects;
  
      /** Simple random for gc-prob */
      private transient static final Random RAN = new Random();
 
     /** Configuration of benchmark, holding everything. */
     private transient final AbstractConfig conf;
 
     /**
      * Constructor with a fixed set of used meters.
      * 
      * @param paramConf
      *            Configuration for Benchmark
      */
     public Benchmark(final AbstractConfig paramConf) {
         conf = paramConf;
         this.clazzes = new LinkedHashSet<Class<?>>();
         this.objects = new LinkedHashSet<Object>();
 
     }
 
     /**
      * Convience constructor using the {@link StandardConfig}
      */
     public Benchmark() {
         this(new StandardConfig());
     }
 
     /**
      * Adding a class to bench to this benchmark. This class should contain
      * benchmarkable methods, otherwise it will be ignored.
      * 
      * @param clazz
      *            to be added.
      */
     public void add(final Class<?> clazz) {
         if (this.clazzes.contains(clazz)) {
             throw new IllegalArgumentException("Only one class-instance per benchmark allowed");
         } else {
             this.clazzes.add(clazz);
         }
     }
 
     /**
      * Adding a already instantiated objects to benchmark. Per benchmark, only
      * one objects of each class is allowed.
      * 
      * @param obj
      *            to be added
      */
     public void add(final Object obj) {
         final Class<?> clazz = obj.getClass();
 
         if (this.clazzes.contains(clazz)) {
             throw new IllegalArgumentException("Only one class-instance per benchmark allowed");
         } else {
             this.clazzes.add(clazz);
             this.objects.add(obj);
         }
     }
 
     /**
      * Getting the number of all methods and all runs
      * 
      * @return a map with all methods and the runs.
      */
     public Map<BenchmarkMethod, Integer> getNumberOfMethodsAndRuns() {
         final Map<BenchmarkMethod, Integer> returnVal = new HashMap<BenchmarkMethod, Integer>();
         final List<BenchmarkMethod> meths = getBenchmarkMethods();
         for (final BenchmarkMethod meth : meths) {
             int numberOfRuns = BenchmarkMethod.getNumberOfAnnotatedRuns(meth.getMethodToBench());
             if (numberOfRuns == Bench.NONE_RUN) {
                 numberOfRuns = conf.getRuns();
             }
             returnVal.put(meth, numberOfRuns);
         }
         return returnVal;
     }
 
     /**
      * Running this benchmark
      * 
      * @return {@link BenchmarkResult} the result in an {@link BenchmarkResult} container.
      */
     public BenchmarkResult run() {
         final BenchmarkResult res = new BenchmarkResult(conf.getListener());
         BenchmarkExecutor.initialize(conf, res);
 
         // getting Benchmarkables
         final List<BenchmarkElement> elements = getBenchmarkElements();
 
         // arranging them
         final AbstractMethodArrangement arrangement =
             AbstractMethodArrangement.getMethodArrangement(elements, conf.getArrangement());
 
         // instantiate methods
         final Map<Class<?>, Object> instantiatedObj = instantiateMethods(res);
 
         // getting the mapping and executing beforemethod
         final Map<Class<?>, Object> objectsToExecute = executeBeforeBenchClass(instantiatedObj, res);
 
         // executing the bench for the arrangement
         for (final BenchmarkElement elem : arrangement) {
             // invoking gc if possible
             if (RAN.nextDouble() < conf.getGcProb()) {
                 System.gc();
             }
 
             final BenchmarkExecutor exec = BenchmarkExecutor.getExecutor(elem);
 
             final Object obj = objectsToExecute.get(elem.getMeth().getMethodToBench().getDeclaringClass());
             // check needed because of failed initialization of objects
             if (obj != null) {
                 exec.executeBeforeMethods(obj);
                 exec.executeBench(obj);
                 exec.executeAfterMethods(obj);
             }
         }
 
         // cleaning up methods to benchmark
         tearDownObjectsToExecute(objectsToExecute, res);
         return res;
     }
 
     /**
      * Setting up executable objects for all registered classes and executing {@link BeforeBenchClass}
      * annotated methods. If an {@link Exception} occurs, this failure will be stored in the
      * {@link BenchmarkResult} and
      * the class will not be instantiated
      * 
      * @param res
      *            {@link BenchmarkResult} for storing possible failures.
      * @return a mapping with class->objects for all registered classes-
      */
     private Map<Class<?>, Object> instantiateMethods(final BenchmarkResult res) {
         // datastructure initialization for all objects
         final Map<Class<?>, Object> objectsToUse = new Hashtable<Class<?>, Object>();
 
         // generating including already instaniated objects
         for (final Object obj : this.objects) {
             final Class<?> clazz = obj.getClass();
             objectsToUse.put(clazz, obj);
         }
 
         // generating objects for each registered class
         for (final Class<?> clazz : clazzes) {
             // generating a new instance on which the benchmark will be
             // performed if there isn't a user generated one
             if (!objectsToUse.containsKey(clazz)) {
                 try {
                     final Object obj = clazz.newInstance();
                     objectsToUse.put(clazz, obj);
                     // otherwise adding an exception to the result
                 } catch (final InstantiationException e) {
                     res.addException(new PerfidixMethodInvocationException(e, BeforeBenchClass.class));
                 } catch (final IllegalAccessException e) {
                     res.addException(new PerfidixMethodInvocationException(e, BeforeBenchClass.class));
                 }
 
             }
         }
 
         return objectsToUse;
     }
 
     /**
      * Executing beforeBenchClass if present.
      * 
      * @param instantiatedObj
      *            with the instantiatedObj;
      * @param res
      *            where the Exceptions should be stored to
      * @return valid instances with valid beforeCall
      */
     private Map<Class<?>, Object> executeBeforeBenchClass(final Map<Class<?>, Object> instantiatedObj,
         final BenchmarkResult res) {
 
         final Map<Class<?>, Object> returnVal = new Hashtable<Class<?>, Object>();
 
         // invoking before bench class
         for (final Class<?> clazz : instantiatedObj.keySet()) {
 
             final Object objectToUse = instantiatedObj.get(clazz);
             // ..the search for the beforeClassMeth begins...
             Method beforeClassMeth = null;
             boolean continueVal = true;
             try {
                 beforeClassMeth =
                     BenchmarkMethod.findAndCheckAnyMethodByAnnotation(clazz, BeforeBenchClass.class);
                 // ... and if this search is throwing an exception, the
                 // exception will be added and a flag is set to break up
             } catch (final PerfidixMethodCheckException e) {
                 res.addException(e);
                 continueVal = false;
             }
             // if everything worked well...
             if (continueVal) {
                 if (beforeClassMeth == null) {
                     // ...either the objects is directly mapped to the class
                     // for executing the benches
                     returnVal.put(clazz, objectToUse);
                 } else {
                     // ... or the beforeMethod will be executed and a
                     // possible exception stored to the result...
                     final PerfidixMethodCheckException beforeByCheck =
                         BenchmarkExecutor.checkMethod(objectToUse, BeforeBenchClass.class, beforeClassMeth);
                     if (beforeByCheck == null) {
                         final PerfidixMethodInvocationException beforeByInvok =
                             BenchmarkExecutor.invokeMethod(objectToUse, BeforeBenchClass.class,
                                 beforeClassMeth);
                         if (beforeByInvok == null) {
                             returnVal.put(clazz, objectToUse);
                         } else {
                             res.addException(beforeByInvok);
                         }
                     } else {
                         res.addException(beforeByCheck);
                     }
                 }
             }
         }
         return returnVal;
     }
 
     /**
      * Tear down executable objects for all registered classes and executing {@link AfterBenchClass} annotated
      * methods.
      * 
      * @param objects
      *            a mapping with class->objects to be teared down
      * @param res
      *            the {@link BenchmarkResult} for storing possible failures.
      */
     private void tearDownObjectsToExecute(final Map<Class<?>, Object> objects, final BenchmarkResult res) {
 
         // executing tearDown for all clazzes registered in given Map
         for (final Class<?> clazz : objects.keySet()) {
             final Object objectToUse = objects.get(clazz);
             if (objectToUse != null) {
                 // executing AfterClass for all objects.
                 Method afterClassMeth = null;
                 try {
                     afterClassMeth =
                         BenchmarkMethod.findAndCheckAnyMethodByAnnotation(clazz, AfterBenchClass.class);
                 } catch (final PerfidixMethodCheckException e) {
                     res.addException(e);
                 }
                 // if afterClassMethod exists, the method will be executed and
                 // possible failures will be stored in the BenchmarkResult
                 if (afterClassMeth != null) {
                     final PerfidixMethodCheckException afterByCheck =
                         BenchmarkExecutor.checkMethod(objectToUse, AfterBenchClass.class, afterClassMeth);
                     if (afterByCheck == null) {
                         final PerfidixMethodInvocationException afterByInvok =
                             BenchmarkExecutor
                                 .invokeMethod(objectToUse, AfterBenchClass.class, afterClassMeth);
                         if (afterByInvok != null) {
                             res.addException(afterByInvok);
                         }
                     } else {
                         res.addException(afterByCheck);
                     }
                 }
             }
         }
     }
 
     /**
      * Getting all Benchmarkable methods out of the registered class.
      * 
      * @return a Set with {@link BenchmarkMethod}
      */
     public List<BenchmarkMethod> getBenchmarkMethods() {
         // Generating Set for returnVal
         final List<BenchmarkMethod> elems = new ArrayList<BenchmarkMethod>();
         // Getting all Methods and testing if its benchmarkable
         for (final Class<?> clazz : clazzes) {
             for (final Method meth : clazz.getDeclaredMethods()) {
                 // Check if benchmarkable, if so, insert to returnVal;
                 if (BenchmarkMethod.isBenchmarkable(meth)) {
                     final BenchmarkMethod benchmarkMeth = new BenchmarkMethod(meth);
                     elems.add(benchmarkMeth);
                 }
             }
         }
         return elems;
     }
 
     /**
      * Getting all benchmarkable objects out of the registered classes with the
      * annotated number of runs.
      * 
      * @return a Set with {@link BenchmarkMethod}
      */
     public List<BenchmarkElement> getBenchmarkElements() {
 
         final List<BenchmarkElement> elems = new ArrayList<BenchmarkElement>();
 
         final List<BenchmarkMethod> meths = getBenchmarkMethods();
 
         for (final BenchmarkMethod meth : meths) {
             int numberOfRuns = BenchmarkMethod.getNumberOfAnnotatedRuns(meth.getMethodToBench());
             if (numberOfRuns == Bench.NONE_RUN) {
                 numberOfRuns = conf.getRuns();
             }
 
             // getting the number of runs and adding this number of
             // elements to the set to be evaluated.
             for (int i = 0; i < numberOfRuns; i++) {
                 elems.add(new BenchmarkElement(meth));
             }
         }
 
         return elems;
     }
 }