#!/usr/bin/python3
# -*- coding: utf-8 -*-

"""package eddsctrl_server
author    Benoit Dubois
copyright FEMTO ENGINEERING
license   GPL v3.0+
brief     DDS controller, server part.
details   This package provides interface to handle DDS package.
          This package implements server part of a client/server architecture.
          Code inspired from Python Module of the Week website (BSD licence):
          http://pymotw.com/2/select/
          for the logic and from:
          http://eli.thegreenplace.net/2011/08/02/length-prefix-framing-for-protocol-buffers/
          for the message using the length prefix technique.
"""

# Ctrl-c closes the application
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)

import os
import logging
import configparser
from queue import Queue, Empty
from struct import pack, unpack
from select import select
from socket import socket, AF_INET, SOCK_STREAM

from dds.ad9912dev import Ad9912Dev as DdsDevice    # for actual use
#from dds.dds_emul import TestUsbDds as DdsDevice   # for test without DDS
from eddsctrl_server.constants import SERVER_PORT, SERVERHOST, \
    DEFAULT_IFREQ, DEFAULT_OFREQ, DEFAULT_AMP, DEFAULT_PHY, \
    CFG_SERVER_FILE, LOG_SERVER_FILE

CONSOLE_LOG_LEVEL = logging.DEBUG
FILE_LOG_LEVEL = logging.DEBUG

