/*
 * 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.List;


import org.jbpm.api.JbpmException;
import org.jbpm.api.listener.EventListener;
import org.jbpm.internal.log.Log;
import org.jbpm.pvm.internal.cmd.CommandService;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.model.op.AtomicOperation;
import org.jbpm.pvm.internal.model.op.MoveToChildActivity;
import org.jbpm.pvm.internal.tx.Transaction;
import org.jbpm.pvm.internal.wire.Descriptor;

/**
 * @author Tom Baeyens
 */
public class ExceptionHandlerImpl implements Serializable {

  private static final long serialVersionUID = 1L;
  static final Log log = Log.getLog(ExceptionHandlerImpl.class.getName());

  protected long dbid;
  protected int dbversion;
  protected ProcessDefinitionImpl processDefinition;
  protected String exceptionClassName;
  protected boolean isTransactional;
  protected boolean isRethrowMasked;
  protected List<EventListenerReference> eventListenerReferences;
  protected String transitionName; // mutually exclusive with activityName
  protected String activityName;       // mutually exclusive with transitionName
  
  // construction methods /////////////////////////////////////////////////////
  
  public EventListenerReference createEventListenerReference(EventListener eventListener) {
    EventListenerReference eventListenerReference = createEventListenerReference();
    eventListenerReference.setEventListener(eventListener);
    return eventListenerReference;
  }

  public EventListenerReference createEventListenerReference(Descriptor descriptor) {
    EventListenerReference eventListenerReference = createEventListenerReference();
    eventListenerReference.setEventListenerDescriptor(descriptor);
    return eventListenerReference;
  }

  public EventListenerReference createEventListenerReference() {
    if (eventListenerReferences==null) {
      eventListenerReferences = new ArrayList<EventListenerReference>();
    }
    EventListenerReference eventListenerReference = new EventListenerReference();
    eventListenerReference.setProcessDefinition(processDefinition);
    eventListenerReferences.add(eventListenerReference);
    return eventListenerReference;
  }
  
  // runtime behaviour methods ////////////////////////////////////////////////
  
  public boolean matches(Exception exception) {
    return matches(exception.getClass());
  }

  public boolean matches(Class<?> exceptionClass) {
    if (exceptionClass==null) {
      return false;
    }
    if ( (exceptionClassName==null)
         || (exceptionClass.getName().equals(exceptionClassName)) 
       ) {
      return true;
    }
    Class<?> superClass = exceptionClass.getSuperclass();
    if (superClass!=null) {
      return matches(superClass);
    }
    return false;
  }
  
  public void handle(ExecutionImpl execution, Exception exception) {
    if (isTransactional) {
      EnvironmentImpl environment = EnvironmentImpl.getCurrent();
      Transaction transaction = (environment!=null ? environment.get(Transaction.class) : null);
      if (transaction!=null) {
        log.trace("registering exception handler to "+transaction);
        CommandService commandService = environment.get(CommandService.class);
        if (commandService==null) {
          throw new JbpmException("environment doesn't have a command service for registering transactional exception handler", exception);
        }
        ExceptionHandlerSynchronization exceptionHandlerSynchronization = new ExceptionHandlerSynchronization(
                this, execution, 
                exception,
                commandService
        );
        // registration of the synchronization is delegated to the AfterTxCompletionListener
        // to avoid a dependency on class Synchronization
        exceptionHandlerSynchronization.register(transaction);
        log.trace("registering exception handler to "+transaction);
        throw new JbpmException("transaction exception handler registered handler after transaction completed.  make sure this transaction is rolled back", exception); 
      } else {
        throw new JbpmException("no transaction present in the environment for transactional exception handler", exception);
      }
    } else {
      executeHandler(execution, exception);
    }
  }
  
