/*
    Copyright (C) 2007 Grid Systems, S.A.
   
    This library 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 library 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 library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom;
  
  import java.io.Serializable;
  import java.net.URI;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import nextgrid.api.env.DiscoveryException;
  import nextgrid.api.env.Prioritiser;
  import nextgrid.api.env.ProcessDiscoverer;
  import nextgrid.api.env.ProcessEnvironment;
  import nextgrid.api.env.ProcessSelector;
  import nextgrid.api.env.STSModule;
  import nextgrid.api.pem.POMListener;
  import nextgrid.api.pom.ProcessController;
  import nextgrid.api.pom.ProcessException;
  
  /**
   * Implementation of the {@link ProcessEnvironment} and {@link ProcessController}
   * interfaces.
   * <p>
   *
   *
   * @author Rodrigo Ruiz
   */
  public class ProcessContext implements ProcessEnvironment, ProcessController {
  
    /**
     * <code>serialVersionUID</code> attribute.
     */
    private static final long serialVersionUID = 9145702833459112038L;
  
    /**
     * Environment logger.
     */
    private static final Log ENACTOR_LOG = LogFactory.getLog("ENACTOR");
  
    /**
     * URI used to replace null values.
     */
    public static final URI NULL_ID = URI.create("#null");
  
    /**
     * Map from process ID to discoverer.
     */
    private final Map<URI, ProcessDiscoverer> discoverers
      = new ConcurrentHashMap<URI, ProcessDiscoverer>();
  
    /**
     * Map from process ID to prioritiser.
     */
    private final Map<URI, Prioritiser> prioritisers
      = new ConcurrentHashMap<URI, Prioritiser>();
  
    /**
     * Map from process ID to selector.
     */
    private final Map<URI, ProcessSelector> selectors
      = new ConcurrentHashMap<URI, ProcessSelector>();
  
    /**
     * The STS Module.
     */
    private STSModule stsmod = null;
  
    /**
     * Map from process ID to process state.
     */
    private final Map<String, Serializable> attribs
      = new ConcurrentHashMap<String, Serializable>();
  
    /**
    * Map from process ID to process listeners.
    */
   private final Map<URI, Collection<POMListener>> listeners
     = new ConcurrentHashMap<URI, Collection<POMListener>>();
 
   /**
    * Lock used to implement control operations.
    */
   private final Lock lock = new ReentrantLock();
 
   /**
    * Workflow execution state.
    */
   private State state = State.RUNNING;
 
   /**
    * Creates a new instance.
    */
   public ProcessContext() {
   }
 
   /**
    * {@inheritDoc}
    */
   public void cancel() throws ProcessException, InterruptedException {
     lock.lock();
     try {
       if (state != State.CANCELLED && state != State.FINISHED) {
         state = State.CANCELLED;
       }
     } finally {
       lock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public State getState() {
     lock.lock();
     try {
       return this.state;
     } finally {
       lock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void pause() throws ProcessException, InterruptedException {
     lock.lock();
     try {
       if (this.state == State.RUNNING) {
         this.state = State.PAUSED;
       }
     } finally {
       lock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void resume() {
     lock.lock();
     try {
       if (this.state == State.PAUSED) {
         this.state = State.RUNNING;
       }
     } finally {
       lock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void start() {
   }
 
   /**
    * {@inheritDoc}
    */
   public void join() {
   }
 
   /**
    * {@inheritDoc}
    */
   public void run() {
   }
 
   /**
    * {@inheritDoc}
    */
   public ProcessDiscoverer getDiscovererFor(URI id) throws DiscoveryException {
     ProcessDiscoverer disc = null;
     if (id != null) {
       disc = discoverers.get(id);
     }
     if (disc == null) {
       disc = discoverers.get(NULL_ID);
     }
     return disc;
   }
 
   /**
    * {@inheritDoc}
    */
   public List<ProcessDiscoverer> getDiscoverers() {
     return new ArrayList<ProcessDiscoverer>(discoverers.values());
   }
 
   /**
    * {@inheritDoc}
    */
   public Prioritiser getPrioritiserFor(URI id) {
     Prioritiser p = null;
     if (id != null) {
       p = prioritisers.get(id);
     }
     if (p == null) {
       p = prioritisers.get(NULL_ID);
     }
     return p;
   }
 
   /**
    * {@inheritDoc}
    */
   public List<Prioritiser> getPrioritisers() {
     return new ArrayList<Prioritiser>(prioritisers.values());
   }
 
   /**
    * {@inheritDoc}
    */
   public ProcessSelector getSelectorFor(URI id) {
     ProcessSelector ps = null;
     if (id != null) {
       ps = selectors.get(id);
     }
     if (ps == null) {
       ps = selectors.get(NULL_ID);
     }
     return ps;
   }
 
   /**
    * {@inheritDoc}
    */
   public List<ProcessSelector> getSelectors() {
     return new ArrayList<ProcessSelector>(selectors.values());
   }
 
   /**
    * Sets the discoverer associated to a given URI.
    *
    * @param id          A process id
    * @param discoverer  A discoverer instance
    */
   public void setDiscovererFor(URI id, ProcessDiscoverer discoverer) {
     final URI key = (id == null) ? NULL_ID : id;
     if (discoverer == null) {
       discoverers.remove(key);
     } else {
       discoverers.put(key, discoverer);
     }
   }
 
   /**
    * Sets the discoverer instance associated to all processes without
    * an explicit one.
    *
    * @param discoverer A discoverer instance
    */
   public void setDefaultDiscoverer(ProcessDiscoverer discoverer) {
     setDiscovererFor(NULL_ID, discoverer);
   }
 
   /**
    * Sets the prioritiser associated to a given URI.
    *
    * @param id           A process id
    * @param prioritiser  A prioritiser instance
    */
   public void setPrioritiser(URI id, Prioritiser prioritiser) {
     final URI key = (id == null) ? NULL_ID : id;
     if (prioritiser == null) {
       prioritisers.remove(key);
     } else {
       prioritisers.put(key, prioritiser);
     }
   }
 
   /**
    * Sets the prioritiser instance associated to all processes without
    * an explicit one.
    *
    * @param prioritiser A prioritiser instance
    */
   public void setDefaultPrioritiser(Prioritiser prioritiser) {
     setPrioritiser(NULL_ID, prioritiser);
   }
 
   /**
    * Sets the selector associated to a given URI.
    *
    * @param id        A process id
    * @param selector  A selector instance
    */
   public void setSelectorFor(URI id, ProcessSelector selector) {
     final URI key = (id == null) ? NULL_ID : id;
     if (selector == null) {
       selectors.remove(key);
     } else {
       selectors.put(key, selector);
     }
   }
 
   /**
    * Sets the selector instance associated to all processes without
    * an explicit one.
    *
    * @param selector A selector instance
    */
   public void setDefaultSelector(ProcessSelector selector) {
     setSelectorFor(NULL_ID, selector);
   }
 
   /**
    * {@inheritDoc}
    */
   public STSModule getSTSModule() {
     return this.stsmod;
   }
 
   /**
    * {@inheritDoc}
    */
   public void setSTSModule(STSModule stsmod) {
     this.stsmod = stsmod;
   }
 
   /**
    * Sets a component that could potentially implement several interfaces.
    * <p>
    * This method will register the object to all relevant interfaces it
    * implements.
    *
    * @param id  The process URI to associate the component to
    * @param obj The component instance
    */
   public void setComponentFor(URI id, Object obj) {
     if (obj != null) {
       boolean isComponent = false;
       if (obj instanceof STSModule) {
         setSTSModule((STSModule)obj);
         isComponent = true;
       }
 
       if (obj instanceof ProcessSelector) {
         setSelectorFor(id, (ProcessSelector)obj);
         isComponent = true;
       }
 
       if (obj instanceof ProcessDiscoverer) {
         setDiscovererFor(id, (ProcessDiscoverer)obj);
         isComponent = true;
       }
 
       if (obj instanceof Prioritiser) {
         setPrioritiser(id, (Prioritiser)obj);
         isComponent = true;
       }
 
       if (obj instanceof POMListener) {
         addListenersFor(id, (POMListener)obj);
         isComponent = true;
       }
 
       if (!isComponent) {
         ENACTOR_LOG.info("Object '" + obj + "' is not a component");
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public Serializable getAttribute(String id) {
     return attribs.get(id);
   }
 
   /**
    * {@inheritDoc}
    */
   public void setAttribute(String id, Serializable value) {
     attribs.put(id, value);
   }
 
   /**
    * {@inheritDoc}
    */
   public Map<String, Serializable> getAttributes() {
     return Collections.unmodifiableMap(attribs);
   }
 
   /**
    * Adds one or more listeners to a given process.
    *
    * @param id        The id of the Process to attach these listeners to
    * @param listeners The listeners to attach
    */
   public void addListenersFor(URI id, POMListener... listeners) {
     Collection<POMListener> list = this.listeners.get(id);
     if (list == null) {
       list = new HashSet<POMListener>();
       this.listeners.put(id, list);
     }
 
     for (POMListener l : listeners) {
       list.add(l);
     }
   }
 
   /**
    * Removes one or more listeners from the attachment map.
    *
    * @param id        The id of the Process to detach these listeners from
    * @param listeners The listeners to detach
    */
   public void removeListenersFrom(URI id, POMListener... listeners) {
     Collection<POMListener> list = this.listeners.get(id);
     if (list != null) {
       for (POMListener l : listeners) {
         list.remove(l);
       }
     }
   }
 
   /**
    * Clears all listeners registered in this environment instance.
    */
   public void clearListeners() {
     this.listeners.clear();
   }
 
   /**
    * Clears all listeners registered for a given Process in this environment
    * instance.
    *
    * @param id The id of the Process
    */
   public void clearListenersFor(URI id) {
     this.listeners.remove(id);
   }
 
   /**
    * {@inheritDoc}
    */
   public Collection<POMListener> getListenersFor(URI id) {
     Collection<POMListener> col = this.listeners.get(id);
     if (col == null) {
       return java.util.Collections.emptySet();
     } else {
       return new HashSet<POMListener>(col);
     }
   }
 
   // ========================================================================
   // Helper methods to be used by Process implementations
   // ========================================================================
 
   /**
    * Waits until the workflow is in RUNNING state.
    * <p>
    * As a side effect, it adds the caller thread to an internal set, which
    * is used for detecting the end of workflow executions.
    *
    * @return <tt>true</tt>  if the workflow is still active;
    *         <tt>false</tt> if it has been cancelled
    */
   boolean isRunning() {
     lock.lock();
     try {
       return state == State.RUNNING;
     } finally {
       lock.unlock();
     }
   }
 
   /**
    * Creates a Thread that executes an Enactable instance taking care
    * of exception handling.
    *
    * @param enactable The instance to execute
    * @return A Thread wrapping the instance
    */
   public EnactionWorker createWorkerThread(Enactable enactable) {
     return new EnactionWorker(this, enactable);
   }
 
 }