/*
 * JBoss, Home of Professional Open Source
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jbpm.jpdl.internal.xml;

import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

import org.jbpm.api.JbpmException;
import org.jbpm.api.activity.ActivityBehaviour;
import org.jbpm.api.listener.EventListener;
import org.jbpm.api.model.Event;
import org.jbpm.internal.log.Log;
import org.jbpm.jpdl.internal.activity.JpdlBinding;
import org.jbpm.jpdl.internal.activity.MailListener;
import org.jbpm.jpdl.internal.model.JpdlProcessDefinition;
import org.jbpm.pvm.internal.email.impl.MailProducerImpl;
import org.jbpm.pvm.internal.email.impl.MailTemplate;
import org.jbpm.pvm.internal.email.impl.MailTemplateRegistry;
import org.jbpm.pvm.internal.email.spi.MailProducer;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.model.ActivityCoordinatesImpl;
import org.jbpm.pvm.internal.model.ActivityImpl;
import org.jbpm.pvm.internal.model.CompositeElementImpl;
import org.jbpm.pvm.internal.model.Continuation;
import org.jbpm.pvm.internal.model.EventImpl;
import org.jbpm.pvm.internal.model.EventListenerReference;
import org.jbpm.pvm.internal.model.ObservableElementImpl;
import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
import org.jbpm.pvm.internal.model.ScopeElementImpl;
import org.jbpm.pvm.internal.model.TimerDefinitionImpl;
import org.jbpm.pvm.internal.model.TransitionImpl;
import org.jbpm.pvm.internal.model.VariableDefinitionImpl;
import org.jbpm.pvm.internal.model.VariableOutDefinitionImpl;
import org.jbpm.pvm.internal.model.VariableOutDefinitionSet;
import org.jbpm.pvm.internal.repository.DeploymentImpl;
import org.jbpm.pvm.internal.task.AssignableDefinitionImpl;
import org.jbpm.pvm.internal.task.SwimlaneDefinitionImpl;
import org.jbpm.pvm.internal.task.TaskDefinitionImpl;
import org.jbpm.pvm.internal.util.XmlUtil;
import org.jbpm.pvm.internal.wire.Descriptor;
import org.jbpm.pvm.internal.wire.WireContext;
import org.jbpm.pvm.internal.wire.binding.MailTemplateBinding;
import org.jbpm.pvm.internal.wire.binding.ObjectBinding;
import org.jbpm.pvm.internal.wire.descriptor.ObjectDescriptor;
import org.jbpm.pvm.internal.wire.usercode.UserCodeReference;
import org.jbpm.pvm.internal.wire.xml.WireParser;
import org.jbpm.pvm.internal.xml.Bindings;
import org.jbpm.pvm.internal.xml.Parse;
import org.jbpm.pvm.internal.xml.Parser;
import org.jbpm.pvm.internal.xml.ProblemImpl;
import org.w3c.dom.Element;

/**
 * @author Tom Baeyens
 */
public class JpdlParser extends Parser {
  
  private static final Log log = Log.getLog(JpdlParser.class.getName());

  public static final String NAMESPACE_JPDL_40 = "http://jbpm.org/4.0/jpdl";
  public static final String NAMESPACE_JPDL_42 = "http://jbpm.org/4.2/jpdl";
  public static final String NAMESPACE_JPDL_43 = "http://jbpm.org/4.3/jpdl";

  public static final String CURRENT_VERSION_JBPM = "4.3";
  public static final String CURRENT_VERSION_NAMESPACE = "http://jbpm.org/"+CURRENT_VERSION_JBPM+"/jpdl";
  public static final String CURRENT_VERSION_PROCESS_LANGUAGE_ID = "jpdl-"+CURRENT_VERSION_JBPM;
  
  public static final List<String> SCHEMA_RESOURCES = new ArrayList<String>();
  static {
    SCHEMA_RESOURCES.add("jpdl-4.0.xsd");
    SCHEMA_RESOURCES.add("jpdl-4.2.xsd");
    SCHEMA_RESOURCES.add("jpdl-4.3.xsd");
  }

  public static final WireParser wireParser = WireParser.getInstance();
  public static final ObjectBinding objectBinding = ObjectBinding.INSTANCE;

