//
// API de connexion au bus logiciel ivy
//
//

package fr.dgac.ivy ;

import java.net.*;
import java.io.*;
import java.util.Vector;
import java.util.Hashtable;
import java.util.StringTokenizer;

public class Ivy implements Runnable, IvyApplicationListener {

  static private boolean debug = (System.getProperty("IVY_DEBUG")!=null) ;

  public static final int DEFAULT_PORT = 2010 ;
  public static final String DEFAULT_DOMAIN = "127.255.255.255:"+DEFAULT_PORT;
  public String appName;
  private boolean ivyRunning = false;
  private String ready_message = null;
  private ServerSocket app;
  private IvyWatcher watch;
  private Thread server;

  private Hashtable regexp_out = new Hashtable();
  private Hashtable callbacks = new Hashtable();
  private Vector clients = new Vector();
  private Vector ivyApplicationListenerList = new Vector();
  private String messages_classes[] = null;
  private int myport;				/* Application port number */
	
  public synchronized boolean  ivyRunning(){ return ivyRunning; }

  public Ivy( String name, String message, IvyApplicationListener appcb) {
    appName = name;
    ready_message =  message;
    if ( appcb != null ) ivyApplicationListenerList.addElement( appcb );
  }

  void classes( String msg_classes[] ) { messages_classes = msg_classes; }

  public Hashtable getRegexpOut() { return regexp_out; }

  public String getReadyMessage() { return ready_message; }
  
  void addClient( Socket socket ) throws IOException {
    IvyClient client = new IvyClient( this, socket);
    clients.addElement( client );
  }

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

  void callCallback(IvyClient client, Integer key, String msgarg) {
    IvyMessageListener callback=(IvyMessageListener)callbacks.get(key);
    if (callback==null){
      traceDebug("(callCallback) Not regexp matching id "+key.intValue());
      return;
    }
    StringTokenizer st = new StringTokenizer(msgarg,IvyClient.EndArg);
    String args[] = new String[st.countTokens()];
    int i=0;
    while (st.hasMoreTokens()){ args[i++] = st.nextToken();}
    callback.receive( client, args );
  }

  public int getApplicationPort() { return myport; }

  public int sendMsg( String message ) {
	int count = 0;
    // envoie le message à tous les clients du bus
	// 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;
  }

  static private int serial=0;
  public int bindMsg(String regexp, IvyMessageListener callback ) {
    // associe une nouvelle regexp à un nouveau callback
    Integer key = new Integer(serial++);
    regexp_out.put(key,regexp);
    callbacks.put(key,callback );
    // indique aux autres clients la nouvelle regexp
    for (int i=0;i<clients.size();i++){
      ((IvyClient)clients.elementAt(i)).sendRegexp(key.intValue(),regexp);
    }
    return key.intValue();
  }

  public void unBindMsg(int id) {
    Integer key = new Integer(id);
    if ( ( regexp_out.remove(key) == null )
         || (callbacks.remove(key) == null ) ) {
      System.err.println("attention j'enlève une regexp inexistante");
    }
    for (int i=0;i<clients.size();i++ ) {
	    ((IvyClient)clients.elementAt(i)).delRegexp(id );
    }
  }
	/* gestion des applications listener et callback associe */
  public int addApplicationListener(IvyApplicationListener callback){
  // associe une nouvelle regexp à un nouveau callback
    ivyApplicationListenerList.addElement( callback );
    int id = ivyApplicationListenerList.indexOf( callback );
    return id;
  }
  public void removeApplicationListener( int id ) {
	  ivyApplicationListenerList.removeElementAt(id);
  }
  public void connect(IvyClient client){
	  for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ )
		{
		IvyApplicationListener listener = (IvyApplicationListener)ivyApplicationListenerList.elementAt(i);
		listener.connect(client);
		}
  }
  public void disconnect(IvyClient client){
  	  for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ )
		{
		IvyApplicationListener listener = (IvyApplicationListener)ivyApplicationListenerList.elementAt(i);
		listener.disconnect(client);
		}
  }
  public void die(IvyClient client, int id){
  	  for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ )
		{
		IvyApplicationListener listener = (IvyApplicationListener)ivyApplicationListenerList.elementAt(i);
		listener.die(client, id);
		}
  }
  public void directMessage( IvyClient client, int id,String msgarg ){
  	  for ( int i = 0 ; i < ivyApplicationListenerList.size(); i++ )
		{
		IvyApplicationListener listener = (IvyApplicationListener)ivyApplicationListenerList.elementAt(i);
		listener.directMessage(client,id, msgarg);
		}
  }

  public static String getDomain(String domainbus) throws IvyException {
	if ( domainbus == null )
		 domainbus = System.getProperty("IVYBUS");
	if ( domainbus == null )
		 domainbus = DEFAULT_DOMAIN;
	return domainbus;
  }
  public void start(String domainbus) throws IvyException {
	try {
      app = new ServerSocket(0);
      myport = app.getLocalPort();
    } catch (IOException e) {
      throw new IvyException("ne peut pas ouvrir la socket server" + e );
    }
    /* Start watcher thread */
    watch = new IvyWatcher(this);
    traceDebug("BUS TCP: "+myport);
	ivyRunning = true;
    server = new Thread( this);
	/* Start ivy server thread */
    server.start();
	/* Send ivy helo msg */
	watch.sendStart(getDomain(domainbus));
  }

  public void stop() {
	try {
	ivyRunning = false;
	watch.close(); /* Stop watcher thread */
	app.close(); /* Stop ivy server thread */
	for ( int i = 0 ; i < clients.size(); i++ ) {
		IvyClient client = (IvyClient)clients.elementAt(i);
		client.close("Ivy Stopping...");/* Stop client thread */
	}
	} catch (  IOException e ) {
      traceDebug("ioexception Stop ");
    }
	clients.removeAllElements();
  }
	
  boolean CheckRegexp( String exp ) {
    /* accepte tout par default */
    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;
  }

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

  public void run() {	
    Socket socket;
    while( ivyRunning() ) {
		try {
		socket = app.accept();
		addClient( socket );
		} catch( IOException e ) {
		/* Normal terminaison si socket close */
		/* TODO: et les autres  */
		traceDebug("Error IvyServer exception:  "  +  e.getMessage());
		}
	}
  }

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

  


} // class Ivy