/**

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

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

        //see libisabelle/modules/examples/src/main/java/edu/tum/cs/isabelle/examples/Hello_PIDE.java

        JResources res = JResources.dumpIsabelleResources();

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

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

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

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

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

        }

    }

}