  // array elements are mutable, even when final
  // never make a static array public
  static final String[] DEFAULT_BINDING_RESOURCES = {
    "jbpm.jpdl.bindings.xml",
    "jbpm.user.bindings.xml"
  }; 

  static JpdlBindingsParser jpdlBindingsParser = new JpdlBindingsParser();

  public static final String CATEGORY_ACTIVITY = "activity";
  public static final String CATEGORY_EVENT_LISTENER = "eventlistener";

  public JpdlParser() {
    initialize(); 
    parseBindings();
    setSchemaResources(SCHEMA_RESOURCES);
  }

  protected void parseBindings() {
    this.bindings = new Bindings();

    for (String activityResource: DEFAULT_BINDING_RESOURCES) {
      Enumeration<URL> resourceUrls = getResources(activityResource);
      if (resourceUrls.hasMoreElements()) {
        while (resourceUrls.hasMoreElements()) {
          URL resourceUrl = resourceUrls.nextElement();
          log.trace("loading jpdl bindings from resource: "+resourceUrl);
          jpdlBindingsParser.createParse()
            .setUrl(resourceUrl)
            .contextMapPut(Parse.CONTEXT_KEY_BINDINGS, bindings)
            .execute()
            .checkErrors("jpdl bindings from "+resourceUrl.toString());
        }
      } else {
        log.trace("skipping unavailable jpdl activities resource: "+activityResource);
      }
    }
  }

  protected Enumeration<URL> getResources(String resourceName) {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    Enumeration<URL> resourceUrls;
    try {
      resourceUrls = classLoader.getResources(resourceName);
    } catch (Exception e) {
      throw new JbpmException("couldn't get resource urls for "+resourceName, e);
    }
    return resourceUrls;
  }

  public Object parseDocumentElement(Element documentElement, Parse parse) {
    List<ProcessDefinitionImpl> processDefinitions = new ArrayList<ProcessDefinitionImpl>();
    
    JpdlProcessDefinition processDefinition = instantiateNewJpdlProcessDefinition();
    
    processDefinitions.add(processDefinition);
    
    parse.contextStackPush(processDefinition);
    try {
      // process attribues
      String name = XmlUtil.attribute(documentElement, "name", true, parse);
      processDefinition.setName(name);

      // make the process language version available for bindings
      // to allow for specific parsing behaviour per version
      
      // first check if the langid is available as a deployment property
      DeploymentImpl deployment = (DeploymentImpl) parse.contextMapGet(Parse.CONTEXT_KEY_DEPLOYMENT);
      if (deployment!=null) {
        String processLanguageId = deployment.getProcessLanguageId(name);
        if (processLanguageId==null) {
          // if it is not available as a deployment property, check if the 
          // jpdlparser attribute specifies a specific jpdl version.
          // this is the case for certain compatibility tests in our test suite
          String jpdlParser = XmlUtil.attribute(documentElement, "jpdlparser");
          if (jpdlParser!=null) {
            processLanguageId = "jpdl-"+jpdlParser;

          } else {
            // if none of the above, check if this is a parser test run for a specific verion
            // specify the jpdltestversion with "mvn -Djpdlparser=jpdl-4.3 clean install"
            // that way, the whole test suite will be use the specified parser
            jpdlParser = System.getProperty("jpdlparser");
            if (jpdlParser!=null) {
              processLanguageId = "jpdl-"+jpdlParser;

            } else {
              // if this process has a namespace, then use the namespace 
              // to see what jpdl parser version should be used
              String namespaceUri = documentElement.getNamespaceURI();
              if (namespaceUri!=null) {
                processLanguageId = "jpdl-"+namespaceUri.substring(16, 19);

              } else {
                // if none of the above, just deploy it as the current library version
                processLanguageId = CURRENT_VERSION_PROCESS_LANGUAGE_ID;
              }
            }
          }
          // saving the process language will make sure that  
          // the right parser version is used after an upgrade of jbpm
          // as the old format xml will still be in the db
          deployment.setProcessLanguageId(name, processLanguageId);
        }
        parse.contextMapPut(Parse.CONTEXT_KEY_PROCESS_LANGUAGE_ID, processLanguageId);
      }

      String packageName = XmlUtil.attribute(documentElement, "package");
      processDefinition.setPackageName(packageName);

      Integer version = XmlUtil.attributeInteger(documentElement, "version", false, parse);
      if (version!=null) {
        processDefinition.setVersion(version);
      }

      String key = XmlUtil.attribute(documentElement, "key", false, parse);
      if (key!=null) {
        processDefinition.setKey(key);
      }

      Element descriptionElement = XmlUtil.element(documentElement, "description");
      if (descriptionElement!=null) {
        String description = XmlUtil.getContentText(descriptionElement);
        processDefinition.setDescription(description);
      }
      
      UnresolvedTransitions unresolvedTransitions = new UnresolvedTransitions();
      parse.contextStackPush(unresolvedTransitions);
      
      // swimlanes
      List<Element> swimlaneElements = XmlUtil.elements(documentElement, "swimlane");
      for (Element swimlaneElement: swimlaneElements) {
        String swimlaneName = XmlUtil.attribute(swimlaneElement, "name", true, parse);
        if (swimlaneName!=null) {
          SwimlaneDefinitionImpl swimlaneDefinition = 
              processDefinition.createSwimlaneDefinition(swimlaneName);
          parseAssignmentAttributes(swimlaneElement, swimlaneDefinition, parse);
        }
      }

      // on events
      parseOnEvents(documentElement, parse, processDefinition);
      
      // activities
      parseActivities(documentElement, parse, processDefinition);

      // bind activities to their destinations
      resolveTransitionDestinations(parse, processDefinition, unresolvedTransitions);

      // process migration information
      Element migrationElement = XmlUtil.element(documentElement, "migrate-instances");
      if (migrationElement != null) {
        MigrationHelper.parseMigrationDescriptor(migrationElement, parse, processDefinition);
      }

    } finally {
      parse.contextStackPop();
    }

    if (processDefinition.getInitial()==null) {
      parse.addProblem("no start activity in process", documentElement);
    }
    
    return processDefinitions;
  }

