/**
 * a software bus package
 *
 * @author	François-Régis Colin
 * @author	Yannick Jestin
 * @author	<a href="http://www.tls.cena.fr/products/ivy/">http://www.tls.cena.fr/products/ivy/</a>
 *
 */
package fr.dgac.ivy ;

import java.net.*;
import java.io.*;
import java.util.*;

/**
 * A class connecting to the Ivy software bus.
 * For example:
 *<pre>
 *Ivy bus = new Ivy("Dummy agent","ready",null);
 *bus.bindMsg("(.*)",myMessageListener);
 *bus.start(null);
 *</pre>
 *
 *  CHANGELOG:
 *  1.2.1:
 *  - bus.start(null) now starts on DEFAULT_DOMAIN
 *  - added the getDomains in order to correctly display the domain list
 *  - checks if the serverThread exists before interrupting it
 *  - no has unBindMsg(String)
 *  1.2.0:
 *  - setSoTimeout is back on the server socket
 *  - added a regression test main()
 *  - clients is now a Hashtable. the deletion now works better
 *  - getIvyClientsByName allows the research of IvyClient by name
 *  - getDomain doesnt throw IvyException anymore
 *  - removed the close() disconnect(IvyClient c). Fixes a big badaboum bug
 *  - getDomain becomes public
 *  - adding the sendToSelf feature
 *  - fixed the printStackTrace upon closing of the ServerSocket after a close()
 */
public class Ivy implements Runnable {

  /**
   * the name of the application on the bus
   */
  String appName;
  /**
   * the protocol version number
   */
  public static final int PROCOCOLVERSION = 3 ;
  /**
   * the port for the UDP rendez vous, if none is supplied
   */
  public static final int DEFAULT_PORT = 2010 ;
  /**
   * the domain for the UDP rendez vous
   */
  public static final String DEFAULT_DOMAIN = "127.255.255.255:"+DEFAULT_PORT;
  /**
   * the library version, useful for development purposes only, when java is
   * invoked with -DIVY_DEBUG
   */
  public static final String libVersion ="1.2.2";

  private boolean debug;
  private static int serial=0;		/* an unique ID for each regexp */
  private static int clientSerial=0;	/* an unique ID for each IvyClient */
  private ServerSocket app;
  private Vector watchers;
  private volatile Thread serverThread; // to ensure quick communication of the end
  private Hashtable callbacks = new Hashtable();
  private Hashtable clients = new Hashtable();
  private Vector ivyApplicationListenerList = new Vector();
  private String messages_classes[] = null;
  private boolean sendToSelf = false ;
  private boolean stopped = false;
  int applicationPort;	/* Application port number */
  Hashtable regexp_out = new Hashtable();
  String ready_message = null;

  public final static int TIMEOUTLENGTH = 3000;
	
  /**
   * Readies the structures for the software bus connexion.
   *
   * All the dirty work is done un the start() method
   * @see #start
   * @param name The name of your Ivy agent on the software bus
   * @param message The hellow message you will send once ready
   * @param appcb A callback handling the notification of connexions and
   * disconnections, may be null
   */
  public Ivy( String name, String message, IvyApplicationListener appcb) {
    appName = name;
    ready_message =  message;
    debug = (System.getProperty("IVY_DEBUG")!=null);
    if ( appcb != null ) ivyApplicationListenerList.addElement( appcb );
  }