  void executeHandler(ExecutionImpl execution, Exception exception) {
    if (eventListenerReferences!=null) {
      for (EventListenerReference eventListenerReference: eventListenerReferences) {
        
        EventListener eventListener = eventListenerReference.getEventListener();
        
        log.trace("executing "+eventListener+" for "+this);
        try {
          eventListener.notify(execution);
        } catch (RuntimeException e) {
          throw e;
        } catch (Exception e) {
          throw new JbpmException("couldn't execute "+eventListener, e);
        }
      }
    }
    
    if (transitionName!=null) {
      ActivityImpl activity = execution.getActivity();
      if (activity==null) {
        // If the execution is not positioned in a activity, it must be 
        // positioned in a transition.  In that case we check if the 
        // transition is present on the enclosing activity.
        
        // The weird way of getting checking and fetching the parent activity
        // is because hibernate doesn't support instanceof.  The transition-->parent
        // relation is mapped as a ProcessElementImpl.  So we can't cast it to 
        // a ActivityImpl.  Ouch.
        // The workaround is to check if the parent is equal to the 
        // process definition.  If that is not the case, we can be sure 
        // that the parent is a activity.  In that case we look up the activity 
        // from the process definition by name.  OuchOuchSquare :-)
        
        TransitionImpl transition = execution.getTransition();
        log.trace("no current activity.  searching for transition from parent of "+transition);
        if (transition!=null) {
          OpenProcessDefinition processDefinition = transition.getProcessDefinition();
          ObservableElementImpl transitionParent = transition.getParent();
          
          if ( (transitionParent!=null)
               && (! transitionParent.equals(processDefinition))
             ) {
            activity = (ActivityImpl) processDefinition.findActivity(transitionParent.getName());
          }
        }
      }
      
      if (activity!=null) {
        TransitionImpl transition = activity.findOutgoingTransition(transitionName);
        if (transition!=null) {
          log.trace(toString()+" takes transition "+transitionName);
          execution.setTransition(transition);
          execution.performAtomicOperationSync(AtomicOperation.TRANSITION_END_ACTIVITY);
        } else {
          log.info("WARNING: "+toString()+" couldn't find transition "+transitionName+" on "+activity);
        }
      } else {
        log.info("WARNING: "+toString()+" couldn't find current activity to take transition "+transitionName);
      }

    } else if (activityName!=null) {
      // execute child activity
      ActivityImpl activity = execution.getActivity();
      ActivityImpl childActivity = ( activity!=null ? activity.getActivity(activityName) : null );
      if (childActivity!=null) {
        log.trace(toString()+" takes transition "+transitionName);
        execution.performAtomicOperationSync(new MoveToChildActivity(childActivity));
      } else {
        log.info("WARNING: "+toString()+" couldn't find child activity "+activityName);
      }
    }
  }

  public static void rethrow(Exception exception, String prefixMessage) {
    log.trace("rethrowing "+exception);
    if (exception instanceof RuntimeException) {
      throw (RuntimeException) exception;
    } else {
      throw new JbpmException(prefixMessage+": "+exception.getMessage(), exception);
    }
  }

  public String toString() {
    return (exceptionClassName!=null ? "exception-handler("+exceptionClassName+")" : "exception-handler");
  }

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

  public long getDbid() {
    return dbid;
  }
  public String getExceptionClassName() {
    return exceptionClassName;
  }
  public void setExceptionClassName(String exceptionClassName) {
    this.exceptionClassName = exceptionClassName;
  }
  public boolean isTransactional() {
    return isTransactional;
  }
  public void setTransactional(boolean isTransactional) {
    this.isTransactional = isTransactional;
  }
  public String getTransitionName() {
    return transitionName;
  }
  public void setTransitionName(String transitionName) {
    this.transitionName = transitionName;
  }
  public String getActivityName() {
    return activityName;
  }
  public void setActivityName(String activityName) {
    this.activityName = activityName;
  }
  public boolean isRethrowMasked() {
    return isRethrowMasked;
  }
  public void setRethrowMasked(boolean isRethrowMasked) {
    this.isRethrowMasked = isRethrowMasked;
  }
  public List<EventListenerReference> getEventListenerReferences() {
    return eventListenerReferences;
  }
  public void setEventListenerReferences(List<EventListenerReference> eventListenerReferences) {
    this.eventListenerReferences = eventListenerReferences;
  }
  public ProcessDefinitionImpl getProcessDefinition() {
    return processDefinition;
  }
  public void setProcessDefinition(ProcessDefinitionImpl processDefinition) {
    this.processDefinition = processDefinition;
  }
}