  protected JpdlProcessDefinition instantiateNewJpdlProcessDefinition() {
    return new JpdlProcessDefinition();
  }

  protected void resolveTransitionDestinations(Parse parse, JpdlProcessDefinition processDefinition, UnresolvedTransitions unresolvedTransitions) {
    for (UnresolvedTransition unresolvedTransition: unresolvedTransitions.list) {
      unresolvedTransition.resolve(processDefinition, parse);
    }
  }

  public void parseActivities(Element documentElement, Parse parse, CompositeElementImpl compositeElement) {
    List<Element> elements = XmlUtil.elements(documentElement);
    for (Element nestedElement : elements) {
      String tagName = XmlUtil.getTagLocalName(nestedElement);
      if ("on".equals(tagName) 
          || "timer".equals(tagName)
          || "swimlane".equals(tagName) 
          || "migrate-instances".equals(tagName)) continue;

      JpdlBinding activityBinding = (JpdlBinding) getBinding(nestedElement, CATEGORY_ACTIVITY);
      if (activityBinding == null) {
        log.debug("unrecognized activity: " + tagName);
        continue;
      }

      ActivityImpl activity = compositeElement.createActivity();
      parse.contextStackPush(activity);
      try {
        activity.setType(activityBinding.getTagName());
        activityBinding.parseName(nestedElement, activity, parse);
        parseTransitions(nestedElement, activity, parse);

        Element descriptionElement = XmlUtil.element(documentElement, "description");
        if (descriptionElement!=null) {
          String description = XmlUtil.getContentText(descriptionElement);
          activity.setDescription(description);
        }

        String continuationText = XmlUtil.attribute(nestedElement, "continue");
        if (continuationText!=null) {
          if ("async".equals(continuationText)) {
            activity.setContinuation(Continuation.ASYNCHRONOUS);
          } else if ("exclusive".equals(continuationText)) {
            activity.setContinuation(Continuation.EXCLUSIVE);
          }
        }

        Object parseResult = activityBinding.parse(nestedElement, parse, this);
        if (parseResult instanceof ActivityBehaviour) {
          ActivityBehaviour activityBehaviour = (ActivityBehaviour) parseResult;
          activity.setActivityBehaviour(activityBehaviour);
        } else {
          Descriptor activityBehaviourDescriptor = (Descriptor) parseResult;
          activity.setActivityBehaviourDescriptor(activityBehaviourDescriptor);
        }

        parseOnEvents(nestedElement, parse, activity);

        String g = XmlUtil.attribute(nestedElement, "g");
        if (g == null) continue;

        StringTokenizer stringTokenizer = new StringTokenizer(g, ",");
        ActivityCoordinatesImpl coordinates = null;
        if (stringTokenizer.countTokens() == 4) {
          try {
            int x = Integer.parseInt(stringTokenizer.nextToken());
            int y = Integer.parseInt(stringTokenizer.nextToken());
            int width = Integer.parseInt(stringTokenizer.nextToken());
            int height = Integer.parseInt(stringTokenizer.nextToken());
            coordinates = new ActivityCoordinatesImpl(x, y, width, height);
          } catch (NumberFormatException e) {
            coordinates = null;
          }
        }
        if (coordinates != null) {
          activity.setCoordinates(coordinates);
        } else {
          parse.addProblem("invalid coordinates g=\"" + g + "\" in " + activity, nestedElement);
        }
      } finally {
        parse.contextStackPop();
      }
    }
  }
  
