/*
 * 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.pvm.internal.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.StringTokenizer;

import org.jbpm.api.Execution;
import org.jbpm.api.JbpmException;
import org.jbpm.api.activity.ActivityExecution;
import org.jbpm.api.job.Job;
import org.jbpm.api.job.Timer;
import org.jbpm.api.listener.EventListenerExecution;
import org.jbpm.api.model.Event;
import org.jbpm.api.model.OpenExecution;
import org.jbpm.api.task.Assignable;
import org.jbpm.api.task.AssignmentHandler;
import org.jbpm.internal.log.Log;
import org.jbpm.pvm.internal.client.ClientProcessDefinition;
import org.jbpm.pvm.internal.client.ClientProcessInstance;
import org.jbpm.pvm.internal.env.Context;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.env.ExecutionContext;
import org.jbpm.pvm.internal.history.HistoryEvent;
import org.jbpm.pvm.internal.history.events.ActivityEnd;
import org.jbpm.pvm.internal.history.events.ActivityStart;
import org.jbpm.pvm.internal.history.events.AutomaticEnd;
import org.jbpm.pvm.internal.history.events.DecisionEnd;
import org.jbpm.pvm.internal.history.events.ProcessInstanceCreate;
import org.jbpm.pvm.internal.history.events.ProcessInstanceEnd;
import org.jbpm.pvm.internal.id.DbidGenerator;
import org.jbpm.pvm.internal.id.IdComposer;
import org.jbpm.pvm.internal.job.JobImpl;
import org.jbpm.pvm.internal.job.MessageImpl;
import org.jbpm.pvm.internal.model.op.AtomicOperation;
import org.jbpm.pvm.internal.model.op.MoveToChildActivity;
import org.jbpm.pvm.internal.model.op.Signal;
import org.jbpm.pvm.internal.script.ScriptManager;
import org.jbpm.pvm.internal.session.DbSession;
import org.jbpm.pvm.internal.session.MessageSession;
import org.jbpm.pvm.internal.session.RepositorySession;
import org.jbpm.pvm.internal.session.TimerSession;
import org.jbpm.pvm.internal.task.AssignableDefinitionImpl;
import org.jbpm.pvm.internal.task.SwimlaneDefinitionImpl;
import org.jbpm.pvm.internal.task.SwimlaneImpl;
import org.jbpm.pvm.internal.type.Variable;
import org.jbpm.pvm.internal.util.EqualsUtil;
import org.jbpm.pvm.internal.util.Priority;
import org.jbpm.pvm.internal.wire.usercode.UserCodeReference;

/**
 * @author Tom Baeyens
 */
