package tmcsim.paramicscommunicator;

import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.Observable;
import java.util.Observer;
import java.util.Properties;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.UIManager;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import tmcsim.common.CADProtocol.PARAMICS_ACTIONS;
import tmcsim.common.CADProtocol.PARAMICS_COMM_TAGS;
import tmcsim.paramicscommunicator.FileIOUpdate.IO_TYPE;
import tmcsim.paramicscommunicator.FileRegUpdate.REG_TYPE;
import tmcsim.paramicscommunicator.gui.ParamicsCommunicatorGUI;

/**
 * ParamicsCommunicator is the main class for this module. The Paramics
 * Communicator is used to provide communication between the CAD Simulator and
 * the Paramics traffic modeler. While the application is running, data is
 * received on a socket from the CAD Simulator. Transmitted data are XML
 * documents containing information and action commands. The CAD Simulator
 * registers readers and writers with the ParamicsCommunicator. Any data read by
 * a ParamicsReader is sent back to the CAD Simulator. All data to be written by
 * a ParamicsWriter is received through the socket.<br><br>
 * The properties file for the ParamicsCommunicator class contains the following
 * data.<br>
 * <code>
 * -----------------------------------------------------------------------------<br>
 * Socket Port The port number to use for socket communication.<br>
 * Working Directory The working directory use for Paramics file
 * communication.<br>
 * Error File The target file to use for error logging.<br>
 * -----------------------------------------------------------------------------<br>
 * Example File: <br>
 * SocketPort = 4450 <br>
 * WorkingDirectory = c:\\tmc_simulator\\ <br>
 * ErrorFile = sim_mgr_error.xml <br>
 * -----------------------------------------------------------------------------<br>
 * </code>
 *
 * @author Matthew Cechini (mcechini@calpoly.edu)
 * @version $Date: 2009/04/17 16:27:46 $ $Revision: 1.7
 */
public class ParamicsCommunicator extends Observable implements Observer, Runnable
{

    private static final String CONFIG_FILE_NAME = "paramics_communicator_config.properties";
	/**
     * Error logger.
     */
    private static Logger paramLogger = Logger.getLogger("tmcsim.paramicscommunicator");

    /**
     * Enumeration containing property names.
     *
     * @author Matthew Cechini
     */
    private static enum PROPERTIES
    {

        SOCKET_PORT("SocketPort"),
        WORKING_DIR("WorkingDirectory"),
        GUI_VISIBLE("GUIvisible");
        public String name;

        private PROPERTIES(String n)
        {
            name = n;
        }
    }
    /**
     * Properties object.
     */
    private Properties paramicsCommProp = null;
    /**
     * Current working directory where files will be read and written
     */
    private String workingDirectory = null;
    /**
     * Socket used to create socket communication with the CAD Simulator.
     */
    private ServerSocket serverSocket = null;
    /**
     * Soccket used to communicate with CAD Simulator.
     */
    private Socket paramicsSocket = null;
    /**
     * Input Stream for reading data from the CAD Simulator.
     */
    private ObjectInputStream in = null;
    /**
     * Output Stream for writing data to the CAD Simulator.
     */
    private ObjectOutputStream out = null;
    /**
     * Map of all current ParamicsFileWriters referenced by I/O ID.
     */
    private TreeMap<String, ParamicsFileWriter> writers = null;
    /**
     * Map of all current ParamicsFileReaders referenced by I/O ID.
     */
    private TreeMap<String, ParamicsFileReader> readers = null;
    /**
     * The view class for the ParamicsCommunicator.
     */
    private ParamicsCommunicatorGUI theGUI;