  public TimerDefinitionImpl parseTimerDefinition(Element timerElement, Parse parse, ScopeElementImpl scopeElement) {
    TimerDefinitionImpl timerDefinition = scopeElement.createTimerDefinition();

    String duedate = XmlUtil.attribute(timerElement, "duedate");
    String duedatetime = XmlUtil.attribute(timerElement, "duedatetime");

    if (duedate!=null) {
      timerDefinition.setDueDateDescription(duedate);
      
    } else if (duedatetime!=null) {
      String dueDateTimeFormatText = (String) EnvironmentImpl.getFromCurrent("jbpm.duedatetime.format");
      if (dueDateTimeFormatText==null) {
        dueDateTimeFormatText = "HH:mm dd/MM/yyyy";
      }
      SimpleDateFormat dateFormat = new SimpleDateFormat(dueDateTimeFormatText);
      try {
        Date duedatetimeDate = dateFormat.parse(duedatetime);
        timerDefinition.setDueDate(duedatetimeDate);
      } catch (ParseException e) {
        parse.addProblem("couldn't parse duedatetime "+duedatetime, e);
      }
    } else {
      parse.addProblem("either duedate or duedatetime is required in timer", timerElement);
    }
    
    String repeat = XmlUtil.attribute(timerElement, "repeat");
    timerDefinition.setRepeat(repeat);
    
    return timerDefinition;
  }

  public void parseOnEvents(Element element, Parse parse, ScopeElementImpl scopeElement) {
    // event listeners
    List<Element> onElements = XmlUtil.elements(element, "on");
    for (Element onElement: onElements) {
      String eventName = XmlUtil.attribute(onElement, "event", true, parse);
      parseOnEvent(onElement, parse, scopeElement, eventName);

      Element timerElement = XmlUtil.element(onElement, "timer");
      if (timerElement!=null) {
        TimerDefinitionImpl timerDefinitionImpl = parseTimerDefinition(timerElement, parse, scopeElement);
        timerDefinitionImpl.setEventName(eventName);
      }
    }
  }