public class ExecutionImpl extends ScopeInstanceImpl 
                           implements ClientProcessInstance,
                                      ActivityExecution, 
                                      EventListenerExecution, 
                                      Serializable {

  private static final long serialVersionUID = 1L;

  private static final Log log = Log.getLog(ExecutionImpl.class.getName());
  
  /** an optional name for this execution.  can be used to 
   * differentiate concurrent paths of execution like e.g. 
   * the 'shipping' and 'billing' paths. */
  protected String name;

  /** a key for this execution. typically this is an externally provided reference 
   * that is unique within the scope of the process definition.  */
  protected String key;

  /** a unique id for this execution. */
  protected String id;

  /** are concurrent executions that related to this execution. */
  protected Collection<ExecutionImpl> executions = new ArrayList<ExecutionImpl>();

  /** the parent child relation of executions is convenient for some forms of
   * concurrency. */
  protected ExecutionImpl parent = null;
  protected ExecutionImpl processInstance;
  
  /** the super process link in case this is a sub process execution */  
  protected ExecutionImpl superProcessExecution;
  
  /** the sub process link in case of sub process execution */
  protected ExecutionImpl subProcessInstance;

  /** swimlanes */
  protected Map<String, SwimlaneImpl> swimlanes = new HashMap<String, SwimlaneImpl>();

  /** reference to the current activity instance history record */
  protected Long historyActivityInstanceDbid;
  
  /** start time of the activity for history purposes (not persisted) */
  protected Date historyActivityStart;

  protected int priority = Priority.NORMAL;

  protected Map<String, Variable> systemVariables = new HashMap<String, Variable>();

  // persistent indicators of the current position ////////////////////////////
  
  /** persistent process definition reference */
  protected String processDefinitionId;
  
  /** persistent activity reference */
  protected String activityName;

  // transient cached indicators of the current position //////////////////////

  /** transient cached process definition.  persistence is managed in {@link #processDefinitionId} */
  protected ProcessDefinitionImpl processDefinition;
  
  /** transient cached current activity pointer.  persistence is managed in {@link #activityName} */
  private ActivityImpl activity;

  /** transition is not to be made persistable by default */
  protected TransitionImpl transition;

  protected EventImpl event;

  protected AtomicOperation eventCompletedOperation;

  protected int eventListenerIndex;

  protected ObservableElementImpl eventSource;

  // cached named executions //////////////////////////////////////////////////
  
  /** caches the child executions by execution name.  This member might be
   * null and is only created from the executions in case its needed.  Note
   * that not all executions are forced to have a name and duplicates are allowed.
   * In case the {@link #executions} change, the executionsMap can be nulled or
   * also updated (but a check needs to be added whether it exists). */
  protected transient Map<String, Execution> executionsMap = null;

  /** the queue of atomic operations to be performed for this execution. */
  protected Queue<AtomicOperation> atomicOperations;

  public enum Propagation {
    UNSPECIFIED, WAIT, EXPLICIT
  }
  protected Propagation propagation = null;

  // construction /////////////////////////////////////////////////////////////
  
  public void initializeProcessInstance(ProcessDefinitionImpl processDefinition, String key) {
    setProcessDefinition(processDefinition);
    setActivity ( (ActivityImpl) processDefinition.getInitial() );
    this.processInstance = this;
    this.state = STATE_CREATED;
    this.key = key;

    save();
    composeIds();
    
    HistoryEvent.fire(new ProcessInstanceCreate(), this);
  }

  protected void save() {
    this.dbid = DbidGenerator.getDbidGenerator().getNextId();
    DbSession dbSession = EnvironmentImpl.getFromCurrent(DbSession.class, false);
    if (dbSession!=null) {
      dbSession.save(this);
    }
  }

  protected void composeIds() {
    this.id = IdComposer.getIdComposer().createId(processDefinition, parent, this);
  }


  // execution method : start /////////////////////////////////////////////////

  public void start() {
    if (!STATE_CREATED.equals(state)) {
      throw new JbpmException(toString()+" is already begun: "+state);
    }
    this.state = STATE_ACTIVE_ROOT;
    ExecutionImpl scopedExecution = initializeScopes();
    
    fire(Event.START, getProcessDefinition());
    if (getActivity()!=null) {
      scopedExecution.performAtomicOperation(AtomicOperation.EXECUTE_ACTIVITY);
    }
  }

  protected ExecutionImpl initializeScopes() {
    LinkedList<ActivityImpl> enteredActivities = new LinkedList<ActivityImpl>();

    ActivityImpl initial = getProcessDefinition().getInitial();
    ExecutionImpl scopedExecution = null;
    
    if (initial!=null) {
      enteredActivities.add(initial);
      ActivityImpl parentActivity = initial.getParentActivity();
      while (parentActivity!=null) {
        enteredActivities.addFirst(parentActivity);
        parentActivity = parentActivity.getParentActivity();
      }
      
      scopedExecution = this;

      initializeVariables(getProcessDefinition(), this);
      initializeTimers(getProcessDefinition());
      
      for (ActivityImpl enteredActivity: enteredActivities) {
        if (enteredActivity.isLocalScope()) {
          scopedExecution.setActivity(enteredActivity);
          scopedExecution = scopedExecution.createScope(enteredActivity);
        }
      }
      
      scopedExecution.setActivity(initial);
    }
    return scopedExecution;
  }

  public ExecutionImpl createScope(ScopeElementImpl scope) {
    ExecutionImpl child = createExecution(scope.getName());
    
    setState(STATE_INACTIVE_SCOPE);
    child.setState(STATE_ACTIVE_ROOT);
    
    // copy the current state from the child execution to the parent execution
    child.setActivity(getActivity());
    child.setTransition(getTransition());
    child.setPropagation(getPropagation());
    
    child.initializeVariables(scope, this);
    child.initializeTimers(scope);
    
    return child;
  }
  
  public ExecutionImpl destroyScope(CompositeElementImpl scope) {
    destroyTimers(scope);
    
    // copy the current state from the child execution to the parent execution
    parent.setActivity(getActivity());
    parent.setTransition(getTransition());
    parent.setPropagation(getPropagation());
    
    ExecutionImpl parentsParent = parent.getParent();
    if ( (parentsParent!=null)
         && (STATE_INACTIVE_CONCURRENT_ROOT.equals(parentsParent.getState()))
       ) {
      parent.setState(STATE_ACTIVE_CONCURRENT);
    } else {
      parent.setState(STATE_ACTIVE_ROOT);
    }
    
    // capture the parent execution cause the 
    // subsequent invocation of end() will set the parent to null
    ExecutionImpl parent = this.parent;
    
    end();

    return parent;
  }
  
  
  protected void destroyTimers(CompositeElementImpl scope) {
    TimerSession timerSession = EnvironmentImpl.getFromCurrent(TimerSession.class, false);
    if (timerSession!=null) {
      log.debug("destroying timers of "+this);
      List<Timer> timers = timerSession.findTimersByExecution(this);
      for (Timer timer: timers) {
        
        Job job = EnvironmentImpl.getFromCurrent(JobImpl.class, false);
        if (timer!=job) {
          timerSession.cancel(timer);
        }
      }
    }
  }

  
  // basic object methods /////////////////////////////////////////////////////

  public String toString() {
    if (getId()!=null) {
      return "execution["+id+"]";
    }
    if (parent==null) {
      return "process-instance";
    }
    return "execution";
  }
  
  // execution method : end ///////////////////////////////////////////////////

  public void end() {
    end(Execution.STATE_ENDED);
  }

  public void end(String state) {
    if (state==null) {
      throw new JbpmException("state is null");
    }

    if (state.equals(STATE_CREATED)
        || state.equals(STATE_ACTIVE_ROOT)
        || state.equals(STATE_ACTIVE_CONCURRENT)
        || state.equals(STATE_INACTIVE_CONCURRENT_ROOT)
        || state.equals(STATE_INACTIVE_SCOPE)
        || state.equals(STATE_INACTIVE_JOIN)
        || state.equals(STATE_SUSPENDED)
        || state.equals(STATE_ASYNC)) {
      throw new JbpmException("invalid end state: "+state);
    }
      
    if (log.isDebugEnabled()) {
      if (state==STATE_ENDED) {
        log.debug(toString()+" ends");
      } else {
        log.debug(toString()+" ends with state "+state);
      }
    }
    
    // end all child executions
   // making a copy of the executions to prevent ConcurrentMoidificationException
    List<ExecutionImpl> executionsToEnd = new ArrayList<ExecutionImpl>(executions);
    for (ExecutionImpl child: executionsToEnd) {
      child.end(state);
    }
    
    setState(state);

    this.propagation = Propagation.EXPLICIT;
    
    DbSession dbSession = EnvironmentImpl.getFromCurrent(DbSession.class, false);

    if (parent!=null) {
      parent.removeExecution(this);
      if (dbSession!=null) {
        dbSession.delete(this);
      }
      
    } else { // this is a process instance
      HistoryEvent.fire(new ProcessInstanceEnd(), this);
      fire(Event.END, getProcessDefinition());

      if (superProcessExecution!=null) {
        log.trace(toString()+" signals super process execution");
        superProcessExecution.signal();

      } else if (dbSession!=null) {
        dbSession.deleteProcessInstance(id, false);
      }
    }
  }
  
  public void end(OpenExecution executionToEnd) {
    ((ExecutionImpl)executionToEnd).end();
  }

  public void end(OpenExecution executionToEnd, String state) {
    ((ExecutionImpl)executionToEnd).end(state);
  }


  // execution method : signal ////////////////////////////////////////////////

  public void signal() {
    signal(null, (Map<String,?>)null);
  }

  public void signal(String signal) {
    signal(signal, (Map<String,?>)null);
  }
  
  public void signal(Map<String, ?> parameters) {
    signal(null, parameters);
  }

  public void signal(String signal, Map<String, ?> parameters) {
    checkActive();
    if (getProcessDefinition().isSuspended()) {
      throw new JbpmException("process definition "+getProcessDefinition().getId()+" is suspended");
    }
    propagation = Propagation.EXPLICIT;
    if (getActivity()!=null) {
      performAtomicOperation(new Signal(signal, parameters));
    } else if (transition!=null) {
      performAtomicOperation(AtomicOperation.TRANSITION_START_ACTIVITY);
    } else {
      throw new JbpmException("execution is not in a activity or in a transition");
    }
  }
  
  public void signal(Execution execution) {
    ((ExecutionImpl)execution).signal(null, (Map<String,?>)null);
  }

  public void signal(String signalName, Execution execution) {
    ((ExecutionImpl)execution).signal(signalName, (Map<String,?>)null);
  }

  public void signal(Map<String, ?> parameters, Execution execution) {
    ((ExecutionImpl)execution).signal(null, parameters);
  }

  public void signal(String signalName, Map<String, ?> parameters, Execution execution) {
    ((ExecutionImpl)execution).signal(signalName, parameters);
  }

  // execution method : take ////////////////////////////////////////////////
  
  /** @see Execution#takeDefaultTransition() */
  public void takeDefaultTransition() {
    TransitionImpl defaultTransition = getActivity().getDefaultOutgoingTransition();
    if (defaultTransition==null) {
      throw new JbpmException("there is no default transition in "+getActivity());
    }
    take(defaultTransition);
  }

  /** @see Execution#take(String) */
  public void take(String transitionName) {
    if (getActivity()==null) {
      throw new JbpmException(toString()+" is not positioned in activity");
    }
    TransitionImpl transition = findTransition(transitionName);
    if (transition==null) {
      throw new JbpmException("there is no transition "+transitionName+" in "+getActivity());
    }
    take(transition);
  }

  /** @see Execution#takeDefaultTransition() */
  public void take(Transition transition) {
    checkActive();

    setPropagation(Propagation.EXPLICIT);

    setTransition((TransitionImpl) transition);
    
    fire(Event.END, getActivity(), AtomicOperation.TRANSITION_END_ACTIVITY);
  }

  public void take(Transition transition, Execution execution) {
    ((ExecutionImpl)execution).take(transition);
  }

  // execution method : execute ///////////////////////////////////////////////

  /** @see Execution#execute(String) */
  public void execute(String activityName) {
    if (getActivity()==null) {
      throw new JbpmException("activity is null");
    }
    Activity nestedActivity = getActivity().getActivity(activityName);
    if (nestedActivity==null) {
      throw new JbpmException("activity "+activityName+" doesn't exist in "+getActivity());
    }
    execute(nestedActivity);
  }
  
  /** @see Execution#execute(Activity) */
  public void execute(Activity activity) {
    if (activity==null) {
      throw new JbpmException("activity is null");
    }
    checkActive();
    
    this.propagation = Propagation.EXPLICIT;
    performAtomicOperation(new MoveToChildActivity((ActivityImpl) activity));
  }
  
  // execution method : waitForSignal /////////////////////////////////////////
  
  public void waitForSignal() {
    propagation = Propagation.WAIT;
  }
  
  // execution method : proceed ///////////////////////////////////////////////

  public void proceed() {
    checkActive();

    // in graph based processDefinition languages we assume that a
    // default transition is available
    TransitionImpl defaultTransition = findDefaultTransition();
    if (defaultTransition!=null) {
      take(defaultTransition);
      
    // in block structured processDefinition languages we assume that 
    // there is no default transition and that there is a 
    // parent activity of the current activity
    } else {
      ActivityImpl parentActivity = getActivity().getParentActivity();

      // if there is a parent activity
      if (parentActivity!=null) {
        // propagate to the parent
        performAtomicOperation(AtomicOperation.PROPAGATE_TO_PARENT);
        
      }  else {
        // When we don't know how to proceed, i don't know if it's best to 
        // throw new PvmException("don't know how to proceed");
        // or to end the execution.  Because of convenience for testing, 
        // I opted to end the execution.
        end();
      }
    }
  }

  public void setActivity(Activity activity, Execution execution) {
    ((ExecutionImpl)execution).setActivity(activity);
  }

  public void setActivity(Activity activity) {
    setActivity((ActivityImpl) activity);
  }

  // events ///////////////////////////////////////////////////////////////////
  
  public void fire(String eventName, ObservableElement eventSource) {
    fire(eventName, (ObservableElementImpl) eventSource, null);
  }

  public void fire(String eventName, ObservableElementImpl observableElement, AtomicOperation eventCompletedOperation) {
    EventImpl event = findEvent(observableElement, eventName);
    if (event!=null) {
      setEvent(event);
      setEventSource(observableElement);
      setEventListenerIndex(0);
      setEventCompletedOperation(eventCompletedOperation);
      performAtomicOperation(AtomicOperation.EXECUTE_EVENT_LISTENER);
    } else {
      if (eventCompletedOperation!=null) {
        performAtomicOperationSync(eventCompletedOperation);
      }
    }
  }
  
  public static EventImpl findEvent(ObservableElementImpl observableElement, String eventName) {
    if (observableElement==null) {
      return null;
    }
    
    EventImpl event = observableElement.getEvent(eventName);
    if (event!=null) {
      return event;
    }
    
    return findEvent(observableElement.getParent(), eventName);
  }

  // execution : internal methods /////////////////////////////////////////////

  public void moveTo(ActivityImpl destination) {
    // move the execution to the destination
    setActivity(destination);
    transition = null;
  }

  public ExecutionImpl startActivity(ActivityImpl activity) {
    ExecutionImpl propagatingExecution = this;
    if (activity.isLocalScope()) {
      propagatingExecution = createScope(activity);
    }
    fire(Event.START, activity);
    return propagatingExecution;
  }

  public ExecutionImpl endActivity(ActivityImpl activity) {
    ExecutionImpl propagatingExecution = this;
    fire(Event.END, activity);
    if (activity.isLocalScope()) {
      propagatingExecution = destroyScope(activity);
    }
    return propagatingExecution;
  }

  // asynchronous continuations ////////////////////////////////////////////////  

  public synchronized void performAtomicOperation(AtomicOperation operation) {
    if (operation.isAsync(this)) {
      sendContinuationMessage(operation);
    } else {
      performAtomicOperationSync(operation);
    }
  }
  
  public void sendContinuationMessage(AtomicOperation operation) {
    EnvironmentImpl environment = EnvironmentImpl.getCurrent();
    MessageSession messageSession = environment.get(MessageSession.class);
    if (messageSession==null) {
      throw new JbpmException("no message-session configured to send asynchronous continuation message");
    }
    MessageImpl<?> asyncMessage = operation.createAsyncMessage(this);
    setState(Execution.STATE_ASYNC);
    messageSession.send(asyncMessage);
  }

  public void performAtomicOperationSync(AtomicOperation operation) {
    if (atomicOperations==null) {
      
      // initialise the fifo queue of atomic operations
      atomicOperations = new LinkedList<AtomicOperation>();
      atomicOperations.offer(operation);
      
      ExecutionContext originalExecutionContext = null; 
      ExecutionContext executionContext = null;
      EnvironmentImpl environment = EnvironmentImpl.getCurrent();
      if (environment!=null) {
        originalExecutionContext = (ExecutionContext) environment.getContext(Context.CONTEXTNAME_EXECUTION);
        if ( (originalExecutionContext!=null)
             && (originalExecutionContext.getExecution()==this)
           ) {
          originalExecutionContext = null;
        } else {
          executionContext = new ExecutionContext(this);
          environment.setContext(executionContext);
        }
      }
      
      try {
        while (! atomicOperations.isEmpty()) {
          AtomicOperation atomicOperation = atomicOperations.poll();
          atomicOperation.perform(this);
        }

      } catch (RuntimeException e ) {
        throw e;
      } finally {
        atomicOperations = null;
        
        if (executionContext!=null) {
          environment.removeContext(executionContext);
        }
        if (originalExecutionContext!=null) {
          environment.setContext(originalExecutionContext);
        }
      }
    } else {
      atomicOperations.offer(operation);
    }
  }

  public void handleException(ObservableElementImpl observableElement,
                              EventImpl event,
                              EventListenerReference eventListenerReference,
                              Exception exception,
                              String rethrowMessage) {
    
    List<ProcessElementImpl> processElements = new ArrayList<ProcessElementImpl>();
    if (eventListenerReference!=null) {
      processElements.add(eventListenerReference);
    }
    if (event!=null) {
      processElements.add(event);
    }
    while (observableElement!=null) {
      processElements.add(observableElement);
      observableElement = observableElement.getParent();
    }
    
    for (ProcessElementImpl processElement: processElements) {
      List<ExceptionHandlerImpl> exceptionHandlers = processElement.getExceptionHandlers();
      if (exceptionHandlers!=null) {
        for (ExceptionHandlerImpl exceptionHandler: exceptionHandlers) {
          if (exceptionHandler.matches(exception)) {
            try {
              exceptionHandler.handle(this, exception);
              return;
            } catch (Exception rethrowException) {
              if (!exceptionHandler.isRethrowMasked()) {
                exception = rethrowException;
              }
            }
            break;
          }
        }
      }
    }

    log.trace("rethrowing exception cause no exception handler for "+exception);
    ExceptionHandlerImpl.rethrow(exception, rethrowMessage+": "+exception.getMessage());
  }
  
  
  // tasks ////////////////////////////////////////////////////////////////////

  /** tasks and swimlane assignment.
   * SwimlaneDefinitionImpl is base class for TaskDefinitionImpl.
   * Both Task and Swimlane implement Assignable. */
  public void initializeAssignments(AssignableDefinitionImpl assignableDefinition, Assignable assignable) {
    String assigneeExpression = assignableDefinition.getAssigneeExpression();
    if (assigneeExpression!=null) {
      String assignee = resolveAssignmentExpression(assigneeExpression, 
                                                    assignableDefinition.getAssigneeExpressionLanguage());
      assignable.setAssignee(assignee);
      
      if (log.isTraceEnabled()) log.trace("task "+name+" assigned to "+assignee+" using expression "+assigneeExpression);
    }
    
    String candidateUsersExpression = assignableDefinition.getCandidateUsersExpression();
    if (candidateUsersExpression!=null) {
      String candidateUsers = 
          resolveAssignmentExpression(candidateUsersExpression, 
                                      assignableDefinition.getCandidateUsersExpressionLanguage());
      StringTokenizer tokenizer = new StringTokenizer(candidateUsers, ",");
      while (tokenizer.hasMoreTokens()) {
        String candidateUser = tokenizer.nextToken().trim();
        assignable.addCandidateUser(candidateUser);
      }
    }
  
    String candidateGroupsExpression = assignableDefinition.getCandidateGroupsExpression();
    if (candidateGroupsExpression!=null) {
      String candidateGroups = 
            resolveAssignmentExpression(candidateGroupsExpression, 
                                        assignableDefinition.getCandidateGroupsExpressionLanguage());
      StringTokenizer tokenizer = new StringTokenizer(candidateGroups, ",");
      while (tokenizer.hasMoreTokens()) {
        String candidateGroup = tokenizer.nextToken();
        assignable.addCandidateGroup(candidateGroup);
      }
    }
    
    UserCodeReference assignmentHandlerReference = assignableDefinition.getAssignmentHandlerReference();
    if (assignmentHandlerReference!=null) {
      AssignmentHandler assignmentHandler = (AssignmentHandler) assignmentHandlerReference.getObject(this.getProcessDefinition());
      if (assignmentHandler!=null) {
        try {
          assignmentHandler.assign(assignable, this);
        } catch (Exception e) {
          throw new JbpmException("assignment handler threw exception: " + e, e);
        }
      }
    }
  }

  protected String resolveAssignmentExpression(String expression, String expressionLanguage) {
    ScriptManager scriptManager = EnvironmentImpl.getFromCurrent(ScriptManager.class);
    Object result = scriptManager.evaluateExpression(expression, expressionLanguage);
    if ( (result ==null)
         || (result instanceof String)
       ) {
      return (String) result;
    }
    throw new JbpmException("result of assignment expression "+expression+" is "+result+" ("+result.getClass().getName()+") instead of String");
  }
  
  // swimlanes ////////////////////////////////////////////////////////////////
  
  public void addSwimlane(SwimlaneImpl swimlane) {
    swimlanes.put(swimlane.getName(), swimlane);
    swimlane.setExecution(this);
  }
  
  public SwimlaneImpl getSwimlane(String swimlaneName) {
    return swimlanes.get(swimlaneName);
  }
  
  public void removeSwimlane(SwimlaneImpl swimlane) {
      swimlanes.remove(swimlane.getName());
      swimlane.setExecution(null);
  }

  public SwimlaneImpl getInitializedSwimlane(SwimlaneDefinitionImpl swimlaneDefinition) {
    String swimlaneName = swimlaneDefinition.getName();
    SwimlaneImpl swimlane = swimlanes.get(swimlaneName);
    if (swimlane==null) {
      swimlane = createSwimlane(swimlaneName);
      initializeAssignments(swimlaneDefinition, swimlane);
    }

    return swimlane;
  }

  public SwimlaneImpl createSwimlane(String swimlaneName) {
    SwimlaneImpl swimlane = new SwimlaneImpl();
    long dbid = EnvironmentImpl.getFromCurrent(DbidGenerator.class).getNextId();
    swimlane.setDbid(dbid);
    swimlane.setName(swimlaneName);
    swimlane.setExecution(this);
    swimlanes.put(swimlaneName, swimlane);
    return swimlane;
  }
  
  // child executions /////////////////////////////////////////////////////////

  public ExecutionImpl createExecution() {
    return createExecution(null);
  }

  public ExecutionImpl createExecution(String name) {
    // when an activity calls createExecution, propagation is explicit.
    // this means that the default propagation (proceed()) will not be called 
    propagation = Propagation.EXPLICIT;

    // create new execution
    ExecutionImpl childExecution = newChildExecution();
    // initialize child execution 
    childExecution.setProcessDefinition(getProcessDefinition());
    childExecution.processInstance = this.processInstance;
    childExecution.name = name;
    
    childExecution.save();
    // make sure that child execution are saved before added to a persistent collection
    // cause of the 'assigned' id strategy, adding the childExecution to the persistent collection 
    // before the dbid is assigned will result in identifier of an instance of ExecutionImpl altered from 0 to x
    addExecution(childExecution);
    // composeIds uses the parent so the childExecution has to be added before the ids are composed
    childExecution.composeIds();

    log.debug("created "+childExecution);

    return childExecution;
  }

  protected ExecutionImpl newChildExecution() {
    return new ExecutionImpl();
  }

  public void addExecution(ExecutionImpl execution) {
    execution.setParent(this);
    executions.add(execution);
    executionsMap = null;
  }

  /** @see Execution#getExecution(String) */
  public ExecutionImpl getExecution(String name) {
    Map<String, Execution> executionsMap = getExecutionsMap();
    return (ExecutionImpl) (executionsMap!=null ? executionsMap.get(name) : null);
  }

  public void removeExecution(ExecutionImpl child) {
    if (executions.contains(child)) {
      if (executions.remove(child)) {
        child.setParent(null);

        // invalidate the executionsMap cache
        executionsMap = null;
      } else {
        throw new JbpmException(child+" is not a child execution of "+this);
      }
    }
  }

  public Map<String, Execution> getExecutionsMap() {
    if ((executionsMap==null)) {
      // initialize executionsMap cache
      executionsMap = new HashMap<String, Execution>();
      for(ExecutionImpl execution: executions) {
        String executionName = execution.getName();
        // the next test makes sure that the first execution wins
        // in case there are multiple executions with the same name
        if (! executionsMap.containsKey(executionName)) {
          executionsMap.put(executionName, execution);
        }
      }
    }
    return executionsMap;
  }
  
  public boolean hasExecution(String name) {
    return ( (getExecutionsMap()!=null)
             && executionsMap.containsKey(name)
           );
  }

  public boolean isActive(String activityName) {
    return findActiveActivityNames().contains(activityName);
  }

  public Set<String> findActiveActivityNames() {
    return addActiveActivityNames(new HashSet<String>());
  }

  protected Set<String> addActiveActivityNames(Set<String> activityNames) {
    if ( ( (state.equals(STATE_ACTIVE_ROOT)) || (state.equals(STATE_ACTIVE_CONCURRENT)) )
         && 
         (activityName!=null)
       ) {
      activityNames.add(activityName);
    }
  
    for (ExecutionImpl childExecution: executions) {
      childExecution.addActiveActivityNames(activityNames);
    }
  
    return activityNames;
  }

  public ExecutionImpl findActiveExecutionIn(String activityName) {
    if ( activityName.equals(this.activityName)
         && isActive()) {
      return this;
    }

    for (ExecutionImpl childExecution: executions) {
      ExecutionImpl found = childExecution.findActiveExecutionIn(activityName);
      if (found!=null) {
        return found;
      }
    }

    return null;
  }
  
  // system variables /////////////////////////////////////////////////////////
  
  public void createSystemVariable(String key, Object value) {
    createSystemVariable(key, value, null);
  }

  public void createSystemVariable(String key, Object value, String typeName) {
    Variable variable = createVariableObject(key, value, typeName, false);
    systemVariables.put(variable.getKey(), variable);
  }

  public void setSystemVariable(String key, Object value) {
    Variable variable = systemVariables.get(key);
    if (variable!=null) {
      log.debug("setting system variable '"+key+"' in '"+this+"' to value '"+value+"'");
      variable.setValue(value, this);
    } else {
      log.debug("creating system variable '"+key+"' in '"+this+"' to value '"+value+"'");
      createSystemVariable(key, value, null);
    }
  }
  
  public Object getSystemVariable(String key) {
    Variable variable = systemVariables.get(key);
    if (variable!=null) {
      return variable.getValue(this);
    }
    return null;
  }
  
  public boolean removeSystemVariable(String key) {
    if (systemVariables.containsKey(key)) {
      return (systemVariables.remove(key)!=null);
    }
    return false;
  }

  // sub process creation /////////////////////////////////////////////////////

  public ClientProcessInstance createSubProcessInstance(ClientProcessDefinition processDefinition) {
    return createSubProcessInstance(processDefinition, null);
  }
  
  public ClientProcessInstance createSubProcessInstance(ClientProcessDefinition processDefinition, String key) {
    if (subProcessInstance!=null) {
      throw new JbpmException(toString()+" already has a sub process instance: "+subProcessInstance);
    }
    subProcessInstance = (ExecutionImpl) processDefinition.createProcessInstance(key);
    subProcessInstance.setSuperProcessExecution(this);
    return subProcessInstance;
  }
  
  public ClientProcessInstance startSubProcessInstance(ClientProcessDefinition processDefinition) {
    return startSubProcessInstance(processDefinition, null);
  }
  
  public ClientProcessInstance startSubProcessInstance(ClientProcessDefinition processDefinition, String key) {
    createSubProcessInstance(processDefinition, key);
    subProcessInstance.start();
    return subProcessInstance;
  }

  // state mgmt ///////////////////////////////////////////////////////////////

  /** @see Execution#suspend() */
  public void suspend() {
    super.suspend();
    this.propagation = Propagation.EXPLICIT;
    DbSession dbSession = EnvironmentImpl.getFromCurrent(DbSession.class, false);
    if (dbSession!=null) {
      dbSession.cascadeExecutionSuspend(this);
    }
  }

  /** @see Execution#resume() */
  public void resume() {
    super.resume();
    DbSession hibernatePvmDbSession = EnvironmentImpl.getFromCurrent(DbSession.class, false);
    if (hibernatePvmDbSession!=null) {
      hibernatePvmDbSession.cascadeExecutionResume(this);
    }
  }

  protected void checkActive() {
    if (!isActive()) {
      throw new JbpmException(toString()+" is not active: "+state);
    }
  }
  
  public boolean isEnded() {
    if (Execution.STATE_ENDED.equals(state)) {
      return true;
    }
    if (Execution.STATE_CREATED.equals(state)) {
      return false;
    }
    if (Execution.STATE_ACTIVE_ROOT.equals(state)) {
      return false;
    }
    if (Execution.STATE_ACTIVE_CONCURRENT.equals(state)) {
      return false;
    }
    if (Execution.STATE_INACTIVE_CONCURRENT_ROOT.equals(state)) {
      return false;
    }
    if (Execution.STATE_INACTIVE_SCOPE.equals(state)) {
      return false;
    }
    if (Execution.STATE_SUSPENDED.equals(state)) {
      return false;
    }
    if (Execution.STATE_ASYNC.equals(state)) {
      return false;
    }
    return true;
  }

  ////////////////////////////////////////////////////////////////////////////////

  // overriding the ScopeInstanceImpl methods /////////////////////////////////
  
  public ScopeInstanceImpl getParentVariableScope() {
    return parent;
  }

  public ExecutionImpl getTimerExecution() {
    return this;
  }

  // overridable by process languages /////////////////////////////////////////
  
  /** by default this will use {@link ActivityImpl#findOutgoingTransition(String)} to 
   * search for the outgoing transition, which includes a search over the parent chain 
   * of the current activity.  This method allows process languages to overwrite this default 
   * implementation of the transition lookup by transitionName.*/
  protected TransitionImpl findTransition(String transitionName) {
    return getActivity().findOutgoingTransition(transitionName);
  }

  protected TransitionImpl findDefaultTransition() {
    return getActivity().findDefaultTransition();
  }
  
  // history //////////////////////////////////////////////////////////////////

  public void historyAutomatic() {
    HistoryEvent.fire(new AutomaticEnd(), this);
  }

  public void historyDecision(String transitionName) {
    HistoryEvent.fire(new DecisionEnd(transitionName), this);
  }
  
  public void historyActivityStart() {
    HistoryEvent.fire(new ActivityStart(), this);
  }

  public void historyActivityEnd() {
    HistoryEvent.fire(new ActivityEnd(), this);
  }

  public void historyActivityEnd(String transitionName) {
    HistoryEvent.fire(new ActivityEnd(transitionName), this);
  }

  // equals ///////////////////////////////////////////////////////////////////
  // hack to support comparing hibernate proxies against the real objects
  // since this always falls back to ==, we don't need to overwrite the hashcode
  public boolean equals(Object o) {
    return EqualsUtil.equals(this, o);
  }
  
  // process definition getter and setter /////////////////////////////////////
  // this getter and setter is special because persistence is based on the   // 
  // process definition id.                                                  //
  /////////////////////////////////////////////////////////////////////////////
  
  
  public ProcessDefinitionImpl getProcessDefinition() {
    if ( (processDefinition==null)
         && (processDefinitionId!=null) 
       ) {
      RepositorySession repositorySession = EnvironmentImpl.getFromCurrent(RepositorySession.class);
      processDefinition = (ProcessDefinitionImpl) repositorySession.findProcessDefinitionById(processDefinitionId);
      if (processDefinition==null) {
        throw new JbpmException("couldn't find process definition "+processDefinitionId+" in the repository");
      }
    }
    return processDefinition;
  }
  public void setProcessDefinition(ProcessDefinitionImpl processDefinition) {
    this.processDefinition = processDefinition;
    this.processDefinitionId = processDefinition.getId();
  }
  
  // activity getter and setter ///////////////////////////////////////////////
  // this getter and setter is special because persistence is based on the   // 
  // activity name.                                                          //
  /////////////////////////////////////////////////////////////////////////////
  
  public ActivityImpl getActivity() {
    if ( (activity==null)
         && (activityName!=null)
       ) {
      activity = getProcessDefinition().findActivity(activityName);
    }
    return activity;
  }
  
  public void setActivity(ActivityImpl activity) {
    this.activity = activity;
    if (activity!=null) {
      this.activityName = activity.getName();
    } else {
      this.activityName = null;
    }
  }

  public String getActivityName() {
    return activityName;
  }

  // special getters and setters /////////////////////////////////////////////////

  public boolean hasAsyncEndEvent(List<ActivityImpl> leftActivities) {
    for (ActivityImpl leftActivity : leftActivities) {
      EventImpl endEvent = leftActivity.getEvent(Event.END);
      if ( (endEvent!=null)
           && (endEvent.isAsync())
         ) {
        return true;
      }
    }
    return false;
  }

  public boolean getIsProcessInstance() {
    return parent==null;
  }

  // getters and setters for scope instance //////////////////////////////////////
  
  public ExecutionImpl getExecution() {
    return this;
  }

  // getters and setters /////////////////////////////////////////////////////////
  
  public TransitionImpl getTransition() {
    return transition;
  }
  public void setTransition(TransitionImpl transition) {
    this.transition = transition;
  }
  public EventImpl getEvent() {
    return event;
  }
  public ObservableElementImpl getEventSource() {
    return eventSource;
  }
  public Collection<ExecutionImpl> getExecutions() {
    return (Collection) executions;
  }
  public String getName() {
    return name;
  }
  public ExecutionImpl getParent() {
    return parent;
  }
  public int getPriority() {
    return priority;
  }
  public void setEvent(EventImpl event) {
    this.event = event;
  }
  public void setEventSource(ObservableElementImpl eventSource) {
    this.eventSource = eventSource;
  }
  public void setPriority(int priority) {
    this.priority = priority;
  }
  public ExecutionImpl getProcessInstance() {
    return processInstance;
  }
  public void setProcessInstance(ExecutionImpl processInstance) {
    this.processInstance = processInstance;
  }
  public String getKey() {
    return key;
  }
  public Propagation getPropagation() {
    return propagation;
  }
  public void setPropagation(Propagation propagation) {
    this.propagation = propagation;
  }
  public void setName(String name) {
    this.name = name;
  }
  public void setExecutions(Collection<ExecutionImpl> executions) {
    this.executions = executions;
  }
  public void setParent(ExecutionImpl parent) {
    this.parent = parent;
  }
  public ExecutionImpl getSuperProcessExecution() {
    return superProcessExecution;
  }
  public void setSuperProcessExecution(ExecutionImpl superProcessExecution) {
    this.superProcessExecution = superProcessExecution;
  }
  public ExecutionImpl getSubProcessInstance() {
    return subProcessInstance;
  }
  public void setSubProcessInstance(ExecutionImpl subProcessExecution) {
    this.subProcessInstance = subProcessExecution;
  }
  public void setKey(String key) {
    this.key = key;
  }
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public Long getHistoryActivityInstanceDbid() {
    return historyActivityInstanceDbid;
  }
  public void setHistoryActivityInstanceDbid(Long historyActivityInstanceDbid) {
    this.historyActivityInstanceDbid = historyActivityInstanceDbid;
  }
  public Date getHistoryActivityStart() {
    return historyActivityStart;
  }
  public void setHistoryActivityStart(Date historyActivityStart) {
    this.historyActivityStart = historyActivityStart;
  }
  public String getProcessDefinitionId() {
    return processDefinitionId;
  }
  public int getEventListenerIndex() {
    return eventListenerIndex;
  }
  public void setEventListenerIndex(int eventListenerIndex) {
    this.eventListenerIndex = eventListenerIndex;
  }
  public AtomicOperation getEventCompletedOperation() {
    return eventCompletedOperation;
  }
  public void setEventCompletedOperation(AtomicOperation eventCompletedOperation) {
    this.eventCompletedOperation = eventCompletedOperation;
  }
}