  /**
   * connects the Ivy bus to a domain or list of domains.
   *
   * <li>One thread (IvyWatcher) for each traffic rendezvous (either UDP broadcast or TCPMulticast)
   * <li>One thread (serverThread/Ivy) to accept incoming connexions on server socket
   * <li>a thread for each IvyClient when the connexion has been done
   *
   * @param domainbus a domain of the form 10.0.0:1234, it is similar to the
   * netmask without the trailing .255. This will determine the meeting point
   * of the different applications. Right now, this is done with an UDP
   * broadcast. Beware of routing problems ! You can also use a comma
   * separated list of domains.
   *
   */
  public void start(String domainbus) throws IvyException {
    if (domainbus==null) domainbus=DEFAULT_DOMAIN;
    try {
      app = new ServerSocket(0);
      app.setSoTimeout(TIMEOUTLENGTH);
      applicationPort = app.getLocalPort();
    } catch (IOException e) {
      throw new IvyException("can't open TCP service socket " + e );
    }
    traceDebug("lib: "+libVersion+" protocol: "+PROCOCOLVERSION+" TCP service open on port "+applicationPort);
    watchers = new Vector();

    Domain[] d = parseDomains(domainbus);
    // readies the rendezvous : an IvyWatcher (thread) per domain bus
    for (int index=0;index<d.length;index++){
      IvyWatcher watcher =new IvyWatcher(this,d[index].domainaddr,d[index].port);
      watchers.addElement(watcher);
    }
    serverThread = new Thread(this);
    serverThread.start();
    // sends the broadcasts and listen to incoming connexions
    for (int i=0;i<watchers.size();i++){ ((IvyWatcher)watchers.elementAt(i)).start(); }
  }

  public Domain[] parseDomains(String domainbus) {
    StringTokenizer st = new StringTokenizer(domainbus,",");
    Domain[] d = new Domain[st.countTokens()];
    int index=0;
    while  ( st.hasMoreTokens()) {
      String s = st.nextToken() ;
      d[index++]=new Domain(IvyWatcher.getDomain(s),IvyWatcher.getPort(s));
    }
    return d;
  }

  /**
   * disconnects from the Ivy bus
   */
  public void stop() {
    if (stopped ) return;
    traceDebug("beginning stopping the bus");
    try {
      // stopping the serverThread
      Thread t=serverThread;
      serverThread=null;
      if (t!=null) t.interrupt(); // The serverThread might be stopped even before having been created
      app.close();
      // stopping the IvyWatchers
      for (int i=0;i<watchers.size();i++){ ((IvyWatcher)watchers.elementAt(i)).stop(); }
      // stopping the remaining IvyClients
      for (Enumeration e=clients.elements();e.hasMoreElements();) {
        IvyClient c = (IvyClient)e.nextElement();
	c.close(true);
	removeClient(c);
      }
    } catch (IOException e) {
     traceDebug("IOexception Stop ");
    }
    traceDebug("the bus should have stopped so far");
    stopped = true;
  }

  /**
   * Toggles the sending of messages to oneself
   *
   */
  public void sendToSelf(boolean b) {sendToSelf=b;}

  /**
   * Performs a pattern matching according to everyone's regexps, and sends
   * the results to the relevant ivy agents.
   * <p><em>There is one thread for each client connected, we could also
   * create another thread each time we send a message.</em>
   * @param message A String which will be compared to the regular
   * expressions of the different clients
   * @return the number of messages actually sent
   */
  public int sendMsg( String message ) {
    int count = 0;
    // an alternate implementation would one sender thread per client
    // instead of one for all the clients. It might be a performance issue
    for ( Enumeration e=clients.elements();e.hasMoreElements();) {
      IvyClient client = (IvyClient)e.nextElement();
      count += client.sendMsg( message );
    }
    if (sendToSelf) {
      // TODO
    }
    return count;
  }

  /**
   * Subscribes to a regular expression.
   *
   * The callback will be executed with
   * the saved parameters of the regexp as arguments when a message will sent
   * by another agent. A program <em>doesn't</em> receive its own messages.
   * <p>Example:
   * <br>the Ivy agent A performs <pre>b.bindMsg("^Hello (*)",cb);</pre>
   * <br>the Ivy agent B performs <pre>b2.sendMsg("Hello world");</pre>
   * <br>a thread in A will uun the callback cb with its second argument set
   * to a array of String, with one single element, "world"
   * @param regexp a perl regular expression, groups are done with parenthesis
   * @param callback any objects implementing the IvyMessageListener
   * interface, on the AWT/Swing framework
   * @return the id of the regular expression
   */
  public int bindMsg(String regexp, IvyMessageListener callback ) {
    // creates a new binding (regexp,callback)
    Integer key = new Integer(serial++);
    regexp_out.put(key,regexp);
    callbacks.put(key,callback );
    // notifies the other clients this new regexp
    for (Enumeration e=clients.elements();e.hasMoreElements();) {
      IvyClient c = (IvyClient)e.nextElement();
      c.sendRegexp(key.intValue(),regexp);
    }
    return key.intValue();
  }