  public void parseOnEvent(Element element, Parse parse, ObservableElementImpl observableElement, String eventName) {
    if (eventName!=null) {
      EventImpl event = observableElement.getEvent(eventName);
      if (event==null) {
        event = observableElement.createEvent(eventName);
      }
      
      String continuationText = XmlUtil.attribute(element, "continue");
      if (continuationText!=null) {
        if ("async".equals(continuationText)) {
          event.setContinuation(Continuation.ASYNCHRONOUS);
        } else if ("exclusive".equals(continuationText)) {
          event.setContinuation(Continuation.EXCLUSIVE);
        }
      }

      for (Element eventListenerElement: XmlUtil.elements(element)) {
        JpdlBinding eventBinding = (JpdlBinding) getBinding(eventListenerElement, CATEGORY_EVENT_LISTENER);
        if (eventBinding!=null) {
          EventListenerReference eventListenerReference = null;
          Object parseResult = eventBinding.parse(eventListenerElement, parse, this);
          if (parseResult instanceof EventListener) {
            EventListener eventListener = (EventListener) parseResult;
            eventListenerReference = event.createEventListenerReference(eventListener);
          } else {
            Descriptor eventListenerDescriptor = (Descriptor) parseResult;
            eventListenerReference = event.createEventListenerReference(eventListenerDescriptor);
          }
          
          if (XmlUtil.attributeBoolean(eventListenerElement, "propagation", false, parse, false)) {
            eventListenerReference.setPropagationEnabled(true);
          }
          
          continuationText = XmlUtil.attribute(eventListenerElement, "continue");
          if (continuationText!=null) {
            if (observableElement instanceof ActivityImpl) {
              if (observableElement.getName()==null) {
                parse.addProblem("async continuation on event listener requires activity name", eventListenerElement);
              }
            } else if (observableElement instanceof TransitionImpl) {
              TransitionImpl transition = (TransitionImpl) observableElement;
              if (transition.getSource().getName()==null) {
                parse.addProblem("async continuation on event listener requires name in the transition source activity", eventListenerElement);
              }
            }
            if ("async".equals(continuationText)) {
              eventListenerReference.setContinuation(Continuation.ASYNCHRONOUS);
            } else if ("exclusive".equals(continuationText)) {
              eventListenerReference.setContinuation(Continuation.EXCLUSIVE);
            }
          }

        } else {
          String tagName = XmlUtil.getTagLocalName(eventListenerElement);
          if ( ! ( (observableElement instanceof TransitionImpl)
                   && ( "condition".equals(tagName)
                        || "timer".equals(tagName)
                      )
                 )
             ) {
            parse.addProblem("unrecognized event listener: "+tagName, null, ProblemImpl.TYPE_WARNING, eventListenerElement);
          }
        }
      }
    }
  }

  public void parseTransitions(Element element, ActivityImpl activity, Parse parse) {
    List<Element> transitionElements = XmlUtil.elements(element, "transition");
    UnresolvedTransitions unresolvedTransitions = parse.contextStackFind(UnresolvedTransitions.class);
    for (Element transitionElement: transitionElements) {
      String transitionName = XmlUtil.attribute(transitionElement, "name", false, parse);

      Element timerElement = XmlUtil.element(transitionElement, "timer");
      if (timerElement!=null) {
        TimerDefinitionImpl timerDefinitionImpl = parseTimerDefinition(timerElement, parse, activity);
        timerDefinitionImpl.setSignalName(transitionName);
      }
  
      TransitionImpl transition = activity.createOutgoingTransition();
      transition.setName(transitionName);
  
      unresolvedTransitions.add(transition, transitionElement);
      
      parseOnEvent(transitionElement, parse, transition, Event.TAKE);
    }
  }

  public void parseAssignmentAttributes(Element element, AssignableDefinitionImpl assignableDefinition, Parse parse) {
    Element descriptionElement = XmlUtil.element(element, "description");
    if (descriptionElement!=null) {
      String description = XmlUtil.getContentText(descriptionElement);
      assignableDefinition.setDescription(description);
    }
  
    Element assignmentHandlerElement = XmlUtil.element(element, "assignment-handler");
    if (assignmentHandlerElement!=null) {
      UserCodeReference assignmentHandlerReference = parseUserCodeReference(assignmentHandlerElement, parse);
      assignableDefinition.setAssignmentHandlerReference(assignmentHandlerReference);
    }
  
    String assigneeExpression = XmlUtil.attribute(element, "assignee");
    assignableDefinition.setAssigneeExpression(assigneeExpression);
    
    String assigneeExpressionLanguage = XmlUtil.attribute(element, "assignee-lang");
    assignableDefinition.setAssigneeExpressionLanguage(assigneeExpressionLanguage);
    
    String candidateUsersExpression = XmlUtil.attribute(element, "candidate-users");
    assignableDefinition.setCandidateUsersExpression(candidateUsersExpression);
    
    String candidateUsersExpressionLanguage = XmlUtil.attribute(element, "candidate-users-lang");
    assignableDefinition.setCandidateUsersExpressionLanguage(candidateUsersExpressionLanguage);
    
    String candidateGroupsExpression = XmlUtil.attribute(element, "candidate-groups");
    assignableDefinition.setCandidateGroupsExpression(candidateGroupsExpression);
    
    String candidateGroupsExpressionLanguage = XmlUtil.attribute(element, "candidate-groups-lang");
    assignableDefinition.setCandidateGroupsExpressionLanguage(candidateGroupsExpressionLanguage);
  }

