/*

 * Created on Aug 13, 2003

 */

package isac.bridge;

/**

 * BridgeMain: main class for bridge, does initialization and provides logging

 * delegate and utility functionality.

 * 

 * @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;

import org.apache.log4j.Logger;

/**

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

 * handles logging mechanism

 * 

 * @author rgradisc

 */

class BridgeMain extends JFrame {

    private String ini_path_;

    private int socket_port_;

    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;

    static Logger logger_ = Logger.getLogger(BridgeMain.class.getName());

    /**

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

        logger_.warn("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() {

        this.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_);

        getContentPane().add(panel_);

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

        WindowListener l = new WindowAdapter() {

            public void windowClosing(WindowEvent e) {

                System.exit(0);

            }

        };

        addWindowListener(l);

        pack();

        this.setSize(300, 500);

        this.show();

    }

    // 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_ 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 is not a number!");

                System.exit(1);

            }

            Float.floatToIntBits(3.14f);

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

            System.exit(1);

        } catch (IOException e) {

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

            System.exit(1);

        }

    }

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

    private void startSMLThread() {

        logger_.warn("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"));

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

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

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

    }

    private void startThreadsFirstTime() {

        logger_.warn("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) {

        this.bridge_logger_.log(level, msg);

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

    }

    public ClientList getClientList() {

        return client_list_;

    }

    public BufferedReader getSmlReader() {

        logger_.warn("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) {

        logger_.warn("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) {

        if (args.length != 4) {

            System.out

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

        } else {

            // initialize bridge main part

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

            try {

                // setup rmi connection to to the clients

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

            }

        }

    }

}