class ECDataControl(object):
    """Base class for all the utility classes.
    Just enforces that they accept remote PCI client in the constructor.
    """
    DATA_LEN = 32
    TIME_CONDITION_S = 0.00000255
    
    def __init__(self, rpci):
        self._rpci = rpci

class SystemInfo(ECDataControl):
    """System information register area, containing basic information about the board."""
    BASE_ADDRESS = 0x05C0
    
    OFF_FIRMWARE_VER = 0x00
    OFF_SYS_ID = 0x08
    OFF_SUB_TYPE = 0x0C
    OFF_FIRMWARE_DATE = 0x16
    
    LEN_FIRMWARE_VER = 8
    LEN_SYS_ID = 4
    LEN_SUB_TYPE = 10
    LEN_FIRMWARE_DATE = 10
    
    def read_firmware_version(self):
        address = SystemInfo.BASE_ADDRESS + SystemInfo.OFF_FIRMWARE_VER
        return self._rpci.read_text(address, SystemInfo.LEN_FIRMWARE_VER).strip()
    
    def read_system_id(self):
        address = SystemInfo.BASE_ADDRESS + SystemInfo.OFF_SYS_ID
        return self._rpci.read_text(address, SystemInfo.LEN_SYS_ID).strip()
    
    def read_sub_type(self):
        address = SystemInfo.BASE_ADDRESS + SystemInfo.OFF_SUB_TYPE
        return self._rpci.read_text(address, SystemInfo.LEN_SUB_TYPE).strip()
    
    def read_firmware_date(self):
        address = SystemInfo.BASE_ADDRESS + SystemInfo.OFF_FIRMWARE_DATE
        return self._rpci.read_text(address, SystemInfo.LEN_FIRMWARE_DATE).strip()

class XilinxSystemMonitor(ECDataControl):
    """Xilinx system monitor register area, containing voltages and temperatures.
    Temperatures and voltages are properly converted before returned to the user.
    """
    BASE_ADDRESS = 0x0580
    
    OFF_TEMP_CUR = 0x00
    OFF_VINT_CUR = 0x04
    OFF_VAUX_CUR = 0x08
    OFF_TEMP_MAX = 0x0C
    OFF_VINT_MAX = 0x10
    OFF_VAUX_MAX = 0x14
    OFF_TEMP_MIN = 0x18
    OFF_VINT_MIN = 0x1C
    OFF_VAUX_MIN = 0x20
    
    _C_TEMP_MULT = float(1) / 64 * 503.975 / 1024
    _C_TEMP_ADD = -273.15
    _C_VOLT_MULT = float(1) / 64 / 1024 * 3
    
    def _read_temp(self, offset):
        """Read temperature in celsius from the offset. Counts are always 4 bytes integer."""
        address = XilinxSystemMonitor.BASE_ADDRESS + offset
        num = self._rpci.read(address, XilinxSystemMonitor.DATA_LEN)
        return (num * XilinxSystemMonitor._C_TEMP_MULT) + XilinxSystemMonitor._C_TEMP_ADD
    
    def _read_volts(self, offset):
        """Read voltage from the offset. Counts are always 4 bytes integer."""
        address = XilinxSystemMonitor.BASE_ADDRESS + offset
        num = self._rpci.read(address, XilinxSystemMonitor.DATA_LEN)
        return num * XilinxSystemMonitor._C_VOLT_MULT
    
    def read_temp_cur(self):
        return self._read_temp(XilinxSystemMonitor.OFF_TEMP_CUR)
    
    def read_temp_max(self):
        return self._read_temp(XilinxSystemMonitor.OFF_TEMP_MAX)
    
    def read_temp_min(self):
        return self._read_temp(XilinxSystemMonitor.OFF_TEMP_MIN)
    
    def read_vint_cur(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VINT_CUR)
    
    def read_vint_max(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VINT_MAX)
    
    def read_vint_min(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VINT_MIN)
    
    def read_vaux_cur(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VAUX_CUR)
    
    def read_vaux_max(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VAUX_MAX)
    
    def read_vaux_min(self):
        return self._read_volts(XilinxSystemMonitor.OFF_VAUX_MIN)