  public TaskDefinitionImpl parseTaskDefinition(Element element, Parse parse, ScopeElementImpl scopeElement) {
    TaskDefinitionImpl taskDefinition = new TaskDefinitionImpl();
  
    String taskName = XmlUtil.attribute(element, "name");
    taskDefinition.setName(taskName);

    String form = XmlUtil.attribute(element, "form");
    taskDefinition.setFormResourceName(form);
    
    ProcessDefinitionImpl processDefinition = parse.contextStackFind(ProcessDefinitionImpl.class);
    if (processDefinition.getTaskDefinition(taskName)!=null) {
      parse.addProblem("duplicate task name "+taskName, element);
    } else {
      processDefinition.addTaskDefinitionImpl(taskDefinition);
    }

    String swimlaneName = XmlUtil.attribute(element, "swimlane");
    if (swimlaneName!=null) {
      JpdlProcessDefinition jpdlProcessDefinition = parse.contextStackFind(JpdlProcessDefinition.class);
      SwimlaneDefinitionImpl swimlaneDefinition = jpdlProcessDefinition.getSwimlaneDefinition(swimlaneName);
      if (swimlaneDefinition!=null) {
        taskDefinition.setSwimlaneDefinition(swimlaneDefinition);
      } else {
        parse.addProblem("swimlane "+swimlaneName+" not declared", element);
      }
    }
    
    parseAssignmentAttributes(element, taskDefinition, parse);
    
    // parse notification mail producer
    Element notificationElement = XmlUtil.element(element, "notification");
    if (notificationElement != null) {
      parseMailEvent(notificationElement, parse, scopeElement, Event.ASSIGN);
    }

    Element reminderElement = XmlUtil.element(element, "reminder");
    if (reminderElement != null) {
      parseMailEvent(reminderElement, parse, scopeElement, Event.REMIND);
      // associate timer to event
      TimerDefinitionImpl timerDefinition = parseTimerDefinition(reminderElement, parse, scopeElement);
      timerDefinition.setEventName(Event.REMIND);
    }

    return taskDefinition;
  }

  public List<VariableDefinitionImpl> parseVariableDefinitions(Element element, Parse parse, boolean initRequired) {
    List<VariableDefinitionImpl> variableDefinitions = new ArrayList<VariableDefinitionImpl>();
    
    for (Element inElement: XmlUtil.elements(element, "variable")) {
      VariableDefinitionImpl variableDefinition = new VariableDefinitionImpl();

      String name = XmlUtil.attribute(inElement, "name", true, parse);
      variableDefinition.setName(name);
      
      int sources = 0;
      
      String initExpr = XmlUtil.attribute(inElement, "init");
      if (initExpr!=null) {
        variableDefinition.setInitExpression(initExpr);
        sources++;
      }
      
      Element valueElement = XmlUtil.element(inElement);
      if (valueElement!=null) {
        Descriptor initValueDescriptor = (Descriptor) WireParser.getInstance().parseElement(valueElement, parse);
        variableDefinition.setInitDescriptor(initValueDescriptor);
        sources++;
      }

      if (initRequired && sources==0) {
        parse.addProblem("no init specified", inElement);
      }
      if (sources>1) {
        parse.addProblem("init attribute and init element are mutually exclusive on element variable", inElement);
      }
      
      variableDefinitions.add(variableDefinition);
    }

    return variableDefinitions;
  }

  public VariableOutDefinitionSet parseVariableOutDefinitionSet(Element element, Parse parse) {
    VariableOutDefinitionSet variableOutDefinitionSet = new VariableOutDefinitionSet();
    
    for (Element inElement: XmlUtil.elements(element, "out-variable")) {
      VariableOutDefinitionImpl variableOutDefinition = variableOutDefinitionSet.createVariableOutDefinition();

      String name = XmlUtil.attribute(inElement, "name", true, parse);
      variableOutDefinition.setName(name);
      
      String expression = XmlUtil.attribute(inElement, "init");
      if (expression!=null) {
        variableOutDefinition.setExpression(expression);
      }
    }

    return variableOutDefinitionSet;
  }

