// $Header: /home/cvs/projects/voop-itu/src/dk/itu/voop/thread/Agent.java,v 1.3 2001/04/03 20:44:25 lth Exp $

package dk.itu.voop.thread;

import java.util.Vector;
import java.util.LinkedList;
import java.util.Iterator;

public class Agent {

   public interface Listener {
      public void onSomeTaskPerformed(int result);
      public void onAnotherTaskPerformed(String argument);
      public void onTerminated();
   }

   public Agent() {
      _dispatcher.start();
   }

   public synchronized void addListener(Listener listener) {
      _listeners.add(listener);
   }

   public void requestSomeTask() {
      _dispatcher.appendTask(_dispatcher.new SomeTask());
   }

   public void requestAnotherTask(String argument) {
      _dispatcher.appendTask(_dispatcher.new AnotherTask(argument));
   }

   public void requestTermination() {
      _dispatcher.interrupt();
   }

   public void join() throws InterruptedException {
      _dispatcher.join();
   }

   private synchronized void fireOnSomeTaskPerformed(int result) {
      Iterator it = _listeners.iterator();
      while(it.hasNext()) {
         Listener listener = (Listener)it.next();
         listener.onSomeTaskPerformed(result);
      }
   }

   private synchronized void fireOnAnotherTaskPerformed(String argument) {
      Iterator it = _listeners.iterator();
      while(it.hasNext()) {
         Listener listener = (Listener)it.next();
         listener.onAnotherTaskPerformed(argument);
      }
   }

   private synchronized void fireOnTerminated() {
      Iterator it = _listeners.iterator();
      while(it.hasNext()) {
         Listener listener = (Listener)it.next();
         listener.onTerminated();
      }
   }

   private Vector _listeners = new Vector();
   private Dispatcher _dispatcher = new Dispatcher();

   private class Dispatcher extends Thread {

      public abstract class Task {
         public abstract void execute();
      }

      public class SomeTask extends Task {
         public void execute() {
            _engine.performSomeTask();
         }
      }

      public class AnotherTask extends Task {
         AnotherTask(String argument) {
            _argument = argument;
         }
         public void execute() {
            _engine.performAnotherTask(_argument);
         }
         String _argument;
      }

      public void run() {
         try {
            while(true) {
               Task task;
               synchronized(this) {
                  if(_queue.isEmpty()) {
                     wait();
                  }
                  task = (Task)_queue.removeFirst();
               }
               dispatch(task);
            }
         }
         catch(InterruptedException e) {
            // okay, we are terminating the thread
         }
         fireOnTerminated();
      }
      public synchronized void appendTask(Task task) {
         _queue.addLast(task);
         notify();
      }
      private void dispatch(Task task) {
         task.execute();
      }
      private LinkedList _queue = new LinkedList();
      private Engine _engine = new Engine();

      
      // Here is the real agent engine stuff:
      private class Engine {
         public void performSomeTask() {
            // do some thing
            int result = 42;
            fireOnSomeTaskPerformed(result);
         }
         public void performAnotherTask(String argument) {
            // do another thing
            fireOnAnotherTaskPerformed(argument);
         }
      }
      
   }
   
}