/*

 * Created on Aug 13, 2003

 */

package isac.bridge;

/**

 * BridgeMain: main class for bridge, does initialization and 

 * provides logging delegate and utility function.

 * @author rgradisc

 */

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

import java.util.Properties;

import java.util.Vector;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

/**

 * Bridge main class: initializes connection to SML, 

 * starts auxillary threads 

 * @author rgradisc

 */

class BridgeMain extends JFrame {

  private String iniPath;

  private int socketPort;

  private String path;

  private String kernelExec;

  private String kernelArgs;

  private long waitMillis;

  private final static int TRANS_STRING = 1;

  private final static int TRANS_MATHML = 2;

  private int transportMode = TRANS_STRING;

  JPanel panel;

  JTextArea textArea;

  JScrollPane scrollPane;

  private Thread thread_clients2ki; // Load-Balancing: Vector

  private Thread thread_sml; // Load-Balancing: Vector

  private Thread thread_ki2clients; // Load-Balancing: Vector  

  private Thread thread_timeChecker; // Load-Balancing: Vector

  private ClientList clientList;

  private BridgeLogger bridgeLogger;

  private OutputStream smlOutput; // Load-Balancing: Vector

  private InputStream smlInput; // Load-Balancing: Vector  

  private PrintWriter smlWriter; // Load-Balancing: Vector

  private BufferedReader smlReader; // Load-Balancing: Vector 

  private Vector timeOutTimes;

  public int ignoreOutput = 0; // Load-Balancing: Vector  

  private Vector newInputs;

  private Vector answeredInputs;

  private BridgeRMI rmi;

  //---------------------------------------------------------------

  /**

   * Constructor used to set up the bridge main program

   * @param iniPath: path to initialization file

   */

  BridgeMain(String iniPath) {

    //FIXME: hack for suppressing warning messages  

    System.setProperty("java.util.prefs.syncInterval", "2000000");

    this.iniPath = iniPath;

    readProperties();

    bridgeLogger = new BridgeLogger(path);

    clientList = new ClientList();

    timeOutTimes = new Vector();

    newInputs = new Vector();

    answeredInputs = new Vector();

    setUpGUI();

    startThreadsFirstTime();    

  }

  //--------------------------------------------------------------- 

  private void setUpGUI() {

    this.setLocation(700, 250);

    panel = new JPanel();

    panel.setSize(200, 300);

    panel.setLayout(new BorderLayout());

    panel.setBackground(Color.white);

    textArea = new JTextArea();

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

    scrollPane =

      new JScrollPane(

        textArea,

        JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,

        JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

    panel.add("Center", scrollPane);

    getContentPane().add(panel);

    setTitle("Bridge Server Program");

    WindowListener l = new WindowAdapter() {

      public void windowClosing(WindowEvent e) {

        System.exit(0);

      }

    };

    addWindowListener(l);

    pack();

    this.setSize(300, 500);

    this.show();

  }

  //---------------------------------------------------------------

  private void readProperties() {

    Properties p = new Properties();

    String prop;

    try {

      p.load(new FileInputStream(iniPath));

      prop = p.getProperty("transportMode");

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

        transportMode = TRANS_STRING;

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

        transportMode = TRANS_MATHML;

      } else {

        System.out.println("INI-File: transportMode value not valid");

        System.exit(1);

      }

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

      prop = p.getProperty("socketPort");

      try {

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

      } catch (NumberFormatException e1) {

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

        System.exit(1);

      }

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

      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 {

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

      } catch (NumberFormatException e1) {

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

        System.exit(1);

      }

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

      kernelExec = p.getProperty("kernelExec");

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

    }

  }

  //---------------------------------------------------------------

  private void startSMLThread() {

    SMLThread smlThread = new SMLThread(this, kernelExec, kernelArgs);

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

    smlInput = smlThread.getInputStream();

    log(1, "SML input stream");

    smlOutput = smlThread.getOutputStream();

    log(1, "SML output stream");

    //old IO:

    smlWriter = new PrintWriter(smlOutput, true);

    //NIO:

    //    smlWriter =

    //      new PrintWriter(

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

    //old IO:

    smlReader = new BufferedReader(new InputStreamReader(smlInput));

    //NIO:

    //    smlReader =

    //      new BufferedReader(

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

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

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

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

  }

