/*
    Copyright (C) 2006 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.lang.reflect.Method;
  import java.util.LinkedHashSet;
  import java.util.Set;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import nextgrid.api.pem.DiscoveryEvent;
  import nextgrid.api.pem.DiscoveryListener;
  import nextgrid.api.pem.POMListener;
  import nextgrid.api.pem.ProcessEvent;
  import nextgrid.api.pem.ProcessListener;
  import nextgrid.api.pom.Process;
  import nextgrid.api.pom.ProcessException;
  
  /**
   * Base class for ProcessImpl.
   * <p>
   * Provides functionality for the management of Process Event Model listeners,
   * and notification of events.
   *
   * @author Rodrigo Ruiz
   */
  public abstract class PemHelper implements Process {
  
    /**
     * Class logger.
     */
    private static final Log LOG = LogFactory.getLog("ENACTOR");
  
    /**
     * Listeners associated to this process.
     */
    private Set<POMListener> listeners = new LinkedHashSet<POMListener>();
  
    /**
     * Lock used to control access to the listeners set.
     */
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
  
    /**
     * {@inheritDoc}
     */
    public Process copy() {
      try {
        PemHelper copy = (PemHelper)this.clone();
        copy.listeners = new LinkedHashSet<POMListener>();
        copy.lock = new ReentrantReadWriteLock(true);
  
        return copy;
      } catch (CloneNotSupportedException e) {
        throw new InternalError("Unexpected CloneNotSupported exception");
      }
    }
  
    /**
     * Adds a listener to the list.
     *
     * @param listener The one to add
     */
    public final void addListener(POMListener listener) {
      if (listener == null) {
        return;
      }
  
      lock.writeLock().lock();
      try {
        this.listeners.add(listener);
      } finally {
        lock.writeLock().unlock();
      }
    }
  
    /**
     * Removes a listener from the list.
     *
     * @param listener The one to remove
     */
    public final void removeListener(POMListener listener) {
     if (listener == null) {
       return;
     }
 
     lock.writeLock().lock();
     try {
       this.listeners.remove(listener);
     } finally {
       lock.writeLock().unlock();
     }
   }
 
   /**
    * Notifies a discovererSelected event.
    *
    * @param event The event to notify
    */
   public final void fireDiscovererSelected(DiscoveryEvent event) {
     fireEvent(DiscoveryListener.class, "discovererSelected", event);
   }
 
   /**
    * Notifies a discoveryStarting event.
    *
    * @param event The event to notify
    */
   public final void fireDiscoveryStarting(DiscoveryEvent event) {
     fireEvent(DiscoveryListener.class, "discoveryStarting", event);
   }
 
   /**
    * Notifies a discoveryFinished event.
    *
    * @param event The event to notify
    */
   public final void fireDiscoveryFinished(DiscoveryEvent event) {
     fireEvent(DiscoveryListener.class, "discoveryFinished", event);
   }
 
   /**
    * Notifies a discoveryFailed event.
    *
    * @param event The event to notify
    */
   public final void fireDiscoveryFailed(DiscoveryEvent event) {
     fireEvent(DiscoveryListener.class, "discoveryFailed", event);
   }
 
   /**
    * Notifies a processSelected event.
    *
    * @param event The event to notify
    */
   public final void fireProcessSelected(ProcessEvent event) {
     fireEvent(ProcessListener.class, "processSelected", event);
   }
 
   /**
    * Notifies a processFinished event.
    *
    * @param event The event to notify
    */
   public final void fireProcessFinished(ProcessEvent event) {
     fireEvent(ProcessListener.class, "processFinished", event);
   }
 
   /**
    * Notifies a processFailed event.
    *
    * @param event The event to notify
    */
   public final void fireProcessFailed(ProcessEvent event) {
     fireEvent(ProcessListener.class, "processFailed", event);
   }
 
   /**
    * Notifies a processFinished event.
    */
   public final void fireProcessFinished() {
     fireProcessFinished(new ProcessEvent(this));
   }
 
   /**
    * Notifies a processEvaluated event.
    */
   public final void fireProcessEvaluated() {
     fireEvent(ProcessListener.class, "processEvaluated", new ProcessEvent(this));
   }
 
   /**
    * Notifies a processStarted event.
    */
   public final void fireProcessStarted() {
     fireEvent(ProcessListener.class, "processStarted", new ProcessEvent(this));
   }
 
   /**
    * Notifies a processFailed event.
    *
    * @param e The exception
    */
   public final void fireProcessFailed(ProcessException e) {
     ProcessEvent event = new ProcessEvent(this);
     event.setException(e);
     fireProcessFailed(event);
   }
 
   /**
    * Fires an event on all listeners using reflection. This method notifies
    * all listeners registered on this process, and its ancestors.
    *
    * @param iface     The listener interface to notify
    * @param method    The name of the method to invoke
    * @param event     The event to pass as parameter
    */
   protected final void fireEvent(Class<?> iface, String method, Object event) {
     // Parameter validation
     if (iface == null || method == null || event == null) {
       return;
     }
     fireEvent(iface, method, event, true);
   }
 
   /**
    * Fires an event on all listeners using reflection. This method notifies
    * all listeners registered on this process, and its ancestors.
    * <p>
    * This method is for internal use, and should never be called directly.
    * Programmers should use {@link #fireEvent(Class, String, Object)} instead.
    *
    * @param iface     The listener interface to notify
    * @param method    The name of the method to invoke
    * @param event     The event to pass as parameter
    * @param direct    Used internally to specify that the event
    *                  is related to a child process.
    */
   @SuppressWarnings("unchecked")
   private void fireEvent(Class iface, String method, Object event,
     boolean direct) {
 
     // Get the method to invoke
     Method m;
     try {
       m = iface.getMethod(method, event.getClass());
     } catch (SecurityException e) {
       LOG.fatal("Security policy prevents access to listener", e);
       throw new RuntimeException(e);
     } catch (NoSuchMethodException e) {
       LOG.fatal("Method '" + method + "'not found in listener", e);
       throw new RuntimeException("Method '" + method + "'not found in listener",
         e);
     }
 
     // Notify all listeners
     lock.readLock().lock();
     try {
 
       // Iterate over the "local" listeners
       for (POMListener listener : listeners) {
         if (direct || listener.isListeningToDescendants()) {
           if (iface.isAssignableFrom(listener.getClass())) {
             // The listener is of the correct type
             m.invoke(listener, event);
           }
         }
       }
     } catch (Exception e) {
       LOG.error("Unexpected exception", e);
       throw new RuntimeException("Unexpected exception", e);
     } finally {
       lock.readLock().unlock();
     }
 
     // Go on with the parent node listeners
     Process parentProcess = this.getParent();
     if (parentProcess instanceof ProcessImpl) {
       ((PemHelper)parentProcess).fireEvent(iface, method, event, false);
     }
   }
 
 }