/**

  * Created on Aug 13, 2003

  *

  * @author Richard Gradischnegg RG

  */

 package isac.bridge;

 /**

  * BridgeMain: main class for bridge, does initialization and provides logging delegate and utility functionality.

  *

  * @author Richard Gradischnegg RG

  * @version 1.1

  */

 import isac.gui.browser.BrowserFrame;

 import isac.util.BridgeMainPaths;

 import isac.util.FixedPortRMISocketFactory;

 import isac.util.ObjectManagerRMISocketFactory;

 import isac.util.ObjectManagerPaths;

 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.io.Serializable;

 import java.rmi.RemoteException;

 import java.rmi.server.RMISocketFactory;

 import java.util.Properties;

 import java.util.Vector;

 import javax.swing.JFrame;

 import javax.swing.JPanel;

 import javax.swing.JScrollPane;

 import javax.swing.JTextArea;

 import org.apache.log4j.Logger;

 /**

  * Bridge main class: initializes connection to SML, starts auxillary threads, handles logging mechanism

  *

  * @author rgradisc

  */

 class BridgeMain implements Serializable {

     private static final long serialVersionUID = 507L;

     private static final Logger logger = Logger.getLogger(BridgeMain.class.getName());

     private String ini_path_;

     private int socket_port_;

     private JFrame log_frame_;

     private String path_;

     private String kernel_exec_;

     private String kernel_args_;

     private long wait_millis_;

     private final static int TRANS_STRING = 1;

     private final static int TRANS_MATHML = 2;

     private int transport_mode_ = TRANS_STRING;

     JPanel panel_;

     JTextArea text_area_;

     JScrollPane scroll_pane_;

     private Thread thread_clients2kernel_;

     private Thread thread_sml_;

     private Thread thread_kernel2clients_;

     private Thread thread_time_checker_;

     private ClientList client_list_;

     private BridgeLogger bridge_logger_;

     private OutputStream sml_output_;

     private InputStream sml_input_;

     private PrintWriter sml_writer_;

     private BufferedReader sml_reader_;

     private Vector time_out_times_;

     public int ignore_output_ = 0;

     private BridgeRMI bridge_rmi_; // multiple RMI connections: Vector

     private boolean restoring_; // true = bridge is in restoring_ phase

     private boolean kernel_responding_ = true;

     /**

      * Constructor used to set up the bridge main program

      *

      * @param ini_path_: 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", "20000000000");

         if (logger.isDebugEnabled()) {

             logger.debug("BridgeMain obj.init: ini_path_=" + iniPath);

         }

         this.ini_path_ = iniPath;

         readProperties();

         bridge_logger_ = new BridgeLogger(path_);

         client_list_ = new ClientList();

         time_out_times_ = new Vector();

         setUpBridgeLog();

         startThreadsFirstTime();

     }

     private void setUpBridgeLog() {

         if (BridgeMainPaths.SHOW_GUI_LOGGER) {

             log_frame_ = new JFrame("Java<->SML");

             log_frame_.setLocation(700, 250);

             panel_ = new JPanel();

             panel_.setSize(200, 300);

             panel_.setLayout(new BorderLayout());

             panel_.setBackground(Color.white);

             text_area_ = new JTextArea();

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

             scroll_pane_ = new JScrollPane(text_area_,

                     JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,

                     JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

             panel_.add("Center", scroll_pane_);

             log_frame_.getContentPane().add(panel_);

             log_frame_.setTitle("BridgeLog Java <=> SML");

             WindowListener l = new WindowAdapter() {

                 public void windowClosing(WindowEvent e) {

                     System.exit(0);

                 }

             };

             log_frame_.addWindowListener(l);

             log_frame_.pack();

             log_frame_.setSize(300, 500);

             log_frame_.setVisible(true);

         }

     }

     // Read Bridge properties from Files

     private void readProperties() {

         Properties p = new Properties();

         String prop;

         try {

             p.load(new FileInputStream(ini_path_));

             prop = p.getProperty("transportMode");

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

                 transport_mode_ = TRANS_STRING;

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

                 transport_mode_ = TRANS_MATHML;

             } else {

                 System.out.println("INI-File: transport_mode_ (" + prop + ") value not valid");

                 System.exit(1);

             }

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

             prop = p.getProperty("socketPort");

             try {

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

             } catch (NumberFormatException e1) {

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

                 System.exit(1);

             }

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

             prop = p.getProperty("path");

             File f = new File(prop);

             if (f.isDirectory()) {

                 path_ = prop;

             } else {

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

                 System.exit(1);

             }

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

             prop = p.getProperty("waitMillis");

             try {

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

             } catch (NumberFormatException e1) {

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

                 System.exit(1);

             }

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

             kernel_exec_ = p.getProperty("kernelExec");

             kernel_args_ = p.getProperty("kernelArgs");

         } catch (FileNotFoundException e) {

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

             System.exit(1);

         } catch (IOException e) {

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

             System.exit(1);

         }

     }

     // Start sml Threads and catch in- and output-streams

     private void startSMLThread() {

         if (logger.isDebugEnabled()) {

             logger.debug("startSMLThread");

         }

         SMLThread smlThread = new SMLThread(this, kernel_exec_, kernel_args_);

         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");

         sml_input_ = smlThread.getInputStream();

         log(1, "SML input stream");

         sml_output_ = smlThread.getOutputStream();

         log(1, "SML output stream");

         // old IO:

         sml_writer_ = new PrintWriter(sml_output_, true);

         // NIO (doesn't run for some reason)

         // sml_writer_ =

         // new PrintWriter(

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

         // old IO:

         sml_reader_ = new BufferedReader(new InputStreamReader(sml_input_));

         // NIO:

         // sml_reader_ =

         // new BufferedReader(

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

         // WN120413 Isabelle2002 --> 2011

         String line_tty = "theory TTY_Communication imports Isac begin ";

         log(1, "[[to sml: " + line_tty);

         sml_writer_.println(line_tty);

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

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

     }

     private void startThreadsFirstTime() {

         if (logger.isDebugEnabled()) {

             logger.debug("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_time_checker_ = new TimeCheckerThread(this, wait_millis_);

         thread_time_checker_.setDaemon(true);

         thread_time_checker_.start();

         log(1, "TimeChecker Thread started");

     }

     public void restartSML() {

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

         time_out_times_.clear();

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

         while (thread_sml_.isAlive()) {

             thread_sml_.interrupt();

         }

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

         try {

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

             sml_reader_.close();

             sml_writer_.close();

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

         } catch (IOException e) {

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

         }

         startSMLThread();

         restoreStateOfKernel();

     }

     // This method restores the last consistent state of the kernel

     // It will be called when the sml kernel crashes

     private void restoreStateOfKernel() {

         // test first if kernel is still responding:

         // if this is the case, no further restoring_ is needed

         // dummy call to test respondablity

         // it could be also work to send a SIGINT (^C in terminal)

         // to the not reacting sml-Kernel

         // But this is not possible in Java (only with C in JNI)

         try {

             while (!kernel_responding_) {

                 sml_writer_.println("DEconstrCalcTree 0;");

                 // if the kernel responds to this instruction, it has

                 // not crashed: no restarting nescessary

                 if (sml_reader_.ready()) {

                     Thread.sleep(1000);

                     sml_reader_.readLine();

                     kernel_responding_ = true;

                 }

             }

         } catch (Exception e) {

         }

         if (!kernel_responding_) {

             log(1, "Kernel is not responding: now restarting");

             this.restoring_ = true;

         }

         /*

          * Vector inputs = bridge_rmi_.getInputs();

          */

         /*

          * Iterator it = newInputs.iterator(); while (it.hasNext()) { int

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

          * client_list_.getPrintWriterOfClient(clientID).println(" <FATALERROR>

          * </FATALERROR>"); }

          */

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

         this.restoring_ = true;

         // send empty response string to blocking client

         client_list_.getPrintWriterOfClient(bridge_rmi_.getRmiID()).println(

                 "<ISAC></ISAC>");

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

         bridge_rmi_.restoreExistingCalcTrees();

         // TODO: bridge_rmi_.deleteLastBufferInput();

         this.restoring_ = false;

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

         /*

          * ignore_output_ = 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 sml_writer_.println(input); time_out_times_.add(new

          * Long(System.currentTimeMillis())); }

          */

     }

     // Here goes the future load balancing functionality

     // public void startNewKernel() {

     // implement load balancing

     // }

     protected void finalize() throws Throwable {

         super.finalize(); // gosling p.47

         // 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..");

         }

         bridge_logger_.log(1, "finished");

         bridge_logger_.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) {

         if (BridgeMainPaths.LOG_TO_FILE) {

             this.bridge_logger_.log(level, msg);

         }

         if (BridgeMainPaths.SHOW_GUI_LOGGER) {

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

         }

     }

     public ClientList getClientList() {

         return client_list_;

     }

     public BufferedReader getSmlReader() {

         //if (logger.isDebugEnabled())

         //    logger.debug("getSmlReader x");

         return sml_reader_;

     }

     public PrintWriter getSmlWriter() {

         return sml_writer_;

     }

     public Vector getTimeOutTimes() {

         return time_out_times_;

     }

     public String getPath() {

         return path_;

     }

     public int getSocketPort() {

         return socket_port_;

     }

     public void setRMI(BridgeRMI bridgeRMI) {

         if (logger.isDebugEnabled()) {

             logger.debug("setRMI: bridge_rmi_=" + bridgeRMI);

         }

         this.bridge_rmi_ = bridgeRMI;

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

     }

     boolean isRestoring() {

         return restoring_;

     }

     void setRestoring(boolean b) {

         restoring_ = b;

     }

     /**

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

      * @see BridgeMain()

      */

     public static void main(String[] args) {

         System.out.println("Starting Bridge...");

         String ini_load_result = BridgeMainPaths.loadFromFile(args[0]);

         if (ini_load_result != null) {

             ini_load_result += BridgeMainPaths.loadFromResource(args[0]);

         }

         if (ini_load_result != null) {

             System.err.println(ini_load_result);

             System.exit(1);

         }

         // initialize bridge main part

         BridgeMain bridge = new BridgeMain(BridgeMainPaths.INI_PATH);

         try {

             // Use ObjectManagerRMISocketFactory

             // 6666 = dummy

             RMISocketFactory.setSocketFactory(new FixedPortRMISocketFactory(BridgeMainPaths.BRIDGE_RMI_PORT));

             // setup rmi connection to to the clients

             BridgeRMI rmi = new BridgeRMI(bridge, BridgeMainPaths.HOST,

                     BridgeMainPaths.BRIDGE_MAIN_PORT, BridgeMainPaths.DTD_PATH);

 //			System.out.println( rmi );

             bridge.setRMI(rmi);

         } catch (RemoteException e) {

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

             e.printStackTrace();

         } catch (IOException e) {

             System.out.println("Exception: " + e.getMessage());

             e.printStackTrace();

         }

     }

 }