/**

  * 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.util.BridgeMainPaths;

 import isac.util.FixedPortRMISocketFactory;

 import info.hupel.isabelle.api.*;

 import info.hupel.isabelle.japi.*;

 import info.hupel.isabelle.setup.*;

 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.IOException;

 import java.io.Serializable;

 import java.nio.file.Path;

 import java.nio.file.Paths;

 import java.rmi.RemoteException;

 import java.rmi.server.RMISocketFactory;

 import java.util.Arrays;

 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 JFrame log_frame_;

     private String path_;

     JPanel panel_;

     JTextArea text_area_;

     JScrollPane scroll_pane_;

     private Thread thread_sml_;

     private BridgeLogger bridge_logger_;

     private BufferedReader sml_reader_;

     public int ignore_output_ = 0;

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

     private JSystem connection_to_kernel_;

     /**

      * Constructor used to set up the bridge main program

      *

      * @param log_path_: path_ to initialization file

      */

     BridgeMain(String log_path, String isabelle_home) {

         // 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 log_path =" + log_path);

         }

         Integer.valueOf(BridgeMainPaths.BRIDGE_MAIN_PORT);

         bridge_logger_ = new BridgeLogger(log_path);

         new ClientList();

         setUpBridgeLog();

         //*TTY*/startThreadsFirstTime();

 /* cp from last working version:

  *  https://hg.risc.uni-linz.ac.at/wneuper/isac/file/84f1ca6a6dd9/isac-java/src/java/isac/bridge/BridgeMain.java#l85

     85         log(1, "-->ISA: try connection with ISABELLE_HOME=\"" + isabelle_home + "\"...");

     86         Setup setup = new Setup(Paths.get(isabelle_home), JPlatform.guess(),

     87           new Version("2015"), Setup.defaultPackageName());

     88         Environment env = JSetup.makeEnvironment(setup); // without Duration

     89         Configuration config = Configuration.fromBuiltin("libisabelle_Isac");

     90         JSystem sys = JSystem.create(env, config);

     92         

     93         connection_to_kernel_ = sys;

     94         log(1, "<--ISA: connection established");

  */

 /* cp from downloaded libisabelle, current version:

 package info.hupel.isabelle.examples.java;

 import java.nio.file.Path;

 import java.nio.file.Paths;

 import java.util.Arrays;

 import info.hupel.isabelle.api.*;

 import info.hupel.isabelle.japi.*;

 import info.hupel.isabelle.setup.*;

 public class Hello_PIDE {

   public static void main(String args[]) {

     JResources res = JResources.dumpIsabelleResources();

     Configuration config = Configuration.simple("Protocol");

     Environment env = JSetup.makeEnvironment(JSetup.defaultSetup(new Version.Stable("2017")), res);

     JSystem sys = JSystem.create(env, config);

     String response = sys.invoke(Operations.HELLO, "world");

     System.out.println(response);

     sys.dispose();

   }

 }

  */

         /*PIDE*/log(1, "-->ISA: try connection with ISABELLE_HOME=\"" + isabelle_home + "\"...");

         JSystem sys = ToKernel.connect(); //does NOT yet work

         /*PIDE*/connection_to_kernel_ = sys;

         /*PIDE*/log(1, "<--ISA: connection established");

     }

     protected JSystem getConnectionToKernel(){

       return connection_to_kernel_;

     }

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

         }

     }

     // 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 BufferedReader getSmlReader() {

         //if (logger.isDebugEnabled())

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

         return sml_reader_;

     }

     public String getPath() {

         return path_;

     }

     public void setRMI(BridgeRMI bridgeRMI) {

         if (logger.isDebugEnabled()) {

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

         }

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

     }

     boolean isRestoring() {

         return restoring_;

     }

     /**

      * @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.LOG_PATH, BridgeMainPaths.ISABELLE_HOME);

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

         }

     }

 }