  /**
   * unsubscribes a regular expression
   *
   * @param id the id of the regular expression, returned when it was bound
   */
  public void unBindMsg(int id) throws IvyException {
    Integer key = new Integer(id);
    if ( ( regexp_out.remove(key) == null )
         || (callbacks.remove(key) == null ) ) {
      throw new IvyException("client wants to remove an unexistant regexp "+id);
    }
    for (Enumeration e=clients.elements();e.hasMoreElements();) {
      ((IvyClient)e.nextElement()).delRegexp(id );
    }
  }

  /**
   * unsubscribes a regular expression
   *
   * @return a boolean, true if the regexp existed, false otherwise or
   * whenever an exception occured during unbinding
   * @param String the string for the regular expression
   */
  public boolean unBindMsg(String re) {
    for (Enumeration e=regexp_out.keys();e.hasMoreElements();) {
      Integer k = (Integer)e.nextElement();
      if ( ((String)regexp_out.get(k)).compareTo(re) == 0) {
	try {
	  unBindMsg(k.intValue());
	} catch (IvyException ie) {
	  return false;
	}
	return true;
      }
    }
    return false;
  }

  /**
   * adds an application listener to a bus
   * @param callback is an object implementing the IvyApplicationListener
   * interface
   * @return the id of the application listener, useful if you wish to remove
   * it later
   */
  public int addApplicationListener(IvyApplicationListener callback){
    ivyApplicationListenerList.addElement(callback);
    int id = ivyApplicationListenerList.indexOf( callback );
    return id;
  }

  /**
   * removes an application listener
   * @param id the id of the application listener to remove
   */
  public void removeApplicationListener(int id){
    ivyApplicationListenerList.removeElementAt(id);
  }

