/*
    * $Id: Dispatcher.java,v 1.1 2004/12/15 14:18:10 patforna Exp $
    *
    * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
    * Berne University of Applied Sciences
    * School of Engineering and Information Technology
    * All rights reserved.
    */
   package bexee.core;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import bexee.dao.BPELProcessDAO;
  import bexee.dao.DAOException;
  import bexee.dao.DAOFactory;
  import bexee.model.process.BPELProcess;
  
  /***
   * This class is used to lookup or create a <code>ProcessInstance</code> given
   * an inbound <code>BexeeMessage</code> and dispatch the message to the
   * {@link bexee.core.ProcessController}either synchronously or asynchronoulsy.
   * <p>
   * To do this, create the object and then use its {@link #dispatch()}method.
   * <p>
   * When the <code>Dispatcher</code> kicks off the
   * <code>ProcessController</code> it will know, whether a synchronous or
   * asynchronous BPEL process is to be started. Depending on that it will either
   * return right away after starting the process for an asynchronous BPEL process
   * or it will wait until the result is available for a synchronous BPEL process.
   * <p>
   * Either way the <code>ProcessController</code>'s
   * <code>processMessage()</code> method is started in a new Thread, but in
   * case of a synchronous BPEL process the <code>Dispatcher</code> will wait
   * until the result is available. This happens by obtaining a lock on the
   * <code>ProcessContext</code>, which will notify the <code>Dispatcher</code>
   * when the result is available.
   * 
   * @version $Revision: 1.1 $, $Date: 2004/12/15 14:18:10 $
   * @author Patric Fornasier
   * @author Pawel Kowalski
   */
  public class Dispatcher extends Thread {
  
      /***
       * Result when processing an asynchronous result. This might change in
       * future versions.
       */
      public static final String ASYNC_RESULT = "Processing request...";
  
      protected ProcessController controller;
  
      protected ProcessInstance instance;
  
      protected BexeeMessage message;
  
      private static Log log = LogFactory.getLog(Dispatcher.class);
  
      /***
       * Creates a new <code>Dispatcher</code> object.
       * 
       * @param message
       *            the incoming message
       */
      public Dispatcher(BexeeMessage message) {
          this.message = message;
  
          // get BPELProcess and ProcessContext for incoming message
          BPELProcess process = getBPELProcess(message);
          ProcessContext ctx = getProcessContext(message);
  
          // create instance from BPELProcess and ProcessContext
          instance = new ProcessInstance(process, ctx);
  
          // create process controller
          controller = ProcessControllerFactory.createProcessController();
      }
  
      /***
       * Calls the {@link ProcessController}s
       * {@link ProcessController#processMessage(ProcessInstance, BexeeMessage)}
       * method either synchronously or asynchronously.
       * <p>
       * Note that this method may take minutes or hours for long-running
       * synchronous processes.
       * 
       * @return the result
       * @throws DispatcherException
       *             If something went wrong dispatching the message. This can
       *             happen for example if the <code>BPELProcess</code> or the
       *             <code>ProcessContext</code> can't be found or created or if
       *             something went wrong processing the message in the
       *             <code>ProcessController</code>.
       */
      public Object dispatch() throws DispatcherException {
  
          Object result = null;
  
          // get BPEL process and process context from process instance
         ProcessContext ctx = instance.getContext();
         BPELProcess process = instance.getProcess();
 
         // check if a context was found or created
         if (ctx == null) {
             throw new DispatcherException("No context found");
         }
 
         // check if a process was found or created
         if (process == null) {
             throw new DispatcherException("No process found");
         }
 
         // start processing
         start();
 
         // if we have a synchronous process, wait until result is available
         if (process.isSynchronous()) {
             synchronized (ctx) {
                 try {
                     // wait until the process has finished and get the result
                     ctx.wait();
                     result = ctx.getResult();
                 } catch (InterruptedException e) {
                     throw new DispatcherException("Dispatcher interrupted", e);
                 }
             }
         } else {
             // TODO do we need to give something back here?
             result = ASYNC_RESULT;
         }
 
         return result;
     }
 
     /***
      * Do not use this method directly. Use {@link #dispatch()}instead.
      */
     public void run() {
         controller.processMessage(instance, message);
     }
 
     /***
      * Gets the <code>ProcessContext</code> belonging to the incoming message.
      * 
      * @param message
      *            the incoming message
      * @return a new <code>ProcessContext</code> if there is currently no
      *         process running or the <code>ProcessContext</code> instance
      *         belonging to the incoming message if there is a process running
      *         already.
      */
     protected ProcessContext getProcessContext(BexeeMessage message) {
 
         ProcessContext ctx = null;
 
         /*
          * TODO Correlation stuff for finding a running process context. Right
          * now this isn't supported, so we create a new instance each time.
          */
         ctx = new ProcessContext();
 
         return ctx;
     }
 
     /***
      * Gets the <code>BPELProcess</code> belonging to the incoming message.
      * 
      * @param message
      *            the incoming message
      * @return the <code>BPELProcess</code> that will be identified by the
      *         incoming message or null if it can't be found.
      */
     protected BPELProcess getBPELProcess(BexeeMessage message) {
 
         BPELProcess process = null;
         String name = message.getService();
 
         DAOFactory factory = DAOFactory.getInstance();
         BPELProcessDAO bpelDAO = factory.createBPELProcessDAO();
 
         try {
             process = bpelDAO.find(name);
         } catch (DAOException e) {
             log.info("Error trying to find process", e);
         }
 
         return process;
     }
 }