/*
    * 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.gworkflowdl.structure.*;
  import net.kwfgrid.gwes.workflowanalyzer.DoubleDistribution;
  import net.kwfgrid.gwes.util.StringUtils;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.log4j.Logger;
  import org.jdom.Element;
  import org.jdom.Namespace;
  import org.jdom.IllegalNameException;
  import org.jdom.Document;
  import org.jaxen.SimpleNamespaceContext;
  
  /**
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: TransitionOccurrence.java 1490 2011-02-18 13:20:36Z hoheisel $
   */
  public class TransitionOccurrence {
  
      /**
       * log4j logger.
       */
      private final static Logger logger = Logger.getLogger(TransitionOccurrence.class);
      
      public final Transition transition;
  
      private Activity activity;
  
      public TokenParameterList tokens;
  
      /**
       * Properties gathered from all incoming tokens to be copied to outgoing tokens.
       */
      private final GenericProperties props;
  
      /**
       * XML context that contains the elements of all incoming tokens, renamed by its edge expression.
       */
      private final Document context;
  
      /**
       * Namespace context
       */
      private final SimpleNamespaceContext nsContext;
  
      public boolean hasXPathEdgeExpressions;
      public final boolean simulation;
  
      /**
       * The ID of the transition is created using the ids of the incoming tokens.
       */
      private final String ID;
  
      /**
       * ID containing also outgoing tokens. use updateID() to update this ID.
       */
      private String IDwithOutputs;
  
      private DoubleDistribution probabilityDistribution;
  
  
      /**
       * Constructor that uses next unlocked tokens on input/read/write places to build transition occurrence.
       * @param transition
       */
      public TransitionOccurrence(Transition transition) throws WorkflowFormatException {
          this.transition = transition;
          this.activity = null;
          this.tokens = new TokenParameterList();
          hasXPathEdgeExpressions = false;
          simulation = false;
          props = Factory.newProperties();
          context = new Document(new Element("data",JdomString.wfSpace));
          nsContext = new DefaultNamespaceContext();
  
          // data group
          // check transition property "ignore.data.groups"
          int ignoreDataGroups = TokenUtils.getIgnoreDataGroupsCode(transition);
          // check transition property "combine.data.groups" (e.g., "a x b")
          String dataGroup = null;
          ArrayList<String> dataGroups = null;
          String[] combineDataGroupsEdgeExpressions = TokenUtils.getCombineDataGroupsEdgeExpressions(transition);
  
          if (combineDataGroupsEdgeExpressions != null) dataGroups = new ArrayList<String>();
  
          // update namespace context
          updateNamespaceContextFromTransitionProperties();
  
         // identifier
         StringBuffer idBuffer = new StringBuffer(transition.getID());
 
         Edge[] edges;
         // read tokens
         edges = transition.getReadEdges();
         for (Edge edge : edges) {
             Token token = TokenUtils.getNextUnlockedToken(edge,true,dataGroup,ignoreDataGroups);
             if (token == null) {
                 throw new WorkflowFormatException("No suitable token available on readPlace \"" + edge.getPlaceID() + "\" for data.group \"" + dataGroup + "\".");
             } else {
                 // put data tokens with edge expression to context
                 addToContext(token, edge);
                 // copy properties
                 updatePropertiesFromToken(token);
                 // create TokenParameter and add it to list
                 TokenParameter tp = new TokenParameter(edge, token, TokenParameter.Scope.READ);
                 tokens.add(tp);
                 // set data Group
                 dataGroup = TokenUtils.updateDataGroup(tp, ignoreDataGroups, combineDataGroupsEdgeExpressions, dataGroups);
                 // update identifier
                 idBuffer.append(",r:").append(token.getID());
             }
         }
 
         // input tokens
         edges = transition.getInEdges();
         for (Edge edge : edges) {
             Token token = TokenUtils.getNextUnlockedToken(edge,false,dataGroup,ignoreDataGroups);
             if (token == null) {
                 throw new WorkflowFormatException("No suitable token available on inputPlace \"" + edge.getPlaceID() + "\" for data.group \"" + dataGroup + "\".");
             } else {
                 // put data tokens with edge expression to context
                 addToContext(token, edge);
                 // copy properties
                 updatePropertiesFromToken(token);
                 // create TokenParameter an add it to list
                 TokenParameter tp = new TokenParameter(edge, token, TokenParameter.Scope.INPUT);
                 tokens.add(tp);
                 // set data Group
                 dataGroup = TokenUtils.updateDataGroup(tp, ignoreDataGroups, combineDataGroupsEdgeExpressions, dataGroups);
                 // update identifier
                 idBuffer.append(",i:").append(token.getID());
             }
         }
 
         // write tokens
         edges = transition.getWriteEdges();
         for (Edge edge : edges) {
             Token token = TokenUtils.getNextUnlockedToken(edge,true,dataGroup,ignoreDataGroups);
             if (token == null) {
                 throw new WorkflowFormatException("There is no unlocked Token on Place '"+edge.getPlaceID()+"' available!");
             } else {
                 if (!hasXPathEdgeExpressions) {
                     String edgeExpression = edge.getExpression();
                     if (edgeExpression != null && edgeExpression.indexOf('$')!=-1) hasXPathEdgeExpressions = true;
                 }
                 // put data tokens with edge expression to context
                 addToContext(token, edge);
                 // copy properties
                 updatePropertiesFromToken(token);
                 // create TokenParameter an add it to list
                 TokenParameter tp = new TokenParameter(edge, token, TokenParameter.Scope.WRITE);
                 tokens.add(tp);
                 // set data Group
                 dataGroup = TokenUtils.updateDataGroup(tp, ignoreDataGroups, combineDataGroupsEdgeExpressions, dataGroups);
                 // update identifier
                 idBuffer.append(",w:").append(token.getID());
             }
         }
 
         // dummy output tokens (real output tokens will be generated by activities or XPath edge expressions)
         edges = transition.getOutEdges();
         for (Edge edge : edges) {
             if (!hasXPathEdgeExpressions) {
                 String edgeExpression = edge.getExpression();
                 if (edgeExpression != null && edgeExpression.indexOf('$')!=-1) hasXPathEdgeExpressions = true;
             }
             tokens.add(new TokenParameter(edge, TokenParameter.Scope.OUTPUT));
         }
 
         // generate combined data groups property
         updateDataGroupProperty(dataGroup, dataGroups);
 
         // update resource allocation group property
         updateResourceAllocationGroupProperty();
 
         // set id
         ID = idBuffer.toString();
         updateID();
 
         // logging
         if(logger.isDebugEnabled()) {
             logger.debug("constructed "+this.toString());
         }
     }
 
     /**
      * Locks the input and - if available - the output tokens.
      */
     public void lockTokens() {
         if (logger.isDebugEnabled()) { logger.debug("lockTokens["+ID+"] ..."); }
 
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case READ:
                     continue;
                 case INPUT:
                     token.token.lock(transition);
                     break;
                 case WRITE:
                     continue;
                 case OUTPUT:
                     if (token.token != null) token.token.lock(transition);
                     break;
             }
         }
     }
 
     /**
      * Unlocks the input and - if available - the output tokens.
      */
     public void unlockTokens() {
         if (logger.isDebugEnabled()) { logger.debug("unlockTokens["+ID+"] ..."); }
 
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case READ:
                     continue;
                 case INPUT:
                     token.token.unlock();
                     break;
                 case WRITE:
                     continue;
                 case OUTPUT:
                     if (token.token != null) token.token.unlock();
                     break;
             }
         }
     }
 
     /**
      * Check conditions of this transition occurrence.
      * Variables (e.g. <code>$input/</code>) that are expanded by the corresponding
      * context XPath (e.g. <code>/gwdl:data/input</code>).
      * @param to Transition occurrence to check.
      * @return <code>ConditionChecker.CONDITION_TRUE</code> if all conditions evaluate to true and
      * <code>ConditionChecker.CONDITION_FALSE_STATIC</code>
      * if a least one static condition evaluates to false.
      * <code>ConditionChecker.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 checkConditions(ConditionChecker checker) throws WorkflowFormatException {
         if (transition.getConditions().length<1) return ConditionChecker.CONDITION_TRUE;
         if (logger.isDebugEnabled()) { logger.debug("checkConditions["+ID+"] ..."); }
         int transCondition = checker.check(this);
         if (logger.isDebugEnabled()) { logger.debug("checkConditions["+ID+"] ... : "+transCondition); }
         return transCondition;
     }
 
     /**
      * Remove input tokens.
      */
     public void removeInputTokens() {
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case READ:
                     continue;
                 case INPUT:
                     if (logger.isDebugEnabled()) {
                         logger.debug("removeInputTokens["+ID+"]: removing token 'i:"+token.token.getID() +"' from place '"+token.edge.getPlaceID()+"'");
                     }
                     token.edge.getPlace().removeToken(token.token);
                     break;
                 case WRITE:
                 case OUTPUT:
                     return;
             }
         }
     }
 
     /**
      * Put and lock reservation dummy tokens to output places.
      * ///ToDo: use this method to avoid place capacity problems on output places.
      * ///ToDo: Introduce special property to be able to display them as "ghost" tokens.
      * @throws CapacityException
      */
     public void putOutputReservationTokens() throws CapacityException {
         for (TokenParameter tp : tokens) {
             switch(tp.scope) {
                 case OUTPUT:
                     if (logger.isDebugEnabled()) {
                         logger.debug("putOutputReservationTokens["+ID+"]: putting reservation token to place '"+tp.edge.getPlaceID()+"'");
                     }
                     Token dummyToken = Factory.newToken();
                     dummyToken.lock(transition);
                     tp.edge.getPlace().addToken(dummyToken);
                     break;
             }
         }
     }
 
     /**
      * Remove reservation tokens from output places if there are any.
      */
     public void removeOutputReservationTokens() {
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case READ:
                 case INPUT:
                 case WRITE:
                     continue;
                 case OUTPUT:
                     if (token.token != null && token.token.isLockedBy(transition)) {
                         if (logger.isDebugEnabled()) {
                             logger.debug("removeOutputReservationTokens["+ID+"]: removing reservation token from place '"+token.edge.getPlaceID()+"'");
                         }
                         token.edge.getPlace().removeToken(token.token);
                     }
                     break;
             }
         }
     }
 
     /**
      * Update tokens on write places if necessary.
      * Currently only control tokens are updated.
      * ///ToDo: support data write tokens. Fix sematic issues first. 
      */
     public void updateWriteTokens() throws CapacityException {
         for (TokenParameter tp : tokens) {
             switch(tp.scope) {
                 case WRITE:
                     if (tp.edge.getExpression() == null) { // update control token
                         boolean newControl = activity == null || activity.getStatus() == Activity.Status.COMPLETED;
                         // only one thread should update write tokens
                         synchronized (tp.edge.getPlace()) {
                             if (tp.token.getControl() == null || tp.token.getControl() != newControl) {
                                 // update token
                                 Token oldToken = tp.token;
                                 tp.edge.getPlace().removeToken(oldToken);
                                 tp.token = Factory.newToken(newControl);
                                 if (logger.isDebugEnabled()) {
                                     logger.debug("updateWriteTokens()["+ID+"]: replacing token 'w:"+oldToken.getID() +"' on place '"+tp.edge.getPlaceID()+"' with token 'w"+tp.token.getID()+"'");
                                 }
                                 addPropertiesToToken(tp.token);
                                 tp.edge.getPlace().addToken(tp.token);
                             }
                         }
                     }
                     break;
             }
         }
     }
 
     /**
      * Puts output parameters to output places.
      * This method also copies the common properties to the token.
      * @throws CapacityException
      */
     public void putOutputTokens() throws CapacityException, WorkflowFormatException {
         for (TokenParameter tp : tokens) {
             switch(tp.scope) {
                 case OUTPUT:
                     if (tp.token == null) {
                         if (tp.edge.getExpression() == null) { // generate new control token
                             if (activity == null) {
                                 // true control token
                                 tp.token = Factory.newToken(true, props);
                             } else {
                                 // control token with Boolean representing status of activity
                                 tp.token = Factory.newToken(activity.getStatus() == Activity.Status.COMPLETED, props);
                             }
                         } else {
                             /// token contains SOAP Fault if there is no token available.
                             String edgeExpression = tp.edge.getExpression();
                             logger.error("Error: Output token with edge expression '" + edgeExpression + "' for "+toString()+ " is not available! Creating token with SOAP fault instead.");
                             SOAPFault fault = new SOAPFault("env:Receiver", "No Output Available");
                             if (activity != null) {
                                 fault.setNode(activity.toString());
                                 fault.setDetail("The activity '" +
                                         activity +
                                         "' has no output parameter related to the edge expression '" +
                                         edgeExpression + "'. Please check the edge expression!");
                             } else {
                                 fault.setNode("Transition "+transition.getID());
                                 fault.setDetail("The transition '" +
                                         transition.getID() +
                                         "' has no output parameter related to the edge expression '" +
                                         edgeExpression + "'. Please check the edge expression!");
                             }
                             tp.token = fault.toToken();
                         }
                     }
                     // copy properties
                     addPropertiesToToken(tp.token);
                     // add token to place
                     if (logger.isDebugEnabled()) {
                         logger.debug("putOutputTokens["+ID+"]: putting token 'o:"+tp.token.getID() +"' to place '"+tp.edge.getPlaceID()+"'");
                     }
                     tp.edge.getPlace().addToken(tp.token);
                     break;
             }
         }
     }
 
     public void writeWriteTokens() throws CapacityException {
         logger.warn("WARNING: writeWriteTokens() not yet implemented!");
         /// ToDo: Implement!
     }
 
     public String getID() {
         return ID;
     }
 
     public String getIDwithOutputs() {
         return IDwithOutputs;
     }
 
     public Document getContext() {
         return context;
     }
 
     public SimpleNamespaceContext getNamespaceContext() {
         return nsContext;
     }
 
     public String getNsUri(String nsPrefix) {
         return nsContext.translateNamespacePrefixToUri(nsPrefix);
     }
 
     public ArrayList<TokenParameter> getTokens() {
         return tokens;
     }
 
     /**
      * ToDo: execute only if necessary!
      * As side effect, this methods adds namespaces declared by transition properties
      * to nsContext.
      * @param step
      */
     public void evaluateXPathEdgeExpressions() throws WorkflowFormatException {
         if (logger.isDebugEnabled()) {
             logger.debug("evaluateXPathEdgeExpressions["+ID+"] ...");
         }
         TokenProcessor tokenProcessor = new TokenProcessor(nsContext, context, tokens);
         tokens = tokenProcessor.generateOutputTokens(props);
     }
 
     private void updateNamespaceContextFromTransitionProperties() {
         GenericProperties transProps = transition.getProperties();
         for (Property prop : transProps.getProperties()) {
             String key = prop.getKey();
             if (key.startsWith(Constants.PROP_TRANSITION_XMLNS_)) {
                 String[] strArr = key.split(Constants.PROP_TRANSITION_XMLNS_);
                 if (strArr.length == 2) nsContext.addNamespace(strArr[1],prop.getValue());
                 //                    logger.debug(" adding namespace: "+key.substring(6)+":"+prop.getValue());
             }
         }
     }
 
     private void updatePropertiesFromToken(Token token) {
         for (Property prop : token.getProperties().getProperties()) {
             if (props.get(prop.getKey()) == null) {
                 props.addProperty(prop);
             }
         }
     }
 
     /**
      * Put a property to the list of properties. Overwrites old values with same name.
      * @param name
      * @param value
      */
     public void putProperty(String name, String value) {
         props.put(name,value);
     }
 
 
     /**
      * Copy properties of transition occurrence to token.
      * Do NOT copy property Constants.PROP_TOKEN_ACTIVITY_MAXATTEMPTS.
      * @param token
      */
     private void addPropertiesToToken(Token token) {
         for (Property prop : props.getProperties()) {
             String key = prop.getKey();
             if (key.equals(Constants.PROP_TOKEN_ACTIVITY_MAXATTEMPTS)) continue;
             if (token.getProperties().get(key) == null) {
                 token.getProperties().addProperty(prop);
             }
         }
     }
 
     /**
      * Remove namespaces if this element does not have any namespace prefix.
      * This method also processes all descendands of the element.
      * @param element
      */
     public static void removeNamespacesWithoutPrefix(Element element) {
         if (element == null) return;
         if (element.getNamespacePrefix().length()==0) element.setNamespace(null);
         List list = element.getChildren();
         if (list != null) {
             for (Object child : list) {
                 removeNamespacesWithoutPrefix((Element) child);
             }
         }
     }
 
     /**
      * Add the cloned content of a token to the context element, regarding the edge expression.
      * The edge expression defines the element name of the context child element.
      * If the edge expression contains a path (e.g., "tns:test/ns:input"), then this method inserts additional
      * child elements (e.g., &lt;data&gt;&lt;tns:test&gt;&lt;ns:input&gt;15&lt;/ns:input&gt;&lt;/tns:test&gt;).
      * @param token
      * @param edge
      */
     private void addToContext(Token token, Edge edge) throws WorkflowFormatException {
         String edgeExpression = edge.getExpression();
         if (edgeExpression == null) return;
 
         // strip probability (e.g., "x{50%}" --> "x")
         double probability = StringUtils.getProbability(edgeExpression);
         if (probability > -1) {
             if (probabilityDistribution == null) probabilityDistribution = new DoubleDistribution();
             probabilityDistribution.put(probability);
         }
         String edgeExpressionWoProbabilities = StringUtils.stripProbability(edgeExpression);
         if (edgeExpressionWoProbabilities.length() == 0) return;
 
         // parse edgeExpression
         String[] edgeExpressionElements = StringUtils.stripOwl(edgeExpressionWoProbabilities).split("/");
 
         // control token with edge expression
         if (token.getData() == null) {
             Element dataChild = createTokenElement(edgeExpressionElements[0]);
             dataChild.setText(token.getControl()?Constants.TRUE:Constants.FALSE);
             addToContext(edgeExpression,edgeExpressionElements, dataChild);
         }
 
         // data token
         else {
             List children = ((Element) token.getData().get()).cloneContent();
 
             // Replace all child elements names by edge expression, e.g., edge expression = value1 -->
             // <data><value1>15</value1></data>
             if (children != null) {
                 for (Object obj : children) {
                     if (obj instanceof Element) {
                         // <value>15</value>
                         Element dataChild = (Element) obj;
                         dataChild.detach();
                         addToContext(edgeExpression, edgeExpressionElements, dataChild);
                     }
                 }
             }
         }
     }
 
     private void addToContext(String edgeExpression, String[] edgeExpressionElements, Element dataChild) throws WorkflowFormatException {
         // only one level element hierarchy specified in edgeExpression
         if (edgeExpressionElements.length == 1) {
             /// we should not remove any namespaces.
             //removeNamespacesWithoutPrefix(dataChild);
             renameTokenElement(dataChild, edgeExpressionElements[0]);
             context.getRootElement().addContent(dataChild);
         }
 
         // more than one level in element hierarchy
         else {
             // traverse element hierarchy
             Element newDataChild = null;
             Element parent = null;
             try {
                 for (int i=0; i<edgeExpressionElements.length-1; i++) {
 //                    logger.info("Processing edgeExpression part \""+edgeExpressionElements[i]+"\"");
                     Element newelement = createTokenElement(edgeExpressionElements[i]);
                     if (i==0) newDataChild = newelement;
                     // connect to parent element
                     if (parent != null) parent.addContent(newelement);
                     parent = newelement;
                 }
             } catch(IllegalNameException e) {
                 throw new WorkflowFormatException("Transition '"+transition.getID()+"' contains edgeExpression '"+edgeExpression+"' that is invalid for renaming input token elements.");
             }
             // last element is copied from dataChild
             String lastEdgeExpressionElement = edgeExpressionElements[edgeExpressionElements.length-1];
 //            logger.info("Processing edgeExpression part \""+lastEdgeExpressionElement+"\"");
             Element lastElement = (Element) dataChild.clone();
             renameTokenElement(lastElement, lastEdgeExpressionElement);
             if (parent != null) parent.addContent(lastElement);
             context.getRootElement().addContent(newDataChild);
         }
     }
 
     private void updateDataGroupProperty(String dataGroup, ArrayList<String> dataGroups) {
         // update data group if combine.data.groups is enabled
         if (dataGroups != null && dataGroups.size() > 0) {
             StringBuffer str = new StringBuffer();
             String group = dataGroups.get(0);
             if (group != null && group.length() > 0) {
                 str.append(group);
             }
             for (int i = 1 ; i < dataGroups.size() ; i++) {
                 group = dataGroups.get(i);
                 if (group != null && group.length() > 0) {
                     str.append(" x ");
                     str.append(group);
                 }
             }
             props.remove(Constants.PROP_TOKEN_DATA_GROUP);
             props.put(Constants.PROP_TOKEN_DATA_GROUP, str.toString());
         } else if (dataGroup != null && dataGroup.length() > 0){
             props.remove(Constants.PROP_TOKEN_DATA_GROUP);
             props.put(Constants.PROP_TOKEN_DATA_GROUP, dataGroup);
         }
     }
 
     private void updateResourceAllocationGroupProperty() {
         String str = transition.getProperties().get(Constants.PROP_TRANSITION_REMOVE_RESOURCE_ALLOCATION_GROUP);
         if (str != null && !str.equals(Constants.FALSE)) {
             for (String key : props.keys()) {
                 if (key.startsWith(Constants.PROP_TOKEN_RESOURCE_ALLOCATION_GROUP_)) {
                     props.remove(key);
                 }
             }
         }
     }
 
     /**
      * Generate the resource.allocation.group token property from activity resource.
      */
     public void generateResourceAllocationGroupPropertyFromActivity() {
         if (activity == null) return;
 
         String groupID = transition.getProperties().get(Constants.PROP_TRANSITION_RESOURCE_ALLOCATION_GROUP);
         if (groupID !=null && activity.getResourceName() != null && activity.getResourceName().length() >0 ) {
             String resourceUri = activity.getResourceName();
             if (logger.isDebugEnabled()) {
                 logger.debug("Resource co-allocation: setting property \""+Constants.PROP_TOKEN_RESOURCE_ALLOCATION_GROUP_ + groupID + "\" with value \""+resourceUri+"\" for activity "+activity.getID());
             }
             props.put(Constants.PROP_TOKEN_RESOURCE_ALLOCATION_GROUP_ + groupID, resourceUri);
         }
     }
 
     private void renameTokenElement(Element element, String newElementName) throws WorkflowFormatException {
         String[] ne = newElementName.split(":");
         // set new element name and namespace
         if (ne.length > 1) {
             // with namespace
             String nsPrefix = ne[0];
             // try default namespaces
             String nsUri = getNsUri(nsPrefix);
             if (nsUri == null) throw new WorkflowFormatException("Transition '"+transition.getID()+"' contains edgeExpression '"+newElementName+"' with namespace prefix '"+nsPrefix+"' which is not defined in the context of the transition. Use <property name=\"xmlns:"+nsPrefix+"\"/> to declare the namespace URI.");
             element.setName(ne[1]);
             element.setNamespace(Namespace.getNamespace(nsPrefix, nsUri));
         } else {
             // without namespace
             if (!newElementName.equals("*")) {
                 element.setName(newElementName);
                 element.setNamespace(null);
             }
         }
     }
 
     private Element createTokenElement(String newElementName) throws WorkflowFormatException, IllegalNameException {
         String[] ne = newElementName.split(":");
         if (ne.length > 1) {
             // with namespace
             String nsPrefix = ne[0];
             // try default namespaces
             String nsUri = getNsUri(nsPrefix);
             if (nsUri == null) throw new WorkflowFormatException("Transition '"+transition.getID()+"' contains edgeExpression '"+newElementName+"' with namespace prefix '"+nsPrefix+"' which is not defined in the context of the transition. Use <property name=\"xmlns:"+nsPrefix+"\"/> to declare the namespace URI.");
             return new Element(ne[1], Namespace.getNamespace(nsPrefix, nsUri));
         } else {
             // without namespace
             return new Element(ne[0]);
         }
     }
 
     /**
      * Copy the property from the TransitionOccurrence to all input tokens and remove it from the
      * TransitionOccurrence.
      * @param propertyName The name of the property.
      */
     public void movePropertyToInputTokens(String propertyName) {
         String value = props.get(propertyName);
         if (value != null) {
             loop: for (TokenParameter token : tokens) {
                 switch (token.scope) {
                     case READ:
                         continue loop;
                     case INPUT:
                         token.token.getProperties().put(propertyName,value);
                         break;
                     case WRITE:
                     case OUTPUT:
                         break loop;
                 }
             }
         }
     }
 
     public GenericProperties getProps() {
         return props;
     }
 
     public Activity getActivity() {
         return activity;
     }
 
     public void setActivity(Activity activity) {
         this.activity = activity;
     }
 
     public DoubleDistribution getProbabilityDistribution() {
         return probabilityDistribution;
     }
 
     /**
      * Updates and returns a ID that contains the ids of all available tokens.
      * Invoke after putOutputTokens() if you need the correct IDs of output tokens.
      * @return
      */
     public String updateID() {
         StringBuffer buffer = new StringBuffer(ID);
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case OUTPUT:
                     if (token.token != null) {
                         buffer.append(",o:").append(token.token.getID());
                     }
                     break;
             }
         }
         IDwithOutputs = buffer.toString();
         return IDwithOutputs;
     }
 
     public String toString() {
         StringBuffer buffer = new StringBuffer("TransitionOccurrence[");
         buffer.append(transition.getID());
         for (TokenParameter token : tokens) {
             switch (token.scope) {
                 case READ:
                     buffer.append(", r:");
                     break;
                 case INPUT:
                     buffer.append(", i:");
                     break;
                 case WRITE:
                     buffer.append(", w:");
                     break;
                 case OUTPUT:
                     buffer.append(", o:");
                     break;
             }
             if (token.token != null) buffer.append(token.token.getID());
         }
         buffer.append(']');
         return buffer.toString();
     }
 
     public static class DefaultNamespaceContext extends SimpleNamespaceContext {
         public DefaultNamespaceContext() {
             super();
             addNamespace("tns","http://target.namespace");
             addNamespace("gwdl", "http://www.gridworkflow.org/gworkflowdl");
             addNamespace("xsd", "http://www.w3.org/2001/XMLSchema");
             addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
             addNamespace("soapenv", "http://www.w3.org/2003/05/soap-envelope");
 //            addNamespace("soapenv", "http://schemas.xmlsoap.org/soap/envelope/");
         }
     }
 
 }