/*
    * 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;
   
  import net.kwfgrid.gwes.jaxen.*;
  import net.kwfgrid.gwes.util.StringUtils;
  import net.kwfgrid.gworkflowdl.structure.*;
  import org.apache.log4j.Logger;
  import org.jaxen.*;
  import org.jaxen.jdom.JDOMXPath;
  import org.jdom.Document;
  
  /**
   * This class is used to check conditions expressed in the XPath syntax.
   *
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: ConditionChecker.java 1433 2010-11-29 18:06:07Z hoheisel $
   */
  public class ConditionChecker {
  
      /**
       * log4j logger.
       */
      private final static Logger logger = Logger.getLogger(ConditionChecker.class);
  
      public final static int CONDITION_TRUE = 1;
      public final static int CONDITION_FALSE_STATIC = 2;
      public final static int CONDITION_FALSE_DYNAMIC = 4;
  
      private final SimpleFunctionContext fnContext;
      private final SimpleNamespaceContext defaultNsContext;
  
      private Document context;
  
      /**
       * Constructor for the condition checker.
       *
       * @param workflow   The workflow context of the condition.
       * @param transition The parent transition.
       */
      public ConditionChecker() {
          // register add-on functions
          fnContext = new XPathFunctionContext();
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "current-dateTimeMs", new CurrentDateTimeMsFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "dateTime2ms", new DateTime2msFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2dateTime", new Ms2dateTimeFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2year", new Ms2yearFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2month", new Ms2monthFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2day", new Ms2dayFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2hour", new Ms2hourFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2minute", new Ms2minuteFunction());
          fnContext.registerFunction("http://www.gridworkflow.org/gworkflowdl", "ms2second", new Ms2secondFunction());
          // add default namespaces
          defaultNsContext = new SimpleNamespaceContext();
          defaultNsContext.addNamespace("xsd", "http://www.w3.org/2001/XMLSchema");
          defaultNsContext.addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
          defaultNsContext.addNamespace("gwdl", "http://www.gridworkflow.org/gworkflowdl");
          defaultNsContext.addNamespace("soapenv", "http://www.w3.org/2003/05/soap-envelope");
      }
  
      /**
       * Set the evaluation context for conditions.
       * @param context Context as JDOM Document.
       */
      public void setContext(Document context) {
          this.context = context; 
      }
  
      /**
       * Check a set of conditions.
       * Variables (e.g. <code>$input/</code>) that are expanded by the corresponding
       * context XPath (e.g. <code>/gwdl:data/input</code>).
       *
       * @param to The transition occurrence that contains the conditios to check.
       * @return <code>CONDITION_TRUE</code> if all conditions evaluate to true and <code>CONDITION_FALSE_STATIC</code>
       * if a least one static condition evaluates to false. <code>CONDITION_FALSE_DYNAMIC</code> if condition is false
       * just because of time-depend conditions that may change in future.
       * @throws WorkflowFormatException If the syntax of the condition is wrong.
       */
      public int check(TransitionOccurrence to) throws WorkflowFormatException {
          int ret = CONDITION_TRUE;
  
          // set context
          // e.g., <gwdl:data><i>5</i><j>6</j></gwdl:data>
          setContext(to.getContext());
  
          // expand namespace context
          SimpleNamespaceContext nsContext = defaultNsContext;
          GenericProperties transProps = to.transition.getProperties();
          for (Property prop : transProps.getProperties()) {
              String key = prop.getKey();
              if (key.startsWith("xmlns:") && key.length() > 6) {
  //                logger.info("==> adding namespace: "+key.substring(6)+":"+prop.getValue());
                 nsContext.addNamespace(key.substring(6),prop.getValue());
             }
         }
 
         // loop through all conditions.
         for (String condition1 : to.transition.getConditions()) {
             String condition = StringUtils.expandContextVariables(condition1.trim());
 
             // if one of the conditions is always false, then return CONDITION_FALSE_STATIC.
             try {
                 if (!check(condition,nsContext)) {
                     if ((ret & CONDITION_TRUE) != 0) ret -= CONDITION_TRUE;
                     if (condition.contains("current-dateTimeMs(")) {
                         ret |= CONDITION_FALSE_DYNAMIC;
                     } else {
                         ret |= CONDITION_FALSE_STATIC;
                         return ret;
                     }
                 }
             } catch (JaxenException e) {
                 logger.error("exception: "+e, e);
                 throw new WorkflowFormatException("There is an error with condition '" + condition + "':"+ e, e);
             }
         }
 
         return ret;
     }
 
     public boolean check(String xpathExpression, NamespaceContext nsContext) throws JaxenException {
         boolean ret;
         // quick check if string is "true" or "false"
         if (xpathExpression.equalsIgnoreCase(Constants.TRUE)) ret = true;
         else if (xpathExpression.equalsIgnoreCase(Constants.FALSE)) ret = false;
         else {
             // real xpath evaluation
             XPath xpath = new JDOMXPath(xpathExpression);
             xpath.setFunctionContext(fnContext);
             xpath.setNamespaceContext(nsContext);
 //            logger.info("Condition  '" + xpathExpression + "' string value: "+ xpath.stringValueOf(xpathExpression));
             ret = xpath.booleanValueOf(context);
         }
 
         if (logger.isDebugEnabled()) {
             logger.debug("Condition '" + xpathExpression + "' is " + ret);
         }
         return ret;
     }
 
 }