/**
    * 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.element;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  import java.util.Hashtable;
  import java.util.LinkedHashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.perfidix.AbstractConfig;
  import org.perfidix.annotation.AfterEachRun;
  import org.perfidix.annotation.AfterLastRun;
  import org.perfidix.annotation.BeforeEachRun;
  import org.perfidix.annotation.BeforeFirstRun;
  import org.perfidix.annotation.Bench;
  import org.perfidix.exceptions.PerfidixMethodCheckException;
  import org.perfidix.exceptions.PerfidixMethodInvocationException;
  import org.perfidix.meter.AbstractMeter;
  import org.perfidix.result.BenchmarkResult;
  
  /**
   * Corresponding to each method, an executor is launched to execute {@link BeforeFirstRun},
   * {@link BeforeEachRun}, {@link AfterEachRun} and {@link AfterLastRun} classes. To store the data if the
   * single-execute before
   * classes have been executed, this class is implemented as a singleton to store
   * this information related to the method. All the data comes from the {@link BenchmarkMethod} class.
   * 
   * @author Sebastian Graf, University of Konstanz
   */
  public final class BenchmarkExecutor {
  
      /**
       * Static mapping for all methods to be executed because of the single-runs
       * before/after methods.
       */
      private static final Map<BenchmarkMethod, BenchmarkExecutor> EXECUTOR =
          new Hashtable<BenchmarkMethod, BenchmarkExecutor>();
  
      /** Static Mapping of runs to occur for each BenchmarkMethod.} */
      private static final Map<BenchmarkMethod, Integer> RUNS = new Hashtable<BenchmarkMethod, Integer>();
  
      /** Set with all meters to be benched automatically. */
      private static final Set<AbstractMeter> METERS_TO_BENCH = new LinkedHashSet<AbstractMeter>();
  
      /** Result for all Benchmarks. */
      private static BenchmarkResult BENCHRES;
  
      /** Config for all Benchmarks. */
      private static AbstractConfig CONFIG;
  
      /** Boolean to be sure that the beforeFirstRun was not executed yet. */
      private transient boolean beforeFirstRun;
  
      /**
       * Corresponding BenchmarkElement of this executor to get the before/after
       * methods.
       */
      private transient final BenchmarkMethod element;
  
      /**
       * Private constructor, just setting the booleans and one element to get the
       * before/after methods.
       * 
       * @param paramElement
       *            BenchmarkElement to provide easy access to the before/after
       *            methods.
       */
      private BenchmarkExecutor(final BenchmarkMethod paramElement) {
          beforeFirstRun = false;
          element = paramElement;
      }
 
     /**
      * Getting the executor corresponding to a BenchmarkElement.
      * 
      * @param meth
      *            for the executor. If the underlaying {@link Method} was not
      *            registered, a new mapping-entry will be created.
      * @return the BenchmarkExecutor corresponding to the Method of the
      *         BenchmarkElement
      */
     public static BenchmarkExecutor getExecutor(final BenchmarkElement meth) {
         if (BENCHRES == null) {
             throw new IllegalStateException("Call initialize method first!");
         }
 
         // check if new instance needs to be created
         if (!EXECUTOR.containsKey(meth.getMeth())) {
             EXECUTOR.put(meth.getMeth(), new BenchmarkExecutor(meth.getMeth()));
             int runsOnAnno = BenchmarkMethod.getNumberOfAnnotatedRuns(meth.getMeth().getMethodToBench());
             if (runsOnAnno < 0) {
                 runsOnAnno = CONFIG.getRuns();
             }
             RUNS.put(meth.getMeth(), runsOnAnno);
         }
 
         // returning the executor
         return EXECUTOR.get(meth.getMeth());
 
     }
 
     /**
      * Initializing the executor.
      * 
      * @param config
      *            to be benched
      * @param result
      *            to be stored to
      */
     public static void initialize(final AbstractConfig config, final BenchmarkResult result) {
         METERS_TO_BENCH.clear();
         METERS_TO_BENCH.addAll(Arrays.asList(config.getMeters()));
         EXECUTOR.clear();
         BENCHRES = result;
         CONFIG = config;
 
     }
 
     /**
      * Executing the {@link BeforeFirstRun}-annotated methods (if still wasn't)
      * and the {@link BeforeEachRun} methods.
      * 
      * @param obj
      *            the object of the class where the bench runs currently in.
      */
     public void executeBeforeMethods(final Object obj) {
 
         // invoking once the beforeFirstRun-method
         if (!beforeFirstRun) {
             beforeFirstRun = true;
 
             Method[] beforeFirst = null;
             try {
                 beforeFirst = element.findBeforeFirstRun();
             } catch (final PerfidixMethodCheckException e) {
                 BENCHRES.addException(e);
             }
             if (beforeFirst.length != 0) {
                 checkAndExectuteBeforeAfters(obj, BeforeFirstRun.class, beforeFirst);
             }
         }
 
         // invoking the beforeEachRun-method
         Method[] beforeEach = null;
         try {
             beforeEach = element.findBeforeEachRun();
         } catch (final PerfidixMethodCheckException e) {
             BENCHRES.addException(e);
         }
         if (beforeEach.length != 0) {
             checkAndExectuteBeforeAfters(obj, BeforeEachRun.class, beforeEach);
         }
 
     }
 
     /**
      * Execution of bench method. All data is stored corresponding to the
      * meters.
      * 
      * @param objToExecute
      *            the instance of the benchclass where the method should be
      *            executed with.
      */
     public void executeBench(final Object objToExecute) {
 
         final double[] meterResults = new double[METERS_TO_BENCH.size()];
 
         final Method meth = element.getMethodToBench();
 
         int meterIndex1 = 0;
         int meterIndex2 = 0;
         for (final AbstractMeter meter : METERS_TO_BENCH) {
             meterResults[meterIndex1] = meter.getValue();
             meterIndex1++;
         }
 
         final PerfidixMethodInvocationException res = invokeMethod(objToExecute, Bench.class, meth);
 
         for (final AbstractMeter meter : METERS_TO_BENCH) {
             meterResults[meterIndex2] = meter.getValue() - meterResults[meterIndex2];
             meterIndex2++;
         }
 
         if (res == null) {
             meterIndex1 = 0;
             for (final AbstractMeter meter : METERS_TO_BENCH) {
                 BENCHRES.addData(element.getMethodToBench(), meter, meterResults[meterIndex1]);
                 meterIndex1++;
             }
         } else {
             BENCHRES.addException(res);
         }
 
     }
 
     /**
      * Executing the {@link AfterLastRun}-annotated methods (if still wasn't)
      * and the {@link AfterEachRun} methods.
      * 
      * @param obj
      *            the object of the class where the bench runs currently in.
      */
     public void executeAfterMethods(final Object obj) {
         int runs = RUNS.get(element);
         runs--;
         RUNS.put(element, runs);
 
         // invoking once the beforeFirstRun-method
         if (RUNS.get(element) == 0) {
             Method[] afterLast = null;
             try {
                 afterLast = element.findAfterLastRun();
             } catch (final PerfidixMethodCheckException e) {
                 BENCHRES.addException(e);
             }
             if (afterLast.length != 0) {
                 checkAndExectuteBeforeAfters(obj, AfterLastRun.class, afterLast);
             }
 
         }
 
         // invoking the beforeEachRun-method
         Method[] afterEach = null;
         try {
             afterEach = element.findAfterEachRun();
         } catch (final PerfidixMethodCheckException e) {
             BENCHRES.addException(e);
         }
         if (afterEach != null) {
             checkAndExectuteBeforeAfters(obj, AfterEachRun.class, afterEach);
         }
 
     }
 
     /**
      * Checking and executing several before/after methods.
      * 
      * @param obj
      *            on which the execution should take place
      * @param meth
      *            to be executed
      * @param anno
      *            the related annotation
      */
     private void checkAndExectuteBeforeAfters(final Object obj, final Class<? extends Annotation> anno,
         Method... meths) {
         final PerfidixMethodCheckException checkExc = checkMethod(obj, anno, meths);
         if (checkExc == null) {
             final PerfidixMethodInvocationException invoExc = invokeMethod(obj, anno, meths);
             if (invoExc != null) {
                 BENCHRES.addException(invoExc);
             }
 
         } else {
             BENCHRES.addException(checkExc);
         }
     }
 
     /**
      * Method to invoke a reflective invokable method.
      * 
      * @param obj
      *            on which the execution takes place
      * @param meth
      *            to be executed
      * @param relatedAnno
      *            related annotation for the execution
      * @return {@link PerfidixMethodInvocationException} if invocation fails,
      *         null otherwise.
      */
     public static PerfidixMethodInvocationException invokeMethod(final Object obj,
         final Class<? extends Annotation> relatedAnno, Method... meths) {
         final Object[] args = {};
         for (Method meth : meths) {
             try {
                 meth.invoke(obj, args);
             } catch (final IllegalArgumentException e) {
                 return new PerfidixMethodInvocationException(e, meth, relatedAnno);
             } catch (final IllegalAccessException e) {
                 return new PerfidixMethodInvocationException(e, meth, relatedAnno);
             } catch (final InvocationTargetException e) {
                 return new PerfidixMethodInvocationException(e.getCause(), meth, relatedAnno);
             }
         }
         return null;
     }
 
     /**
      * Checking a method if it is reflective executable and if the mapping to
      * the object fits.
      * 
      * @param obj
      *            on which the execution takes place
      * @param meths
      *            to be checked
      * @param anno
      *            the related annotation for the check
      * @return {@link PerfidixMethodCheckException} if something is wrong in the
      *         mapping, null otherwise.
      */
     public static PerfidixMethodCheckException checkMethod(final Object obj,
         final Class<? extends Annotation> anno, Method... meths) {
 
         for (Method meth : meths) {
             // check if the class of the object to be executed has the given method
             boolean classMethodCorr = false;
             for (final Method methodOfClass : obj.getClass().getDeclaredMethods()) {
                 if (methodOfClass.equals(meth)) {
                     classMethodCorr = true;
                 }
             }
 
             if (!classMethodCorr) {
                 return new PerfidixMethodCheckException(new IllegalStateException(new StringBuilder(
                     "Object to execute ").append(obj).append(" is not having a Method named ").append(meth)
                     .append(".").toString()), meth, anno);
             }
 
             // check if the method is reflected executable
             if (!BenchmarkMethod.isReflectedExecutable(meth, anno)) {
                 return new PerfidixMethodCheckException(new IllegalAccessException(new StringBuilder(
                     "Method to execute ").append(meth).append(" is not reflected executable.").toString()),
                     meth, anno);
             }
         }
         return null;
     }
 
 }