class VoltageMonitor(ECDataControl):
    """Voltage monitor register area, containing board voltages and temperature.
    Temperatures and voltages are properly converted before returned to the user.
    """
    BASE_ADDRESS = 0x0540
    
    OFF_V15 = 0x00
    OFF_V12 = 0x04
    OFF_V5 = 0x08
    OFF_V33 = 0x0C
    OFF_V33IO = 0x10
    OFF_VM15 = 0x14
    OFF_C15 = 0x18
    OFF_C12 = 0x1C
    OFF_C5 = 0x20
    OFF_C33 = 0x24
    OFF_C33IO = 0x28
    OFF_C25 = 0x2C
    OFF_C1 = 0x30
    OFF_CM15 = 0x34
    OFF_TEMP_BOARD = 0x38
    
    _C305 = 305.18 * 1e-6
    _C19 = 19.0735 * 1e-6
    _C19_150 = _C19 / (150 * 1e-3)
    _C19_60 = _C19 / (60 * 1e-3)
    _C19_30 = _C19 / (30 * 1e-3)
    
    def read_voltage_15(self):
        """Reads +15.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_V15
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * 6.0 * VoltageMonitor._C305
    
    def read_voltage_12(self):
        """Reads +12.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_V12
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * 4.83 * VoltageMonitor._C305
    
    def read_voltage_5(self):
        """Reads +5.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_V5
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * 2.0 * VoltageMonitor._C305
    
    def read_voltage_33(self):
        """Reads +3.3V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_V33
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C305
    
    def read_voltage_33io(self):
        """Reads +3.3V IO."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_V33IO
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C305
    
    def read_voltage_m15(self):
        """Reads -15.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_VM15
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * -16.0 * VoltageMonitor._C305
    
    def read_current_15(self):
        """Reads current at +15.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C15
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_60
    
    def read_current_12(self):
        """Reads current at +12.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C12
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_150
    
    def read_current_5(self):
        """Reads current at +5.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C5
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_30
    
    def read_current_33(self):
        """Reads current at +3.3V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C33
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_150
    
    def read_current_33io(self):
        """Reads current at +3.3V IO."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C33IO
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_150
    
    def read_current_25(self):
        """Reads current at +2.5V. See Xilinx AUX voltage."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C25
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_150
    
    def read_current_1(self):
        """Reads current at +1.0V. See Xilinx INT voltage."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_C1
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_150
    
    def read_current_m15(self):
        """Reads current at +15.0V."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_CM15
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * VoltageMonitor._C19_60
    
    def read_temp(self):
        """Reads board temperature."""
        address = VoltageMonitor.BASE_ADDRESS + VoltageMonitor.OFF_TEMP_BOARD
        num = self._rpci.read(address, VoltageMonitor.DATA_LEN)
        return num * 0.0625

class ADCControl(ECDataControl):
    """ADC control register area, enabling reading of the status."""
    BASE_ADDRESS = 0x0440
    
    OFF_STATUS = 0x00
    OFF_SET = 0x04
    OFF_RESET = 0x08
    
    MASK_BULK_ADC_TIMEOUT = 1 << 3
    MASK_ADC_TIMEOUT = 1 << 2
    
    def read_status(self):
        address = ADCControl.BASE_ADDRESS + ADCControl.OFF_STATUS
        return self._rpci.read(address, ADCControl.DATA_LEN)
    
    def read_bulk_adc_timeout(self):
        return ((self.read_status() & ADCControl.MASK_BULK_ADC_TIMEOUT) > 0)
    
    def read_adc_timeout(self):
        return ((self.read_status() & ADCControl.MASK_ADC_TIMEOUT) > 0)

class FaultControl(ECDataControl):
    """Faults register area, enabling reading of board faults.
    Also provides functions for writing external fault bits.
    """
    BASE_ADDRESS = 0x0480
    
    OFF_FAULTS_STATUS = 0x00
    OFF_FAULTS_LATCH_STATUS = 0x04
    OFF_RESET_LATCH = 0x08
    OFF_CTRL_STATUS = 0x0C
    OFF_CTRL_SET = 0x10
    OFF_CTRL_RESET = 0x14
    
    MASK_INHIBIT_BIT = 1 << 1
    MASK_RESET_BIT = 1 << 0

    def _get_offset(self, value):
        offset = FaultControl.OFF_CTRL_RESET
        if value == True:
            offset = FaultControl.OFF_CTRL_SET
        return offset
    
    def read_status(self):
        """Returns faults status as a 16 bit integer, where each bit is one fault."""
        address = FaultControl.BASE_ADDRESS + FaultControl.OFF_FAULTS_STATUS
        return self._rpci.read(address, FaultControl.DATA_LEN) & 0xFFFF
    
    def reset_faults_all(self):
        """Resets faults latch status."""
        address = FaultControl.BASE_ADDRESS + FaultControl.OFF_RESET_LATCH
        self._rpci.write(address, FaultControl.DATA_LEN, 0xFFFF)
    
    def write_inhibit_bit(self, value):
        address = FaultControl.BASE_ADDRESS + self._get_offset(value)
        self._rpci.write(address, FaultControl.DATA_LEN, FaultControl.MASK_INHIBIT_BIT)
    
    def write_reset_bit(self, value):
        address = FaultControl.BASE_ADDRESS + self._get_offset(value)
        self._rpci.write(address, FaultControl.DATA_LEN, FaultControl.MASK_RESET_BIT)