#==============================================================================
class EDdsCtrlServer(object):
    """Class dedicated to interface socket client with DDS device.
    Provide a basic interface to handle client queries:
    Message is built using the length prefix technique: length is sent as a
    packed 4-byte little-endian integer.
    Allow only 4 queries, changement of output frequency, input frequency,
    phase or amplitude value.
    Message structure is simple:
      - Length of message,
      - Exclamation mark
      - Character identifier,
      - Exclamation mark
      - Value
      - Exclamation mark
    There are 8 valid identifiers:
      - 'o[?]' for set/get output frequency
      - 'i[?]' for set/get input frequency
      - 'p[?]' for set/get phase
      - 'a[?]' for set/get amplitude
    """

    def __init__(self, settings_file=None):
        """Constructor: initialize the server.
        :param settings_file: file containing setting data value (str)
        :returns: None
        """
        # Retrieve parameter values from 'ini' file
        if settings_file is None:
            raise ValueError("Parameter settings_file missing.")
        self._settingsf = settings_file
        config = configparser.ConfigParser()
        config.read(settings_file)
        try:
            self._port = config.getint('dds_ctrl', 'server_port')
            ifreq = config.getfloat('dds_ctrl', 'ifreq')
            ofreq = config.getfloat('dds_ctrl', 'ofreq')
            phase = config.getfloat('dds_ctrl', 'phase')
            amp = config.getint('dds_ctrl', 'amp')
        except KeyError as ex:
            logging.critical("Correct or delete the configuration file.")
            raise KeyError("Key %s not found in configuration file:"% str(ex))
        # Init devices
        self._init_dds(ifreq, ofreq, phase, amp)
        self._init_server()
        # Start threaded server
        self._server_loop()

    def _init_dds(self, ifreq, ofreq, phase, amp):
        """Create and configure a DDS object.
        :param ifreq: dds input frequency (float)
        :param ofreq: dds output frequency (float)
        :param phase: dds output phase (float)
        :param amp: dds output amplitude (int)
        :returns: None
        """
        self._dds = DdsDevice()
        try:
            self._dds.set_ifreq(ifreq)
            self._dds.set_ofreq(ofreq)
            self._dds.set_phy(phase)
            self._dds.set_amp(amp)
            self._dds.set_hstl_output_state(False)
            self._dds.set_cmos_output_state(False)
        except Exception as ex:
            raise Exception("Unexpected error during DDS initialisation: %s" \
                            % str(ex))
        logging.debug("DDS inititialization done")

    def _init_server(self):
        """Create and configure a basic server object.
        :returns: None
        """
        try:
            self.server = socket(AF_INET, SOCK_STREAM)
            self.server.setblocking(0)
            host = SERVERHOST    # Get local machine name
            self.server.bind((host, self._port))    # Bind to the port
            self.server.listen(3)    # Now wait for client connection
        except IOError as ex:
            raise IOError("EDDSCTRLSERVER: %s, have you closed properly the " \
                          "server? " % str(ex))
        except Exception as ex:
            raise Exception("EDDSCTRLSERVER: unexpected error during server " \
                            "initialisation: %s" % str(ex))
        # Sockets from which we expect to read
        self.inputs = [self.server]
        # Sockets to which we expect to write
        self.outputs = []
        # Outgoing message queues (socket:Queue)
        self.message_queues = {}
        logging.debug("Server initialization done")

    def _server_loop(self):
        """Main server loop: Handle connection, read and write on server socket.
        :returns: None
        """
        while self.inputs:
            # Await an event on a readable socket descriptor
            readable, writable, exceptional = select(self.inputs, \
                                                     self.outputs, \
                                                     self.inputs)
            # Handle inputs
            self._handle_readable(readable)
            # Handle outputs
            self._handle_writable(writable)
            # Handle exceptional condition
            self._handle_exceptional(exceptional)

    def _handle_readable(self, socket_list):
        """Read message from client.
        Message is built using the length prefix technique. See:
        http://eli.thegreenplace.net/2011/08/02/length-prefix-framing-for-protocol-buffers/
        :param socket_list: List of socket usable to receive data
        :returns: None
        """
        for sock in socket_list:
            # Received a connect to the server (listening) socket
            if sock is self.server:
                self._accept_connect()
            # Established connection
            else:
                header_data = self._recv_n_bytes(sock, 4)
                if header_data is None:
                    logging.error("Message seems received but no data to read")
                    return
                if len(header_data) == 4:
                    msg_len = unpack('<L', header_data)[0]
                    data = self._recv_n_bytes(sock, msg_len).decode('utf-8')
                    # Check message validity
                    if data is None:
                        logging.error("Message received but no data to read")
                        return
                    if len(data) != msg_len:
                        logging.error("Bad message length")
                        return
                    logging.debug("receive %s from %s", \
                                  data, sock.getpeername())
                    # Handle message
                    ret_data = self._input_msg_handler(data)
                    # Return data to client
                    self.message_queues[sock].put(ret_data)
                    # Add output channel for response
                    if sock not in self.outputs:
                        self.outputs.append(sock)
                else:
                    # Interpret empty result as closed connection
                    logging.info("Closing connection after reading no data")
                    # Stop listening for input on the connection
                    if sock in self.outputs:
                        self.outputs.remove(sock)
                    self.inputs.remove(sock)
                    sock.close()
                    # Remove message queue
                    del self.message_queues[sock]

    def _handle_writable(self, socket_list):
        """Send message to client.
        :param socket_list: List of socket object usable to send data
        :returns: None
        """
        for sock in socket_list:
            try:
                next_msg = self.message_queues[sock].get_nowait()
            except Empty:
                self.outputs.remove(sock)
            else:
                self._send_msg(sock, next_msg)
                logging.debug("send %s to %s", next_msg, sock.getpeername())

    def _handle_exceptional(self, socket_list):
        """Handle error with socket by closing it.
        :param socket_list: List of socket object in exceptional condition
        :returns: None
        """
        try:
            for sock in socket_list:
                logging.warning("handling exceptional condition for %s", \
                                sock.getpeername())
                # Stop listening for input on the connection
                self.inputs.remove(sock)
                if sock in self.outputs:
                    self.outputs.remove(sock)
                sock.close()
                # Remove message queue
                del self.message_queues[sock]
        except Exception as ex:
            logging.error("Unexpected error: %s", ex)

    def _input_msg_handler(self, msg):
        """Handle message from clients. Message format is defined in
        :class:`eddsctrl.server.eddsctrlsserver.EDdsCtrlServer`.
        Message contains a command to update DDS device state.
        :param msg: A formated string message (str)
        :returns: Return actual value of parameter in DDS (float)
        """
        split_msg = msg.split("!")
        index = split_msg[1].strip('\0') # Remove extra binary NULL characters
        value = split_msg[2]
        config = configparser.ConfigParser()
        config.read(self._settingsf)
        if index == "o":
            retval = self._dds.set_ofreq(float(value))
            config.set('dds_ctrl', 'ofreq', str(self._dds.get_ofreq()))
        elif index == "p":
            retval = self._dds.set_phy(float(value))
            config.set('dds_ctrl', 'phase', str(self._dds.get_phy()))
        elif index == "a":
            retval = self._dds.set_amp(int(value))
            config.set('dds_ctrl', 'amp', str(self._dds.get_amp()))
        elif index == "i":
            retval = self._dds.set_ifreq(float(value))
            config.set('dds_ctrl', 'ifreq', str(self._dds.get_ifreq()))
        elif index == "o?":
            retval = self._dds.get_ofreq()
        elif index == "p?":
            retval = self._dds.get_phy()
        elif index == "a?":
            retval = self._dds.get_amp()
        elif index == "i?":
            retval = self._dds.get_ifreq()
        else: # Bad identifier, message not valid
            logging.error("Bad identifier, expected o[?], p[?], a[?] or i[?]: "
                          + index + " given")
            return
        # Write modification to setting file
        with open(self._settingsf, 'w') as fd:
            config.write(fd)
        # Note that value actually writed in DDS (retval) can be a bit different
        # than value sended to DDS (value).
        msg = "!" + index + "!" + str(retval) + "!"
        return msg

    @staticmethod
    def _send_msg(sock, msg):
        """Method for sending 'msg' to socket.
        Message is built using the length prefix technique. See:
        http://eli.thegreenplace.net/2011/08/02/length-prefix-framing-for-protocol-buffers/
        :param sock: a valid socket object
        :param msg: message to be send (str)
        :returns: None
        """
        header = pack('<L', len(msg))
        try:
            sock.sendall(header + msg.encode('utf-8'))
        except IOError as ex:
            logging.error("Error during sending: %s", ex)

    @staticmethod
    def _recv_n_bytes(sock, nb):
        """Convenience method for receiving exactly n bytes from socket
        (assuming it's open and connected).
        :param sock: socket object which receives the n bytes
        :param nb: number of bytes to be received (int)
        :returns: data received (str)
        """
        data = ''
        while len(data) < nb:
            try:
                chunk = sock.recv(nb - len(data))
                if chunk == '':
                    break
                data += chunk
            except IOError as ex:
                logging.error("Socket error in _recv_n_bytes: %s", ex)
                return
            except Exception as ex:
                logging.error("Error in _recv_n_bytes: %s", ex)
                return
        return data

    def _accept_connect(self):
        """Server accept connection from client.
        :returns: a new socket object related to client connection (socket)
        """
        # A "readable" server socket is ready to accept a connection
        connection, client_address = self.server.accept()
        logging.info("New connection from %s", client_address)
        connection.setblocking(0)
        self.inputs.append(connection)
        self.outputs.append(connection)
        # Give the connection a queue for data we want to send
        self.message_queues[connection] = Queue()
        return connection