  /* invokes the application listeners upon arrival of a new Ivy client */
  public void connect(IvyClient client){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).connect(client);
    }
  }

  /* invokes the application listeners upon arrival of a new Ivy client */
  void disconnectReceived(IvyClient client){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).disconnect(client);
    }
  }

  /*
   * removes a client from the list
   */
  void removeClient(IvyClient c) { clients.remove(c.getClientKey()); }

  /**
   * invokes the application listeners when we are summoned to die
   * then stops
   */
  public void dieReceived(IvyClient client, int id){
    for ( int i=0 ;i<ivyApplicationListenerList.size();i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).die(client,id);
    }
  }

  /* invokes the direct message callbacks */
  public void directMessage( IvyClient client, int id,String msgarg ){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).directMessage(client,id, msgarg);
    }
  }

  /**
   * gives the names of IvyClient(s) 
   */
  public Vector getIvyClients() {
    Vector v=new Vector();
    for (Enumeration e=clients.elements();e.hasMoreElements();) {
      v.add(e.nextElement());
    }
    return v;
  }

  /**
   * gives a list of IvyClient(s) with the name given in parameter
   *
   * @param name The name of the Ivy agent you're looking for
   */
  public Vector getIvyClientsByName(String name) {
    Vector v=new Vector();
    for (Enumeration e=clients.elements();e.hasMoreElements();) {
      IvyClient ic = (IvyClient)e.nextElement();
      if ( ((ic.getApplicationName()).compareTo(name))==0 ) v.addElement(ic);
    }
    return v;
  }

  /////////////////////////////////////////////////////////////////:
  //
  // Protected methods
  //
  /////////////////////////////////////////////////////////////////:

  void addClient(Socket socket,boolean peerCalling) throws IOException {
    IvyClient client = new IvyClient(
	this, socket,peerCalling,new Integer(clientSerial++));
    clients.put(client.getClientKey(),client);
    traceDebug(getClientNames());
  }

  void callCallback(IvyClient client, Integer key, String[] tab) throws IvyException {
    IvyMessageListener callback=(IvyMessageListener)callbacks.get(key);
    if (callback==null){
      throw new IvyException("(callCallback) Not regexp matching id "+key.intValue());
    }
    callback.receive( client, tab);
  }

  private static String[] myTokenize(String s,String separator) {
    int index=0, last=0, length=s.length();
    Vector v = new Vector();
    if (length!=0) while (true) {
	    index=s.indexOf(separator,last);
	    if (index==-1) {
		    v.add(s.substring(last,length));
		    break;
	    } else if (index<s.length()) {
		    v.add(s.substring(last,index));
		    last=index+1;
	    } else {
		    break;
	    }
    }
    String[] tab = new String[v.size()];
    v.copyInto(tab);
    return tab;
  }

  public static String getDomain(String domainbus) {
    if ( domainbus == null ) domainbus = System.getProperty("IVYBUS");
    if ( domainbus == null ) domainbus = DEFAULT_DOMAIN;
    return domainbus;
  }


  /**
   * checks the "validity" of a regular expression.
   */
  boolean CheckRegexp( String exp ) {
    boolean regexp_ok = true;
    if ( exp.startsWith( "^" )&&messages_classes!=null) {
      regexp_ok=false;
      for (int i=0 ; i < messages_classes.length;i++) {
	if (messages_classes[i].equals(exp.substring(1))) return true;
      }
    }
    return regexp_ok;
  }

  /*
   * prevents two clients from connecting to each other at the same time
   * there might still be a lingering bug here, that we could avoid with the
   * SchizoToken.
   */
  boolean checkConnected( IvyClient clnt ) {
    if ( clnt.getAppPort() == 0 ) return false;
    for (Enumeration e=clients.elements();e.hasMoreElements();) {
      IvyClient client = (IvyClient)e.nextElement();
      if ( clnt != client && client.sameClient( clnt ) ) return true;
    }
    return false;
  }

  /*
   * the service socket thread reader main loop
   */
  public void run() {	
    // System.out.println("Ivy service Thread started"); // THREADDEBUG
    Thread thisThread=Thread.currentThread();
    while(thisThread==serverThread){
      try {
        Socket socket = app.accept();
	addClient(socket,true); // the peer called me
      } catch (InterruptedIOException ie) {
	if (thisThread!=serverThread) break;
      } catch( IOException e ) {
	if (serverThread==thisThread) {
          traceDebug("Error IvyServer exception:  "  +  e.getMessage());
	  System.out.println("Ivy server socket reader caught an exception " + e.getMessage());
	  e.printStackTrace();
	} else { traceDebug("my server socket has been closed"); }
      }
    }
    traceDebug("stopping the server Thread");
    // System.out.println("Ivy service Thread stopped"); // THREADDEBUG
  }


  private void traceDebug(String s){ if (debug) System.out.println("-->ivy<-- "+s); }

  /* a small private method for debbugging purposes */
  private String getClientNames() {
    String s = appName+" clients are: ";
    for (Enumeration e=clients.elements();e.hasMoreElements();){
      s+=((IvyClient)e.nextElement()).getApplicationName()+" ";
    }
    return s;
  }

  class Domain {
    private String domainaddr;
    private int port;
    public Domain(String domainaddr,int port) {this.domainaddr=domainaddr;this.port=port;}
    public String toString() {return domainaddr+":"+port;}
    public String getDomainaddr() { return domainaddr; }
    public int getPort() { return port; }
  }


  /*
   * unitary test. Normally, running java fr.dgac.ivy.Ivy should stop in 2.3 seconds :)
   */
  public static void main(String[] args) {
    Ivy bus = new Ivy("Test Unitaire","TU ready",null);
    try {
      bus.start(null);
      try { Thread.sleep(2000); } catch (InterruptedException ie) { }
      bus.stop();
    } catch (IvyException ie) {
      ie.printStackTrace();
    }
  }
 
} // class Ivy

/* EOF */