class MagnetFaultControl(ECDataControl):
    """Magnet faults register area."""
    BASE_ADDRESS = 0x0500
    
    OFF_MAG_FAULTS_STATUS = 0x0C
    OFF_MAG_FAULTS_LATCH_STATUS = 0x10
    OFF_RESET_LATCH = 0x14
    
    def read_status(self):
        """Returns magnet faults status as a 8 bit integer, where each bit is one fault."""
        address = MagnetFaultControl.BASE_ADDRESS + MagnetFaultControl.OFF_MAG_FAULTS_STATUS
        return self._rpci.read(address, MagnetFaultControl.DATA_LEN) & 0xFF
    
    def reset_mag_faults_all(self):
        """Resets magnet faults latch status."""
        address = MagnetFaultControl.BASE_ADDRESS + MagnetFaultControl.OFF_RESET_LATCH
        self._rpci.write(address, FaultControl.DATA_LEN, 0xFF)
    
class InterlockControl(ECDataControl):
    """Interlocks register area, enabling setting of external interlocks."""
    BASE_ADDRESS = 0x0500
    
    OFF_INT_STATUS = 0x00
    OFF_INT_SET = 0x04
    OFF_INT_RESET = 0x08
    
    NUM_INTERLOCKS = 4

    def _get_offset(self, value):
        offset = InterlockControl.OFF_INT_RESET
        if value == True:
            offset = InterlockControl.OFF_INT_SET
        return offset
    
    def write_interlock(self, value, bit):
        if bit < 0:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be greater or equal to 0!")
        if bit >= InterlockControl.NUM_INTERLOCKS:
            raise ValueError("Invalid bit '" + str(bit) + "' specified! Value should be less than " + str(InterlockControl.NUM_INTERLOCKS) + "!")
        
        address = InterlockControl.BASE_ADDRESS + self._get_offset(value)
        self._rpci.write(address, InterlockControl.DATA_LEN, (1 << bit) & 0x0F)
    
    def write_all_interlocks(self, value):
        address = InterlockControl.BASE_ADDRESS + self._get_offset(value)
        self._rpci.write(address, InterlockControl.DATA_LEN, 0x0F)