  //---------------------------------------------------------------

  private void startThreadsFirstTime() {

    startSMLThread();

    Clients2KIServer c2ki = new Clients2KIServer(this);

    thread_clients2ki = new Thread(c2ki, "java_bridge_clients2ki");

    thread_clients2ki.setDaemon(true);

    thread_clients2ki.start();

    log(1, "Clients2KI Thread started");

    KI2ClientsServer ki2c = new KI2ClientsServer(this);

    thread_ki2clients = new Thread(ki2c, "java_bridge_ki2clients");

    thread_ki2clients.setDaemon(true);

    thread_ki2clients.start();

    log(1, "KI2Clients Thread started");

    thread_timeChecker = new TimeCheckerThread(this, waitMillis);

    thread_timeChecker.setDaemon(true);

    thread_timeChecker.start();

    log(1, "TimeChecker Thread started");

  }

  //---------------------------------------------------------------

  public void restartSML() {

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

    timeOutTimes.clear();

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

    while (thread_sml.isAlive()) {

      /*       

      try {

        smlOutput.write(3);

        smlOutput.flush();

      } catch (IOException e) {        

        e.printStackTrace();

      }

      */

      thread_sml.interrupt();

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

    }

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

    try {

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

      smlReader.close();

      smlWriter.close();

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

    } catch (IOException e) {

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

    }

    startSMLThread();

    restoreStateOfKI();

  }

  //---------------------------------------------------------------

  private void restoreStateOfKI() { // pass kernelID   

    newInputs.clear(); // discard unanswered inputs: they have to be resent         

    //FIXXXME: works with only one client

    clientList.getPrintWriterOfClient(1).println("Error in Kernel");    

    ignoreOutput = answeredInputs.size();

    Iterator it = answeredInputs.iterator();

    while (it.hasNext()) {

      String input = (String)it.next();

      log(1, "user ---> " + input);

      //Resend user input to sml

      smlWriter.println(input);

      timeOutTimes.add(new Long(System.currentTimeMillis()));

    }

  }

  //---------------------------------------------------------------

  //public void startNewKernel() {

  // load balancing	

  //}

  //---------------------------------------------------------------

  protected void finalize() {

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

    }

    bridgeLogger.log(1, "finished");

    bridgeLogger.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.bridgeLogger.log(level, msg);

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

  }

  /**

   * Buffers input sent to the sml-Kernel (for later possible restart)

   * @param kernelID ID of the sml-Kernel

   * @param input input to be buffered

   */

  //----------------------------------------------------------------

  public void bufferInput(int kernelID, String input) {

    //kernelID: For use with multiple kernels

    newInputs.add(input);

  }

  /**

   * This will be called when the sml-Kernel has answered a response

   * and the answer was sent back to the user.

   */

  //----------------------------------------------------------------

  public void responseSent() {

    // Kernel works as a FIFO: first item sent to kernel is

    // always returned first.

    Object firstNew = newInputs.firstElement();

    answeredInputs.add(firstNew);

    newInputs.remove(firstNew);

  }

  //Setters and Getters: no JavaDoc needed

  public ClientList getClientList() {

    return clientList;

  }

  public BufferedReader getSmlReader() {

    return smlReader;

  }

  public PrintWriter getSmlWriter() {

    return smlWriter;

  }

  public Vector getTimeOutTimes() {

    return timeOutTimes;

  }

  public String getPath() {

    return path;

  }

  public int getSocketPort() {

    return socketPort;

  }

  /**

   * @param bridgeRMI

   */

  public void setRMI(BridgeRMI bridgeRMI) {

    rmi = bridgeRMI;

  }

  //---------------------------------------------------------------

  /**

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

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

      try {

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

      }

    }       

  }

}