    /**
     * Constructor. Read in the property values. If the properties file does not
     * contain a value for the working directory, open a dialog to prompt the
     * user for the path of the Paramics working directory. An empty string is
     * not accepted. A null signifies that the user pressed cancel. Prompt the
     * user to accept the cancel and exit the application if confirmed. Continue
     * until a valid directory has been entered, that exists, and append a '\'
     * to the end of the directory if necessary.
     *
     * Initialize the Sockets and begin communication.
     *
     * @param propertiesFilePath File Path of ParamicsCommunicator properties
     * file.
     */
    public ParamicsCommunicator(String propertiesFile)
    {
        paramLogger.logp(Level.INFO, "ParamicsCommunicator", "Constructor",
                "Entering ");

        writers = new TreeMap<String, ParamicsFileWriter>();
        readers = new TreeMap<String, ParamicsFileReader>();

        theGUI = new ParamicsCommunicatorGUI();
        addObserver(theGUI);
        theGUI.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        try
        {
            paramicsCommProp = new Properties();
            paramicsCommProp.load(new FileInputStream(propertiesFile));

            if (paramicsCommProp.getProperty(PROPERTIES.SOCKET_PORT.name) == null)
            {
                JOptionPane.showMessageDialog(theGUI,
                        "Properties file missing CAD Simulator Port information.",
                        "Invalid Configuration", JOptionPane.ERROR_MESSAGE);
                System.exit(0);
            } else if (paramicsCommProp.getProperty(PROPERTIES.WORKING_DIR.name) == null
                    || paramicsCommProp.getProperty(PROPERTIES.WORKING_DIR.name).length() == 0)
            {

                try
                {
                    String workingDir = null;

                    while (workingDir == null || workingDir.length() == 0)
                    {
                        workingDir = JOptionPane.showInputDialog(null,
                                "Please set the output directory for Paramics communication.",
                                "Paramics Working Directory", JOptionPane.QUESTION_MESSAGE);

                        if (workingDir == null)
                        {
                        } else if (!new File(workingDir).exists())
                        {
                            JOptionPane.showMessageDialog(null,
                                    "Directory does not exist.",
                                    "Invalid Working Directory", JOptionPane.WARNING_MESSAGE);

                            workingDir = null;
                        } else if (!new File(workingDir).isDirectory())
                        {
                            JOptionPane.showMessageDialog(null,
                                    workingDir + " is not a directory.",
                                    "Invalid Working Directory", JOptionPane.WARNING_MESSAGE);

                            workingDir = null;
                        }
                    }

                    if (workingDir.lastIndexOf("\\") != workingDir.length() - 1)
                    {
                        workingDir = workingDir + "\\";
                    }

                    paramicsCommProp.setProperty(PROPERTIES.WORKING_DIR.name, workingDir);
                    paramicsCommProp.store(new FileOutputStream(propertiesFile), "");
                } catch (IOException ioe)
                {
                    paramLogger.logp(Level.SEVERE, "ParamicsCommunicator", "Constructor",
                            "Exception in writing properties file.", ioe);
                }

            }

            workingDirectory = paramicsCommProp.getProperty(
                    PROPERTIES.WORKING_DIR.name).trim();

        } catch (Exception e)
        {
            paramLogger.logp(Level.SEVERE, "ParamicsCommunicator", "Constructor",
                    "Exception in reading properties file.", e);
        }

        // Should we display the GUI?
        String visibleProp = paramicsCommProp.getProperty(PROPERTIES.GUI_VISIBLE.name);
        // If no property was given, or if it was given and says True
        if (visibleProp == null || (visibleProp.toLowerCase().equals("true")))
        {
            theGUI = new ParamicsCommunicatorGUI(); // it sets itself visible
            addObserver(theGUI);
            theGUI.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
        }

        try
        {
            initializeSockets(Integer.parseInt(paramicsCommProp.getProperty(
                    PROPERTIES.SOCKET_PORT.name).trim()));
        } catch (Exception e)
        {
            paramLogger.logp(Level.SEVERE, "ParamicsCommunicator", "Constructor",
                    "Exception in initializing sockets.", e);
        }

    }

    /**
     * Transmits a message XML document object to the CAD Simulator.
     *
     * @param mess The ParamicsCommMessage to be transmitted.
     */
    private void write(Document mess)
    {

        synchronized (paramicsSocket)
        {
            try
            {
                out.writeObject(mess);
                out.flush();
            } catch (Exception e)
            {
                paramLogger.logp(Level.SEVERE, "ParamicsCommunicator", "write",
                        "Exception in writing to the socket.", e);
            }
        }
    }