class ChannelsControl(ECDataControl):
    """AIO channels register area. Enables reading of monitors and feedbacks.
    Also provides functions for writing the setpoints and ramping settings.
    """
    BASE_ADDRESS = 0x0000
    CHANNEL_OFFSET = 0x40
    NUM_CHANNELS = 16
    
    OFF_SP_REQ = 0x00
    OFF_CUR_SP = 0x04
    OFF_MON_READ = 0x08
    OFF_MON_AVG_READ = 0x0C
    OFF_MON_RIPPLE = 0x10
    OFF_FDBCK_READ = 0x14
    OFF_FDBCK_AVG_READ = 0x18
    OFF_FDBCK_RIPPLE = 0x1C
    OFF_FULLSCALE_DAC = 0x20
    OFF_FULLSCALE_ADC_MON = 0x24
    OFF_RAMP_RATE = 0x28
    OFF_SAMPLES_AVG = 0x2C
    OFF_CONF_STATUS = 0x30
    OFF_CONF_SET = 0x34
    OFF_CONF_RESET = 0x38
    OFF_FULLSCALE_ADC_FDBCK = 0x3C
    
    MASK_RAMPING_STATUS = 1 << 5
    MASK_RAMP_MODE = 1 << 3
    MASK_CONF = 1 << 0
    
    ADC_V_MIN = -10.0
    ADC_V_MAX = +10.0
    DAC_V_MIN = -10.0
    DAC_V_MAX = +10.0
    
    def _get_channel_address(self, channel):
        if channel < 0:
            raise ValueError("Invalid channel '" + str(channel) + "' specified! Value should be greater or equal to 0!")
        if channel >= ChannelsControl.NUM_CHANNELS:
            raise ValueError("Invalid channel '" + str(channel) + "' specified! Value should be less than " + str(ChannelsControl.NUM_CHANNELS) + "!")
        return ChannelsControl.BASE_ADDRESS + channel * ChannelsControl.CHANNEL_OFFSET
    
    def _get_conf_offset(self, value):
        offset = ChannelsControl.OFF_CONF_RESET
        if value == True:
            offset = ChannelsControl.OFF_CONF_SET
        return offset
    
    def read_monitor(self, channel):
        """Reads monitor value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_MON_READ
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
    
    def read_monitor_avg(self, channel):
        """Reads monitor averaged value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_MON_AVG_READ
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
        
    def read_monitor_ripple(self, channel):
        """Reads monitor ripple value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_MON_RIPPLE
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
        
    def read_feedback(self, channel):
        """Reads feedback value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FDBCK_READ
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
        
    def read_feedback_avg(self, channel):
        """Reads feedback averaged value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FDBCK_AVG_READ
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
        
    def read_feedback_ripple(self, channel):
        """Reads feedback ripple value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FDBCK_RIPPLE
        return self._rpci.read(address, ChannelsControl.DATA_LEN)
    
    def write_set_point(self, channel, value):
        """writes set point value in uA."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_SP_REQ
        self._rpci.write(address, ChannelsControl.DATA_LEN, value)
    
    def write_ramp_rate(self, channel, ramp_rate):
        """Writes ramp rate in uA/sec."""
        address = self._get_channel_address(channel) + ChannelsControl.OFF_RAMP_RATE
        self._rpci.write(address, ChannelsControl.DATA_LEN, ramp_rate)
        
    def write_ramp_mode(self, channel, value):
        """Value:
        True -> Immediate, no ramping
        False -> Ramping
        """
        address = self._get_channel_address(channel) + self._get_conf_offset(value)
        self._rpci.write(address, ChannelsControl.DATA_LEN, ChannelsControl.MASK_RAMP_MODE)
    
    def write_configure_bit(self, channel, value):
        """Value:
        True -> The channel will respond to setpoint commands.
        False -> The channel will not respond to setpoint commands.
        """
        address = self._get_channel_address(channel) + self._get_conf_offset(value)
        self._rpci.write(address, ChannelsControl.DATA_LEN, ChannelsControl.MASK_CONF)
    
    def read_configure_bit(self, channel):
        """Returns:
        True -> The channel is configured.
        False -> The channel is not configured.
        """
        address = self._get_channel_address(channel) + ChannelsControl.OFF_CONF_STATUS
        return (self._rpci.read(address, ChannelsControl.DATA_LEN) & ChannelsControl.MASK_CONF) != 0
    
    def write_fullscale_dac(self, channel, value):
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FULLSCALE_DAC
        self._rpci.write(address, ChannelsControl.DATA_LEN, value)
    
    def write_fullscale_adc_monitor(self, channel, value):
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FULLSCALE_ADC_MON
        self._rpci.write(address, ChannelsControl.DATA_LEN, value)
    
    def write_fullscale_adc_feedback(self, channel, value):
        address = self._get_channel_address(channel) + ChannelsControl.OFF_FULLSCALE_ADC_FDBCK
        self._rpci.write(address, ChannelsControl.DATA_LEN, value)
        
    def read_samples_avg(self, channel):
        """Returns samples per average for monitor and feedback channels."""
        # 0x5 -> 32
        # 0x4 -> 16
        # 0x3 -> 8
        # 0x2 -> 4
        # 0x1 -> 2
        # 0x0 -> 1
        address = self._get_channel_address(channel) + ChannelsControl.OFF_SAMPLES_AVG
        return 1 << self._rpci.read(address, ChannelsControl.DATA_LEN)
    
    def read_ramping_status(self, channel):
        """Returns:
        True -> Ramping in progress
        False -> Ramping done
        """
        address = self._get_channel_address(channel) + ChannelsControl.OFF_CONF_STATUS
        return (self._rpci.read(address, ChannelsControl.DATA_LEN) & ChannelsControl.MASK_RAMPING_STATUS) != 0

def remap_value(a, min_a, max_a, min_b, max_b):
    """Maps value a defined on interval min_a..max_a to
    value b, defined on interval min_b..max_b and returns it.
    """
    fact = (float(a) - min_a) / (max_a - min_a)
    b = fact * (max_b - min_b) + min_b
    return b
