import socket
import struct
import threading

class EmcorTester(object):
    """Core class for communicating with the EMCOR tester board.
    Abstracts socket usage away from the user.
    """
    _DEFAULT_PORT = 56789
    _RECV_BUFFER_SIZE = 128
    
    _PROTOCOL_VERSION = 0x01
    _PROTOCOL_VERSION_MASK = 0x3F
    _ENDIAN_BIG = 0
    _ENDIAN_LITTLE = 1
    _METHOD_READ = 0
    _METHOD_WRITE = 1
    _HEADER_SIZE = 12
    
    def __init__(self, host, port=_DEFAULT_PORT, timeout=2):
        self._message_id = 0
        self._host = host
        self._port = port
        self._socklock = threading.Lock()
        
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self._socket.settimeout(timeout)

    def __del__(self):
        self._socket.close()

    def read(self, address, count):
        """Returns data if it was read successfully, else throws an exception."""
        return self._process(address, count, None)
    
    def write(self, address, data):
        """Writes data or throws an exception."""
        self._process(address, len(data), data)
    
    def _process(self, address, count, data):
        """Encodes protocol message and sends it to the server.
        Waits for the response, decodes and returns it.
        """
        with self._socklock:
            msg_send = self._encode_msg(address, count, data)
            msg_recv = self._communicate(msg_send)
            return self._decode_msg(msg_recv, address)
        
    def _encode_msg(self, address, count, data):
        """Checks input parameters and throws exception if they are invalid.
        Encodes and returns protocol message.
        """
        if address < 0:
            raise ValueError("Invalid address '" + str(address) + "' specified! Value should be greater or equal to 0!")
        if count < 0:
            raise ValueError("Invalid count '" + str(count) + "' specified! Value should be greater or equal to 0!")
        
        endian = EmcorTester._ENDIAN_BIG
        method = EmcorTester._METHOD_READ
        if data:
            method = EmcorTester._METHOD_WRITE
        
        self._message_id = self._message_id + 1
        # message_id can only be 1 byte
        if self._message_id > 0xFF:
            self._message_id = 0
            
        msg = bytearray()
        msg.append((method << 7) | (endian << 6) | (EmcorTester._PROTOCOL_VERSION & EmcorTester._PROTOCOL_VERSION_MASK))
        msg.append(self._message_id & 0xFF)
        msg.extend(struct.pack("!H", 0))  # 2 bytes padding
        msg.extend(struct.pack("!I", address))
        msg.extend(struct.pack("!H", count))
        msg.extend(struct.pack("!H", 0))  # 2 bytes padding
        if method == EmcorTester._METHOD_WRITE:
            for d in data:
                msg.extend(struct.pack("!H", d))
        return msg
    
    def _decode_msg(self, message, address):
        """Decodes message and returns the data as an array of words.
        Throws ProtocolException in case that decoding fails.
        """
        if len(message) < EmcorTester._HEADER_SIZE:
            raise ETProtocolException("header length", len(message), EmcorTester._HEADER_SIZE)
        
        msg_protocol = struct.unpack("!B", message[0])[0]
        msg_id = struct.unpack("!B", message[1])[0]
        # 2 bytes padding
        msg_address = struct.unpack("!I", message[4:8])[0]
        msg_count = struct.unpack("!H", message[8:10])[0]
        # 2 bytes padding
        
        # no checks for other bits, because they are always the same in the examples
        protocol_version = msg_protocol & EmcorTester._PROTOCOL_VERSION_MASK
        if protocol_version != EmcorTester._PROTOCOL_VERSION:
            raise ETProtocolException("protocol version", protocol_version, EmcorTester._PROTOCOL_VERSION)
        if msg_id != self._message_id:
            raise ETProtocolException("message id", msg_id, self._message_id)
        if msg_address != address:
            raise ETProtocolException("status", msg_address, address)

        msg_words = []
        if len(message) > EmcorTester._HEADER_SIZE:
            msg_vals = message[EmcorTester._HEADER_SIZE:]
            if len(msg_vals) != msg_count * 2:
                raise ETProtocolException("message values length", len(msg_vals), msg_count * 2)
            # decoding by words - 2 bytes
            for i in range(msg_count):
                byte_id = i * 2
                msg_words.extend(struct.unpack("!H", msg_vals[byte_id:byte_id + 2]))
        return msg_words
    
    def _communicate(self, data):
        """Sends data over the socket and receives and returns response."""
        self._socket.sendto(data, (self._host, self._port))
        recv_data, _ = self._socket.recvfrom(EmcorTester._RECV_BUFFER_SIZE)
        return recv_data

