package org.lidar;

import java.io.InputStream;
import java.io.OutputStream;
import javax.comm.*;
import java.util.*;
import org.apache.commons.configuration.XMLConfiguration;
import org.lidar.api.Management;

/**
 * Serial port communication
 * @author Andrej Cimpersek
 */
public class Serial {

    private boolean isOpened = false;
    private String deviceName;
    private String portName;
    private Enumeration portIdentifiers;
    private CommPortIdentifier portId;
    private SerialPort port;
    protected InputStream inputStream;
    protected OutputStream outputStream;
    private int baudRate, dataBits, stopBits, parity;
    private XMLConfiguration configuration;

    public Serial(String deviceName) {
        configuration = Config.getConfiguration();
        this.portName = configuration.getString(String.format("devices.%s.port", deviceName));
        this.baudRate = configuration.getInt(String.format("devices.%s.baudRate", deviceName));
        this.dataBits = configuration.getInt(String.format("devices.%s.dataBits", deviceName));
        this.stopBits = configuration.getInt(String.format("devices.%s.stopBits", deviceName));
        this.parity = configuration.getInt(String.format("devices.%s.parity", deviceName));
    }

    /**
     * Check each port identifier if
     *   (a) it indicates a serial (not a parallel) port, and
     *   (b) matches the desired name.
     * @return boolean
     */
    protected boolean identfy() {
        this.portIdentifiers = CommPortIdentifier.getPortIdentifiers();
        this.portId = null;  // will be set if port found
        while (portIdentifiers.hasMoreElements()) {
            CommPortIdentifier pid = (CommPortIdentifier) portIdentifiers.nextElement();
            if (pid.getPortType() == CommPortIdentifier.PORT_SERIAL && pid.getName().equals(this.portName)) {
                this.portId = pid;
                return true;
            }
        }
        return false;
    }

    /**
     * Destructor - close port
     */
    @Override()
    protected void finalize() throws Throwable {
        closePort();
    }

    public boolean acquirePort() {
        if (this.portId == null) {
            return false;
        }
        // Use port identifier for acquiring the port
        try {
            this.port = (SerialPort) this.portId.open(
                    this.deviceName, // Name of the application asking for the port
                    10000 // Wait max. 10 sec. to acquire port
                    );
        } catch (PortInUseException e) {
            return false;
        }

        return true;
    }

    public boolean openPort() {
        if (!acquirePort()) {
            return false;
        }
        closePort();
        try {
            this.port.setSerialPortParams(this.baudRate, this.dataBits, this.stopBits, this.parity);
            this.port.removeEventListener();
            this.port.addEventListener(new SerialPortEventListener() {

                public void serialEvent(SerialPortEvent event) {
                    switch (event.getEventType()) {
                        case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                            onOutputBufferEmpty(event);
                            break;

                        case SerialPortEvent.DATA_AVAILABLE:
                            onDataAvailable(event);
                            break;
                    }
                }
            });
            this.inputStream = this.port.getInputStream();
            this.outputStream = this.port.getOutputStream();
            this.isOpened = true;
        } catch (Exception e) {
            this.isOpened = false;
        } finally {
            return this.isOpened;
        }
    }

    public void closePort() {
        if (this.port == null) {
            return;
        }
        try {
            this.inputStream.close();
            this.outputStream.close();
            this.port.close();
        } catch (Exception e) {
        } finally {
            this.isOpened = false;
        }
    }

    /**
     * Write shortcut for string
     */
    public boolean sendCommand(String lockToken, String string) {
        return sendCommand(lockToken, string.getBytes());
    }

    /**
     * Write shortcut
     * @param bytes
     * @return boolean
     */
    public boolean sendCommand(String lockToken, byte[] bytes) {
        // TODO: worker, ki odklene po X času brez dostopa
        if (!Management.locked || lockToken != Management.lockToken) {
            return false;
        }
        Management.lockAccess = new Date();

        try {
            outputStream.write(bytes);
        } catch (Exception e) {
            return false;
        }

        return true;
    }

    /**
     * Handle output buffer empty events.
     * NOTE: The reception of this event is optional and not
     *       guaranteed by the API specification.
     * @param event The output buffer empty event
     */
    protected void onOutputBufferEmpty(SerialPortEvent event) {
        //TODO: implement
    }

    /**
     * Handle data available events.
     * @param event The data available event
     */
    protected void onDataAvailable(SerialPortEvent event) {
        //TODO: implement
    }
}