/*

  * Created on Aug 13, 2003

  */

 package isac.bridge;

 /**

  * BridgeMain: main class for bridge, does initialization and 

  * provides logging delegate and utility function.

  * @author rgradisc

  * @version 1.1

  */

 import java.awt.BorderLayout;

 import java.awt.Color;

 import java.awt.Font;

 import java.awt.event.WindowAdapter;

 import java.awt.event.WindowEvent;

 import java.awt.event.WindowListener;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.OutputStream;

 import java.io.PrintWriter;

 import java.rmi.RemoteException;

 import java.util.Properties;

 import java.util.Vector;

 import javax.swing.JFrame;

 import javax.swing.JPanel;

 import javax.swing.JScrollPane;

 import javax.swing.JTextArea;

 /**

  * Bridge main class: initializes connection to SML, 

  * starts auxillary threads 

  * @author rgradisc

  */

 class BridgeMain extends JFrame {

   private String iniPath;

   private int socketPort;

   private String path;

   private String kernelExec;

   private String kernelArgs;

   private long waitMillis;

   private final static int TRANS_STRING = 1;

   private final static int TRANS_MATHML = 2;

   private int transportMode = TRANS_STRING;

   JPanel panel;

   JTextArea textArea;

   JScrollPane scrollPane;

   private Thread thread_clients2kernel; 

   private Thread thread_sml; 

   private Thread thread_kernel2clients;   

   private Thread thread_timeChecker; 

   private ClientList clientList;

   private BridgeLogger bridgeLogger; 

   private OutputStream smlOutput; 

   private InputStream smlInput;   

   private PrintWriter smlWriter; 

   private BufferedReader smlReader;  

   private Vector timeOutTimes;

   public int ignoreOutput = 0; 

   private BridgeRMI bridgeRMI; // multiple RMI connections: Vector

   private boolean restoring;

   //---------------------------------------------------------------

   /**

    * Constructor used to set up the bridge main program

    * @param iniPath: path to initialization file

    */

   BridgeMain(String iniPath) {

     //hack for suppressing warning messages 

     //(no longer nescessary with j2sdk1.4.2)

     //System.setProperty("java.util.prefs.syncInterval", "2000000");

     this.iniPath = iniPath;

     readProperties();

     bridgeLogger = new BridgeLogger(path);

     clientList = new ClientList();

     timeOutTimes = new Vector();

     setUpGUI();

     startThreadsFirstTime();

   }

   //--------------------------------------------------------------- 

   private void setUpGUI() {

     this.setLocation(700, 250);

     panel = new JPanel();

     panel.setSize(200, 300);

     panel.setLayout(new BorderLayout());

     panel.setBackground(Color.white);

     textArea = new JTextArea();

     textArea.setFont(new Font("Monospaced", 0, 11));

     scrollPane =

       new JScrollPane(

         textArea,

         JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,

         JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

     panel.add("Center", scrollPane);

     getContentPane().add(panel);

     setTitle("Bridge Server Program");

     WindowListener l = new WindowAdapter() {

       public void windowClosing(WindowEvent e) {

         System.exit(0);

       }

     };

     addWindowListener(l);

     pack();

     this.setSize(300, 500);

     this.show();

   }

   //---------------------------------------------------------------

   private void readProperties() {

     Properties p = new Properties();

     String prop;

     try {

       p.load(new FileInputStream(iniPath));

       prop = p.getProperty("transportMode");

       if (prop.equals("string")) {

         transportMode = TRANS_STRING;

       } else if (prop.equals("mathml")) {

         transportMode = TRANS_MATHML;

       } else {

         System.out.println("INI-File: transportMode value not valid");

         System.exit(1);

       }

       System.out.println("transportMode = " + transportMode);

       prop = p.getProperty("socketPort");

       try {

         socketPort = Integer.valueOf(prop).intValue();

       } catch (NumberFormatException e1) {

         System.out.println("INI-File: socketport is not a number!");

         System.exit(1);

       }

       System.out.println("socketPort = " + socketPort);

       prop = p.getProperty("path");

       File f = new File(prop);

       if (f.isDirectory()) {

         path = prop;

       } else {

         System.out.println("INI-File: path is not a valid directory!");

         System.exit(1);

       }

       System.out.println("path = " + path);

       prop = p.getProperty("waitMillis");

       try {

         waitMillis = Long.valueOf(prop).longValue();

       } catch (NumberFormatException e1) {

         System.out.println("INI-File: waitMillis is not a number!");

         System.exit(1);

       }

       System.out.println("waitMillis = " + waitMillis);

       kernelExec = p.getProperty("kernelExec");

       kernelArgs = p.getProperty("kernelArgs");

     } catch (FileNotFoundException e) {

       System.out.println("Couldn't open INI File");

       System.exit(1);

     } catch (IOException e) {

       System.out.println("Couldn't read INI File");

       System.exit(1);

     }

   }

   //---------------------------------------------------------------

   private void startSMLThread() {

     SMLThread smlThread = new SMLThread(this, kernelExec, kernelArgs);

     thread_sml = new Thread(smlThread, "java_bridge_execution");

     thread_sml.setDaemon(true);

     // daemon threads: discontinue running after main application is finished    

     log(1, "SML Execution Thread starting...");

     thread_sml.start();

     log(1, "SML Execution Thread started");

     smlInput = smlThread.getInputStream();

     log(1, "SML input stream");

     smlOutput = smlThread.getOutputStream();

     log(1, "SML output stream");

     //old IO:

     smlWriter = new PrintWriter(smlOutput, true);

     //NIO:

     //    smlWriter =

     //      new PrintWriter(

     //        Channels.newWriter(Channels.newChannel(smlOutput), "ISO-8859-1"));

     //old IO:

     smlReader = new BufferedReader(new InputStreamReader(smlInput));

     //NIO:

     //    smlReader =

     //      new BufferedReader(

     //        Channels.newReader(Channels.newChannel(smlInput), "ISO-8859-1"));

     log(1, "SML in/output streams fetched");

     //log(1, smlWriter.toString());

     //log(1, smlReader.toString());

   }

   //---------------------------------------------------------------

   private void startThreadsFirstTime() {

     startSMLThread();

     Clients2KernelServer c2k = new Clients2KernelServer(this);

     thread_clients2kernel = new Thread(c2k, "java_bridge_clients2kernel");

     thread_clients2kernel.setDaemon(true);

     thread_clients2kernel.start();

     log(1, "Clients2Kernel Thread started");

     Kernel2ClientsServer k2c = new Kernel2ClientsServer(this);

     thread_kernel2clients = new Thread(k2c, "java_bridge_kernel2clients");

     thread_kernel2clients.setDaemon(true);

     thread_kernel2clients.start();

     log(1, "Kernel2Clients Thread started");

     thread_timeChecker = new TimeCheckerThread(this, waitMillis);

     thread_timeChecker.setDaemon(true);

     thread_timeChecker.start();

     log(1, "TimeChecker Thread started");

   }

   //---------------------------------------------------------------

   public void restartSML() {

     log(1, "No response from sml-kernel: restart");

     timeOutTimes.clear();

     log(1, "Trying to kill sml-kernel...");

     while (thread_sml.isAlive()) {

       /*       

       try {

         smlOutput.write(3);

         smlOutput.flush();

       } catch (IOException e) {        

         e.printStackTrace();

       }

       */

       thread_sml.interrupt();

       //log(1, "Trying to kill sml-kernel");

     }

     log(1, "Successfully killed sml-kernel");

     try {

       log(1, "BridgeMain: trying to close reader/writer");

       smlReader.close();

       smlWriter.close();

       log(1, "BridgeMain: closed reader/writer");

     } catch (IOException e) {

       log(1, "BridgeMain: couldn't close reader/writer");

     }

     startSMLThread();

     restoreStateOfKernel();

   }

   //---------------------------------------------------------------

   // this method will be called when the sml kernel crashes   

   private void restoreStateOfKernel() {    

   	/*

   	Vector inputs = bridgeRMI.getInputs();

   	*/

   	/*Iterator it = newInputs.iterator();  

   	while (it.hasNext()) {

 	  int clientID = ((ClientInput)it.next()).getClientID();

 	  clientList.getPrintWriterOfClient(clientID).println("<FATALERROR></FATALERROR>");

   	}*/	

   	log(1, "------ now restoring state of kernel");

   	this.restoring = true;

 	clientList.getPrintWriterOfClient(bridgeRMI.getRmiID()).println("<ISAC></ISAC>");    

 	log(1, "------ restoreExistingCalcTrees()");

 	bridgeRMI.restoreExistingCalcTrees();  

 	this.restoring = false;  

 	log(1, "------ done restoring state of kernel");

 	/*ignoreOutput = inputs.size();

     Iterator it = inputs.iterator();    

     while (it.hasNext()) {

       ClientInput clientInput = (ClientInput)it.next();

       String input = clientInput.getInputLine();

       log(1, "user "+clientInput.getClientID()+" ---> " + input);

       //Resend user input to sml

       smlWriter.println(input);

       timeOutTimes.add(new Long(System.currentTimeMillis()));

     }	

     */

   }

   //---------------------------------------------------------------

   //public void startNewKernel() {

   // load balancing	

   //}

   //---------------------------------------------------------------

   protected void finalize() {

     //Objects created in run method are finalized when 

     //program terminates and thread exits

     while (thread_sml.isAlive()) {

       thread_sml.interrupt();

       log(1, "waiting for SML thread to quit..");

     }

     bridgeLogger.log(1, "finished");

     bridgeLogger.close();    

   }

   /**

    * Log a message with a specified severity level

    * @param level severity level

    * @param msg the message to be logged

    */

   //---------------------------------------------------------------

   public void log(int level, String msg) {

     this.bridgeLogger.log(level, msg);

     this.textArea.append(msg + "\n");

   } 

   public ClientList getClientList() {

     return clientList;

   }

   public BufferedReader getSmlReader() {

     return smlReader;

   }

   public PrintWriter getSmlWriter() {

     return smlWriter;

   }

   public Vector getTimeOutTimes() {

     return timeOutTimes;

   }

   public String getPath() {

     return path;

   }

   public int getSocketPort() {

     return socketPort;

   }

   public void setRMI(BridgeRMI bridgeRMI) {

     this.bridgeRMI = bridgeRMI;

     bridgeRMI.setRmiID(1); //only one BridgeRMI used so far

   }

   //---------------------------------------------------------------

   /**

    * @param args commandline arguments (exactly 4 expected: _iniPath _host _port _dtdPath)

    * @see BridgeMain()

    */

   public static void main(String[] args) {

     if (args.length != 4) {

       System.out.println("Usage: java BridgeMain _iniPath _host _port _dtdPath");

     } else {

       BridgeMain bridge = new BridgeMain(args[0]);

       try {

         BridgeRMI rmi = new BridgeRMI(bridge, args[1], Integer.parseInt(args[2]), args[3]);

         bridge.setRMI(rmi);

       } catch (RemoteException e) {

         System.out.println("Could not instantiate RMI: exiting");

         e.printStackTrace();

       }

     }

   }  

   boolean isRestoring() {

     return restoring;

   }

   void setRestoring(boolean b) {

   	restoring = b;

   }

 }