    /**
     * Observer/Observable update method. The Paramics Communicator observers
     * registered ParamicsReaders. When messages are to be sent, they are sent
     * through this method. All messages are ParamicsCommMessage objects. Send
     * these messages to the write() method for transmission on the socket.
     */
    public void update(Observable o, Object arg)
    {

        if (arg instanceof Document)
        {
            write((Document) arg);
        }
    }

    /**
     * Runnable method. While this thread is not interrupted, read in an object
     * from the socket input stream. If an object exists, call doMessage() to
     * parse and perform the received action in the message.
     */
    public void run()
    {

        while (true)
        {
            try
            {
                doMessage((Document) in.readObject());
            } catch (SocketTimeoutException ste)
            {
                //just try again
            } catch (EOFException eofe)
            {
                paramLogger.logp(Level.SEVERE, "ParamicsCommunicator",
                        "run", "EOF Exception in reading data from the socket.", eofe);
            } catch (Exception e)
            {
                paramLogger.logp(Level.SEVERE, "ParamicsCommunicator",
                        "run", "Exception in reading data from the socket.", e);

                JOptionPane.showMessageDialog(theGUI,
                        "Connection has been lost to the CAD Simulator.  "
                        + "Paramics Communicator will now shutdown.",
                        "Dropped Connection", JOptionPane.ERROR_MESSAGE);
                break;
            }
            try
            {
                Thread.sleep(2000);
                paramLogger.logp(Level.INFO, "ParamicsCommunicator",
                        "run", "sleeping.");
            } catch (InterruptedException ex)
            {
                paramLogger.logp(Level.INFO, "ParamicsCommunicator",
                        "run", "Exception in reading data from the socket.", ex);
            }
        }


        try
        {
            in.close();
        } catch (Exception e)
        {
        }
        try
        {
            out.close();
        } catch (Exception e)
        {
        }
        try
        {
            serverSocket.close();
        } catch (Exception e)
        {
        }
        try
        {
            paramicsSocket.close();
        } catch (Exception e)
        {
        }

    }

    /**
     * Perform the action represented in XML document message received from the
     * CAD Simulator. First determine if the action is from a READER, WRITER,
     * and RESET. If the paramics action is REGISTER, add a new
     * ParamicsFileReader/Writer to the local list of readers/writers and update
     * the GUI with a FileRegUpdate object. If the paramics action is
     * UNREGISTER, remove the ParamicsFileReader/Writer from the local list of
     * readers/writers and update the GUI with a FileRegUpdate object. If RESET
     * is received, clear all readers and writers.
     *
     * @param mess Received XML document message.
     */
    private void doMessage(Document mess)
    {

        Element rootElement = mess.getDocumentElement();

        String id = null;
        String action = null;

        switch (PARAMICS_COMM_TAGS.fromString(rootElement.getNodeName()))
        {
            case READER:
                id = rootElement.getAttribute(PARAMICS_COMM_TAGS.ID.tag);
                action = rootElement.getAttribute(PARAMICS_COMM_TAGS.ACTION.tag);

                switch (PARAMICS_ACTIONS.fromString(action))
                {
                    case REGISTER:
                        Integer interval = Integer.parseInt(rootElement.getChildNodes().item(0).getTextContent());
                        String targetFile = rootElement.getChildNodes().item(1).getTextContent();

                        readers.put(id, new ParamicsFileReader(workingDirectory, id,
                                interval, targetFile));
                        readers.get(id).addObserver(this);
                        readers.get(id).addObserver(theGUI);

                        setChanged();
                        notifyObservers(new FileRegUpdate(IO_TYPE.READ,
                                REG_TYPE.REGISTER, id, targetFile, interval));
                        break;
                    case UNREGISTER:
                        readers.get(id).deleteObserver(this);
                        readers.get(id).deleteObserver(theGUI);
                        readers.remove(id);

                        setChanged();
                        notifyObservers(new FileRegUpdate(IO_TYPE.READ,
                                REG_TYPE.UNREGISTER, id, null, null));
                        break;
                }
                break;
            case WRITER:
                id = rootElement.getAttribute(PARAMICS_COMM_TAGS.ID.tag);
                action = rootElement.getAttribute(PARAMICS_COMM_TAGS.ACTION.tag);

                switch (PARAMICS_ACTIONS.fromString(action))
                {
                    case REGISTER:
                        String targetFile = rootElement.getChildNodes().item(0).getTextContent();

                        writers.put(id, new ParamicsFileWriter(id,
                                workingDirectory, targetFile));
                        writers.get(id).addObserver(theGUI);

                        setChanged();
                        notifyObservers(new FileRegUpdate(IO_TYPE.WRITE,
                                REG_TYPE.REGISTER, id, targetFile, null));
                        break;
                    case UNREGISTER:
                        writers.remove(id);

                        writers.get(id).deleteObserver(theGUI);

                        setChanged();
                        notifyObservers(new FileRegUpdate(IO_TYPE.WRITE,
                                REG_TYPE.UNREGISTER, id, null, null));
                        break;
                    case WRITE_FILE:
                        writers.get(id).writeMessage((Element) rootElement.getChildNodes().item(0));
                        break;
                }
                break;
            case RESET:
                readers.clear();
                writers.clear();
                break;
        }
    }