  public void parseMailEvent(Element element, Parse parse,
      ObservableElementImpl observableElement, String eventName) {
    // obtain assign event
    EventImpl event = observableElement.getEvent(eventName);
    if (event == null) {
      event = observableElement.createEvent(eventName);
    }
    // register event listener
    MailListener eventListener = new MailListener();
    EventListenerReference eventListenerRef = event.createEventListenerReference(eventListener);
    // set continuation mode
    String continuationText = XmlUtil.attribute(element, "continue");
    if ("async".equals(continuationText)) {
      eventListenerRef.setContinuation(Continuation.ASYNCHRONOUS);
    }
    else if ("exclusive".equals(continuationText)) {
      eventListenerRef.setContinuation(Continuation.EXCLUSIVE);
    }

    //https://jira.jboss.org/jira/browse/JBPM-2466
    String mailTemplateName = eventName;
    if (Event.ASSIGN.equals(eventName)) {
    	mailTemplateName = "task-notification";
    } else if (Event.REMIND.equals(eventName)) {
    	mailTemplateName = "task-reminder";
    }
    
    // associate mail producer to event listener
    MailProducer mailProducer = parseMailProducer(element, parse, mailTemplateName);
    eventListener.setMailProducer(mailProducer);
  }

  public MailProducer parseMailProducer(Element element, Parse parse, String defaultTemplateName) {
    // check whether the element is a generic object descriptor
    if (ObjectBinding.isObjectDescriptor(element)) {
      // TODO test custom mail producer
      ObjectDescriptor objectDescriptor = parseObjectDescriptor(element, parse);
      return (MailProducer) WireContext.create(objectDescriptor);
    }

    // parse the default producer
    MailProducerImpl mailProducer = new MailProducerImpl();
    mailProducer.setTemplate(parseMailTemplate(element, parse, defaultTemplateName));
    return mailProducer;
  }

  private MailTemplate parseMailTemplate(Element element, Parse parse,
      String defaultTemplateName) {
    if (element.hasAttribute("template")) {
      // fetch template from configuration
      return findTemplate(element, parse, element.getAttribute("template"));
    }
    if (!XmlUtil.isTextOnly(element)) {
      // parse inline template
      return MailTemplateBinding.parseMailTemplate(element, parse);
    }
    if (defaultTemplateName != null) {
      // fetch default template
      return findTemplate(element, parse, defaultTemplateName);
    }
    parse.addProblem("mail template must be referenced in the 'template' attribute "
        + "or specified inline", element);
    return null;
  }

  private MailTemplate findTemplate(Element element, Parse parse, String templateName) {
    MailTemplateRegistry templateRegistry = EnvironmentImpl.getFromCurrent(MailTemplateRegistry.class);
    if (templateRegistry != null) {
      MailTemplate template = templateRegistry.getTemplate(templateName);
      if (template != null) return template;
    }
    parse.addProblem("mail template not found: " + templateName, element);
    return null;
  }

  public UserCodeReference parseUserCodeReference(Element element, Parse parse) {
    UserCodeReference userCodeReference = new UserCodeReference();

    ObjectDescriptor objectDescriptor = parseObjectDescriptor(element, parse);
    userCodeReference.setDescriptor(objectDescriptor);
    
    if (objectDescriptor.getExpr()!=null) {
      // expressions are not cached by default
      userCodeReference.setCached(false);
    }

    Boolean isCached = XmlUtil.attributeBoolean(element, "cache", false, parse, null);
    if (isCached!=null) {
      userCodeReference.setCached(isCached.booleanValue());
    }

    return userCodeReference;
  }

  public ObjectDescriptor parseObjectDescriptor(Element element, Parse parse) {
    return (ObjectDescriptor) objectBinding.parse(element, parse, wireParser);
  }

  public Descriptor parseDescriptor(Element element, Parse parse) {
    return (Descriptor) wireParser.parseElement(element, parse);
  }

  public Set<String> getActivityTagNames() {
    return getBindings().getTagNames(CATEGORY_ACTIVITY);
  }
}