class ETProtocolException(Exception):
    """Exception that is thrown when there is a problem with the communication protocol."""
    def __init__(self, var_name, var_value, var_expected):
        self.var_name = var_name
        self.var_value = var_value
        self.var_expected = var_expected
        message = "Value for '" + var_name + "' is '" + str(var_value) + "', but should be '" + str(var_expected) + "'!"
        super(ETProtocolException, self).__init__(message)

class ETDataControl(object):
    """Base class for all the utility classes.
    Just enforces that they accept tester in the constructor.
    """
    def __init__(self, tester):
        self._tester = tester

class FaultControl(ETDataControl):
    """Faults control register area, enables triggering the faults."""
    ADDR_STATUS = 0x0000
    ADDR_SET = 0x0001
    ADDR_RESET = 0x0002
    
    NUM_FAULTS = 16
    
    def _get_address(self, value):
        address = FaultControl.ADDR_RESET
        if value == True:
            address = FaultControl.ADDR_SET
        return address
        
    def write_fault(self, value, bit):
        if bit < 0:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be greater or equal to 0!")
        if bit >= FaultControl.NUM_FAULTS:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be less than " + str(FaultControl.NUM_FAULTS) + "!")
        address = self._get_address(value)
        self._tester.write(address, [(1 << bit) & 0xFFFF])
    
    def write_all_faults(self, value):
        address = self._get_address(value)
        self._tester.write(address, [0xFFFF])

class MagnetFaultControl(ETDataControl):
    """Magnet faults control register area, enables triggering the faults."""
    ADDR_STATUS = 0x0003
    ADDR_SET = 0x0004
    ADDR_RESET = 0x0005
    
    NUM_MAG_FAULTS = 8
    
    def _get_address(self, value):
        address = MagnetFaultControl.ADDR_RESET
        if value == True:
            address = MagnetFaultControl.ADDR_SET
        return address
    
    def write_mag_fault(self, value, bit):
        if bit < 0:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be greater or equal to 0!")
        if bit >= MagnetFaultControl.NUM_MAG_FAULTS:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be less than " + str(MagnetFaultControl.NUM_MAG_FAULTS) + "!")
        
        address = self._get_address(value)
        self._tester.write(address, [(1 << bit) & 0xFFFF])
    
    def write_all_mag_faults(self, value):
        address = self._get_address(value)
        self._tester.write(address, [0x00FF])
    
class StatusRegControl(ETDataControl):
    """Status register area, enables reading the status of external interlocks."""
    ADDRESS = 0x0006
    
    MASK_INHIBIT_BIT = 1 << 4
    MASK_RESET_BIT = 1 << 5
    
    def read_interlocks(self):
        """Returns interlocks status as a 4 bit integer, where each bit is one interlock."""
        return self._tester.read(StatusRegControl.ADDRESS, 1)[0] & 0x0F
    
    def read_inhibit_bit(self):
        return self._tester.read(StatusRegControl.ADDRESS, 1)[0] & StatusRegControl.MASK_INHIBIT_BIT
    
    def read_reset_bit(self):
        return self._tester.read(StatusRegControl.ADDRESS, 1)[0] & StatusRegControl.MASK_RESET_BIT