    /**
     * Method waits to accept a socket connection from the CAD Simulator. When a
     * connection has been established the method exits. The input and output
     * streams are created on the new socket.
     *
     * @param socketPort Socket port to use for establishing Socket
     * communication.
     * @throws IOException if there is an exception in establishing Socket
     * communication.
     */
    private void initializeSockets(Integer socketPort) throws IOException
    {

        boolean waiting = true;

        try
        {
            serverSocket = new ServerSocket(socketPort);
            //delay for accept timeout(milliseconds)
            serverSocket.setSoTimeout(10 * 1000);
        } catch (IOException ioe)
        {
            throw new IOException("Exception in creating "
                    + "the server socket on port " + socketPort);
        }

        while (waiting)
        {
            try
            {
                paramicsSocket = serverSocket.accept();
                waiting = false;
            } catch (SocketTimeoutException ste)
            {
                System.out.println("...waiting...");
                try
                {
                    Thread.sleep(2000);
                    paramLogger.logp(Level.INFO, "ParamicsCommunicator",
                            "initializeSockets", "sleeping.");
                } catch (InterruptedException ex)
                {
                    paramLogger.logp(Level.INFO, "ParamicsCommunicator",
                            "initializeSockets", "Exception exiting for socket.", ex);
                }
            } catch (IOException ioe)
            {
                throw new IOException("Exception in creating "
                        + "the receiving socket on port " + socketPort);
            }

        }


        //** out must be performed before in to unlock for connecting socket **//
        try
        {
            out = new ObjectOutputStream(paramicsSocket.getOutputStream());
            in = new ObjectInputStream(paramicsSocket.getInputStream());
        } catch (IOException ioe)
        {
            throw new IOException("Exception in creating input "
                    + "and output streams on socket.");
        }

    }

    /**
     * Construct the ParamicsCommunicator with the properties file path, either
     * from the command line arguments or default.
     *
     * @param args Command line arguments.
     */
    public static void main(String[] args) {
    	if(System.getProperty("CONFIG_DIR") == null){
        	System.setProperty("CONFIG_DIR", "config");
        }
    	
        try{

        	UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
            new Thread(new ParamicsCommunicator(System.getProperty("CONFIG_DIR") + System.getProperty("file.separator") + CONFIG_FILE_NAME)).start();
        
        } catch (Exception e) {
            paramLogger.logp(Level.SEVERE, "ParamicsCommunicator", "Main",
                    "Error occured initializing application", e);

            JOptionPane.showMessageDialog(null, e.getMessage(),
                    "Error - Program Exiting", JOptionPane.ERROR_MESSAGE);

            System.exit(-1);
        }


    }
}