/*
    * $Id: SimpleProrater.java 1540 2011-08-17 13:30:37Z hoheisel $
    *
    * Copyright (c) 2005, The K-Wf Grid Consortium
    * Fraunhofer Institute for Computer Architecture and Software Technology
    * See http://www.kwfgrid.eu and http://www.first.fraunhofer.de for more details.
    */
   
   package net.kwfgrid.gwes.prorater;
  
  import net.kwfgrid.gworkflowdl.structure.Transition;
  import net.kwfgrid.gworkflowdl.structure.OperationClass;
  import net.kwfgrid.gworkflowdl.structure.OperationCandidate;
  import net.kwfgrid.gwes.exception.DatabaseException;
  import net.kwfgrid.gwes.Constants;
  
  import java.io.IOException;
  import java.util.*;
  
  /**
   * Simple implementation of a Prorater
   *
   * @author Helge Rose' and Andreas Hoheisel
   * @version $Id: SimpleProrater.java 1540 2011-08-17 13:30:37Z hoheisel $
   */
  public class SimpleProrater extends AbstractProrater {
  
      /**
       * key is hardware identifier, value is Node object.
       */
      HashMap<String, Node> nodes;
  
      /**
       * key is hardware identifier, value is time of last assignment of this hardware
       */
      HashMap<String, Long> lastAssignments;
  
      void init(ArrayList<Transition> transitions) throws IOException {
          logger.debug("Init:");
          long now = System.currentTimeMillis();
          if (nodes == null) nodes = new HashMap<String, Node>();
          if (lastAssignments == null) lastAssignments = new HashMap<String, Long>();
          nodes.clear();
          int priority = 0;
          for (Transition transition : transitions) {
              Object oo = transition.getOperation().get();
              if (oo instanceof OperationClass) {
  
                  OperationCandidate[] operationCandidates = ((OperationClass) oo).getOperationCandidates();
                  for (OperationCandidate operationCandidate : operationCandidates) {
                      String resourceName = operationCandidate.getResourceName();
                      // skip hardware that has been recently assigned (wait for load update)
                      Long last = lastAssignments.get(resourceName);
                      if (last != null && now - last < WAIT_AFTER_LAST_ASSIGNMENT) continue;
                      // <property name="priority">1</property>
                      String propStr = transition.getProperties().get(Constants.PROP_TRANSITION_PRIORITY);
                      if (propStr != null) {
                          try {
                              priority = Integer.parseInt(propStr);
                          } catch (NumberFormatException e) {
                              // do nothing.
                          }
                      }
                      Alternative alternative = new Alternative(transition, operationCandidate, priority);
                      Node node = nodes.get(resourceName);
  
                      if (node == null) {
                          node = new Node(resourceName);
                          node.updateQuality(operationCandidate.getQuality());
                          nodes.put(resourceName, node);
                      }
  
                      // Only nodes with a high quality get into the game
                      if (node.quality > MIN_QUALITY) {
                          node.add(alternative);
                      }
                      // for the others set the quality
                      else {
                          alternative.operationCandidate.setQuality(node.quality);
                      }
  
                  }
                  ++priority;
              }
          }
  
          if (logger.isDebugEnabled()) {
              logger.debug("--------- last resource assignments ---------");
              for (String hw : lastAssignments.keySet()) {
                  logger.debug(hw + ": " + lastAssignments.get(hw));
              }
          }
      }
  
      /**
       * @return True if there has been a decision, false if not.
       */
      boolean decide() {
          boolean ret = false;
         if (nodes.size() == 0) return ret;
         logger.debug("Decide:");
         ArrayList<Transition> tdone = new ArrayList<Transition>();
         ArrayList<Node> nc = new ArrayList<Node>();
         nc.addAll(nodes.values());
         Collections.shuffle(nc, new Random(System.currentTimeMillis()));
         for (Node node : nc) {
             int nr = node.alternatives.size();	// number of alternative operationCandidates involving this host
             if (nr == 0) continue;
             if (logger.isDebugEnabled()) {
                 logger.debug("Node: " + node.hostname);
             }
             Collections.sort(node.alternatives);
             Collections.reverse(node.alternatives);	// transitions with high priority first
             for (int i = 0; i < nr; ++i) {
                 Alternative a = node.alternatives.get(i);
                 if (!tdone.contains(a.transition)) {
                     // find equal priorities
                     int tries, j = i;
                     while (j + 1 < nr && a.priority == node.alternatives.get(j + 1).priority) ++j;
                     // choose random transition in case of equal priorities
                     if (j > i) {
                         //System.out.println("node: "+node.hostname+" equal priorities: "+i+"-"+j);
                         tries = j - i;
                         while (tries-- > 0) {
                             Alternative b = node.alternatives.get(i + (int) ((j - i) * Math.random() + 0.5));
                             if (!tdone.contains(b.transition)) {
                                 a = b;
                                 break;
                             }
                         }
                         i = j;
                     }
                     a.operationCandidate.setSelected(true);
                     ret = true;
                     tdone.add(a.transition);
                     lastAssignments.put(node.hostname, System.currentTimeMillis());
                     logger.info("  " + a.priority + ": " + a.operationCandidate.getResourceName() + ": " + a.transition.getID());
                     break;
                 }
             }
         }
         return ret;
     }
 }