/**
 * 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.Vector;
import java.util.Hashtable;

/**
 * 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>
 */
public class Ivy implements Runnable, IvyApplicationListener {

  /**
   * the name of the application on the bus
   */
  public 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
   */
  public static String libVersion ="1.0.8";

  private boolean debug;
  private static int serial=0;	/* an unique ID for each regexp */
  private ServerSocket app;
  private IvyWatcher watch;
  private Thread server;
  private Hashtable callbacks = new Hashtable();
  private Vector clients = new Vector();
  private Vector ivyApplicationListenerList = new Vector();
  private String messages_classes[] = null;

  int applicationPort;	/* Application port number */
  boolean ivyRunning = false;
  Hashtable regexp_out = new Hashtable();
  String ready_message = null;
	
  /**
   * 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
   * @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 {
    try {
      app = new ServerSocket(0);
      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);
    watch = new IvyWatcher(this);
    ivyRunning = true;
    server = new Thread(this);
    server.start();
    watch.start(getDomain(domainbus));
  }

  /**
   * disconnects from the Ivy bus.
   *
   * TODO: it's buggy, the watcher is still there, the ivyclients are waiting
   * for one last message . Everything needs to be redesigned from scratch
   */
  public void stop() {
    traceDebug("I want to leave");
    try {
      app.close();
      ivyRunning = false;
      watch.stop();
      for (int i=0;i<clients.size();i++) {
        IvyClient client = (IvyClient)clients.elementAt(i);
	client.close("normal Ivy Stopping...");
      }
    } catch (IOException e) {
     traceDebug("IOexception Stop ");
    }
    clients.removeAllElements();
  }

  /**
   * 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;
    // TODO: il faudrait mettre une Thread emission par client */
    for ( int i = 0 ; i < clients.size(); i++ ) {
      IvyClient client = (IvyClient)clients.elementAt(i);
      count += client.sendMsg( message );
    }
    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 (int i=0;i<clients.size();i++){
      ((IvyClient)clients.elementAt(i)).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 (int i=0;i<clients.size();i++ ) {
      ((IvyClient)clients.elementAt(i)).delRegexp(id );
    }
  }

  /**
   * 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
   * it *might* be considered poor style to invoke them as the same level
   * as the others applicationListeners. This is part of the interface
   */
  public void connect(IvyClient client){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).connect(client);
    }
  }

  /* invokes the application listeners upon departure of an Ivy client
   * ibid.
   */
  public void disconnect(IvyClient client){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).disconnect(client);
    }
  }

  /* invokes the application listeners upon death of an Ivy client
   * ibid
   */
  public void die(IvyClient client, int id){
    for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ ) {
      ((IvyApplicationListener)ivyApplicationListenerList.elementAt(i)).die(client, id);
    }
    this.stop();
  }

  /* invokes the direct message callbacks
   * ibid
   */
  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);
    }
  }

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

  void addClient(Socket socket,boolean peerCalling) throws IOException {
    IvyClient client = new IvyClient(this, socket,peerCalling);
    clients.addElement(client);
  }

  void removeClient( IvyClient client ) {
	  clients.removeElement( client ); 
  }

  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;
  }


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


  /*
   * checks the "validity" of a regular expression.
   * TODO i'm not sure this is still used by anything.
   */
  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;
  }

  /*
   * TODO prevents two clients from connecting to each other at the same time
   * there is still a lingering bug here, that we could avoid with the
   * SchizoToken.
   */
  boolean checkConnected( IvyClient clnt ) {
    if ( clnt.getAppPort() == 0 ) return false;
    for ( int i = 0 ; i < clients.size(); i++ ) {
      IvyClient client = (IvyClient)clients.elementAt(i);
      if ( clnt != client && client.sameClient( clnt ) ) return true;
    }
    return false;
  }

  /*
   * the service socket thread reader. 
   */
  public void run() {	
    while(ivyRunning){
      try {
        Socket socket = app.accept();
	addClient(socket,true); // the peer called me
      } catch( IOException e ) {
        /* TODO is it a normal termination on socket close ?  */
        traceDebug("Error IvyServer exception:  "  +  e.getMessage());
	System.out.println("DEBUG TCP socket reader caught an exception " + e.getMessage());
      }
    } // while
    traceDebug("IvyServer end of trans");
  }


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

  // TODO find out if this is useful or not ...
  private void classes( String msg_classes[] ) {
    messages_classes = msg_classes;
  }

} // class Ivy

/* EOF */