package org.lsst.ccs.utilities.dispatch;
   
   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   import java.util.concurrent.CopyOnWriteArrayList;
   import java.util.concurrent.ExecutorService;
   import java.util.logging.Level;
   
  /**
   *  Instances of this class creates a dynamic proxy that parallely dispatches  method call
   * to registered agents implementing an interface type.
   * <P>
   *  <B>beware</B> : if the implemented interface is itself a parameterized type
   *  no type control is exercised on these type parameters.
   *
   */
  public class ParallelDispatchProxy<I> {
  
      protected CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<Object>();
      protected I proxy;
      protected ExecutorService loop;
  
      class Invoker implements InvocationHandler {
          @Override
          public Object invoke(Object o, final Method method, final Object[] parms) {
              for (final Object goal : list) {
                  loop.submit(new Runnable() {
                      @Override
                      public void run() {
                          try {
                             method.invoke(goal, parms);
                          }catch(Exception exc) {
                              PackCst.CURLOG.log(Level.SEVERE, "dispatching to " + goal, exc);
                          }
                      }
                  });
              }
              return null;
          }
      }
  
      /**
       * prepares a generator able to deliver a Proxy object able to dispatch method calls to registered agents.
       * The methods of the interface will necessarily be of procedural nature (the return values will be dumped)
       *
       * @param interfaceType
       */
      public ParallelDispatchProxy(Class<I> interfaceType) {
          this(interfaceType, false) ;
      }
  
      /**
       * Same as <TT>ParallelDispatchProxy</TT> but specification of a single Thread dispatch can be added.
       * @param interfaceType
       * @param singleThread
       */
      public ParallelDispatchProxy(Class<I> interfaceType, boolean singleThread) {
          // not necessarily a good idea ;
          proxy = (I) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{interfaceType}, new Invoker());
          if(singleThread) {
              this.loop = PackCst.SINGLE_THREAD ;
          } else {
              this.loop = PackCst.EXECUTOR_SERVICE;
          }
      }
  
      /**
       * Same as previous but with a specified ClassLoader
       *
       * @param interfaceType
       * @param loader
       */
      public ParallelDispatchProxy(Class<I> interfaceType, ClassLoader loader) {
          this(interfaceType, loader, false) ;
      }
      public ParallelDispatchProxy(Class<I> interfaceType, ClassLoader loader, boolean singleThread) {
          proxy = (I) Proxy.newProxyInstance(loader, new Class[]{interfaceType}, new Invoker());
          if(singleThread) {
              this.loop = PackCst.SINGLE_THREAD ;
          } else {
              this.loop = PackCst.EXECUTOR_SERVICE;
          }
      }
  
      /**
       * Registers a code ready to receive "synchronous" commands
       *
       * @param executant (should implement the interface)
       */
      public <T extends I> void addExecutant(T executant) {
          list.add(executant);
      }
  
      /**
       * Remove the code from the listeners list
       *
       * @param executant
       */
     public <T extends I> void removeExecutant(T executant) {
         list.remove(executant);
     }
 
     /**
      * to be called once to get a dynamically generated proxy that will forward calls to registered agents.
      *
      * @return
      */
     public I getProxy() {
         return proxy;
     }
 }