#==============================================================================
def reset_settings(settings_file):
    """Resets the "settings" file with default values.
    :param settings_file: file containing setting data value (str)
    :returns: None
    """
    config = configparser.ConfigParser()
    config.add_section('dds_ctrl')
    config.set('dds_ctrl', 'server_port', str(SERVER_PORT))
    config.set('dds_ctrl', 'ofreq', str(DEFAULT_OFREQ))
    config.set('dds_ctrl', 'phase', str(DEFAULT_PHY))
    config.set('dds_ctrl', 'amp', str(DEFAULT_AMP))
    config.set('dds_ctrl', 'ifreq', str(DEFAULT_IFREQ))
    # Write modification to setting file
    with open(settings_file, 'w') as fd:
        fd.truncate(0) # Reset file contents
        config.write(fd)
    logging.info("Settings file reseted.")


#==============================================================================
def configure_logging():
    """Configures logs.
    """
    date_fmt = "%d/%m/%Y %H:%M:%S"
    log_format = "%(asctime)s %(levelname) -8s %(filename)s " + \
                 " %(funcName)s (%(lineno)d): %(message)s"
    logging.basicConfig(level=FILE_LOG_LEVEL, \
                        datefmt=date_fmt, \
                        format=log_format, \
                        filename=LOG_SERVER_FILE, \
                        filemode='w')
    console = logging.StreamHandler()
    # define a Handler which writes messages to the sys.stderr
    console.setLevel(CONSOLE_LOG_LEVEL)
    # set a format which is simpler for console use
    console_format = '%(levelname) -8s %(filename)s (%(lineno)d): %(message)s'
    formatter = logging.Formatter(console_format)
    # tell the handler to use this format
    console.setFormatter(formatter)
    # add the handler to the root logger
    logging.getLogger('').addHandler(console)


#==============================================================================
def main(settings_file):
    """Main
    """
    configure_logging()
    if os.path.isfile(settings_file) is False:
        logging.error("Settings file missing: create one with default values.")
        reset_settings(settings_file)
    EDdsCtrlServer(settings_file)


#==============================================================================
if __name__ == '__main__':
    main(CFG_SERVER_FILE)