/**

  * 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.BrowserFrameSwing;

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

 			System.out.println(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() {

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

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

 		// 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) {

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

         }

 	}

 }