/*
    * Copyright 2010 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software
    * Technology (FIRST), Berlin, Germany. All rights reserved.
    * http://www.first.fraunhofer.de/
    */
   package net.kwfgrid.gwes.workflowanalyzer;
   
   import net.kwfgrid.gwes.Activity;
  import net.kwfgrid.gwes.Constants;
  import net.kwfgrid.gwes.XMLDB;
  import net.kwfgrid.gwes.exception.DatabaseException;
  import net.kwfgrid.gworkflowdl.structure.GenericProperties;
  import net.kwfgrid.gworkflowdl.structure.Transition;
  import net.kwfgrid.gworkflowdl.structure.Workflow;
  import org.apache.log4j.Logger;
  
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Hashtable;
  
  /**
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: WorkflowStatistics.java 1419 2010-11-01 14:12:17Z hoheisel $
   */
  public class WorkflowStatistics {
  
      static Logger logger = Logger.getLogger(WorkflowStatistics.class);
  
      private Workflow workflow;
  
      private int numberOfEdges = -1;
      private double branchingFactor = -1d;
      private long sequentialExecutionPathSize = -1;
      private double speedupTotal = -1d;
      private double speedupActive = -1d;
  
      HashMap<String, TransitionActivityStatistics> transitionStatistics;
  
      public WorkflowStatistics(Workflow workflow) {
          this.workflow = workflow;
          transitionStatistics = new HashMap<String, TransitionActivityStatistics>();
      }
  
      public synchronized void updateActivityStatistics(Activity activity, Transition transition) {
          TransitionActivityStatistics stats = transitionStatistics.get(transition.getID());
          if (stats == null) {
              stats = new TransitionActivityStatistics();
              transitionStatistics.put(transition.getID(), stats);
          }
          stats.put(activity);
          GenericProperties props = transition.getProperties();
          stats.updateTransitionProperties(props);
      }
  
      public synchronized void updateDatabaseActivityStatistics() throws DatabaseException {
  
          // key is operation resource pair, value is the combined distribution set over all transitions
          Map<OperationResourcePair,DistributionSet> orDistMap = new Hashtable<OperationResourcePair,DistributionSet>();
          
          // loop over all Transition statistics
          for (TransitionActivityStatistics transitionStats : transitionStatistics.values()) {
              Map<OperationResourcePair, DistributionSet> transDists = transitionStats.getDistributionMap();
              // loop over all operation resource pairs
              for (OperationResourcePair orp : transDists.keySet()) {
                  // combine distribution maps for equal operation resource pairs
                  DistributionSet distSet = orDistMap.get(orp);
                  if (distSet == null) {
                      distSet = new DistributionSet();
                      orDistMap.put(orp,distSet);
                  }
                  distSet.add(transDists.get(orp));
              }
          }
  
          // update database for each operation resource pair
          for (OperationResourcePair orp : orDistMap.keySet()) {
              DistributionSet dbSet = XMLDB.getInstance().getResourceDurationStatistics(orp.getOperation(),orp.getResource());
              if (dbSet == null) {
                  dbSet = new DistributionSet();
              }
              dbSet.add(orDistMap.get(orp));
              XMLDB.getInstance().updateResourceDurationStatistics(orp.getOperation(), orp.getResource(), dbSet);
          }
          
      }
  
      public double getBranchingFactor() {
          if (branchingFactor < 0) updateBranchingFactor();
          return branchingFactor;
      }
  
      /**
       * ToDo: this is not an "official" branching factor (defined as children for each node).
       * @return
       */
      public double updateBranchingFactor() {
  //        int nodes = workflow.placeCount() + workflow.transitionCount();
 //        if (getNumberOfEdges() <= 0) return -1d;
 //        branchingFactor = (double) getNumberOfEdges() / (double) nodes;
 //        workflow.getProperties().put(GWorkflowDLHandler.PROP_WORKFLOW_BRANCHINGFACTOR, "" + branchingFactor);
         return branchingFactor;
     }
 
     public long getSequentialExecutionPathSize() {
         if (sequentialExecutionPathSize < 0) updateSequentialExecutionPathSize();
         return sequentialExecutionPathSize;
     }
 
     public long updateSequentialExecutionPathSize() {
         sequentialExecutionPathSize = 0;
         if (transitionStatistics != null && transitionStatistics.size() > 0) {
             for (String id : workflow.getTransitionIDs()) {
                 TransitionActivityStatistics stats = transitionStatistics.get(id);
                 if (stats != null) {
                     DistributionSet set = stats.getAggregatedSet(); 
                     sequentialExecutionPathSize += set.durationTotal.getNumber() * set.durationTotal.getMean();
                 }
             }
         }
         workflow.getProperties().put(Constants.PROP_WORKFLOW_SEQUENTIAL_EXECUTION_PATH_SIZE_MS, "" + sequentialExecutionPathSize);
         return sequentialExecutionPathSize;
     }
 
     public double getSpeedupActive() {
         if (speedupActive < 0) updateSpeedupActive();
         return speedupActive;
     }
 
     public double updateSpeedupActive() {
         String makespanS = workflow.getProperties().get(Constants.PROP_DURATION_ACTIVE_MS);
         if (makespanS == null) return -1d;
         try {
             long makespan = Long.parseLong(makespanS);
             speedupActive = (double) getSequentialExecutionPathSize() / (double) makespan;
         } catch (NumberFormatException e) {
             logger.warn("Wrong format of durationActiveMs property: " + makespanS);
             return -1d;
         }
         workflow.getProperties().put(Constants.PROP_WORKFLOW_SPEEDUP_ACTIVE, ""+ speedupActive);
         return speedupActive;
     }
 
     public double getSpeedupTotal() {
         if (speedupTotal < 0) updateSpeedupTotal();
         return speedupTotal;
     }
 
     public double updateSpeedupTotal() {
         String makespanS = workflow.getProperties().get(Constants.PROP_DURATION_TOTAL_MS);
         if (makespanS == null) return -1d;
         try {
             long makespan = Long.parseLong(makespanS);
             speedupTotal = (double) getSequentialExecutionPathSize() / (double) makespan;
         } catch (NumberFormatException e) {
             logger.warn("Wrong format of durationTotalMs property: " + makespanS);
             return -1d;
         }
         workflow.getProperties().put(Constants.PROP_WORKFLOW_SPEEDUP_TOTAL, ""+ speedupTotal);
         return speedupTotal;
     }
 
     public double getNumberOfEdges() {
         if (numberOfEdges == -1) updateNumberOfEdges();
         return numberOfEdges;
     }
 
     public double updateNumberOfEdges() {
         // counte edges
         int edgecounter = 0;
         for (Transition transition : workflow.getTransitions()) {
             edgecounter += transition.getReadEdges().length;
             edgecounter += transition.getInEdges().length;
             edgecounter += transition.getOutEdges().length;
         }
         numberOfEdges = edgecounter;
         return numberOfEdges;
     }
 
 }