"""
Set up and get values from rate measure
Wrapper for rate measurese
"""
from epics import caget, caput
from time import sleep

class RateMeasure:
    ON = 1
    OFF = 0

    FIXEDRATE = 0
    ACRATE = 1
    EXPSEQ = 2

    FR_1HZ = 0
    FR_10HZ = 1
    FR_100HZ = 2
    FR_1KHZ = 3
    FR_10KHZ = 4
    FR_71KHZ = 5
    FR_1MZ = 6

    AC_HALFHZ = 0
    AC_1HZ = 1
    AC_5HZ = 2
    AC_10HZ = 3 
    AC_30HZ = 4
    AC_60HZ = 5

    DISABLE = 0
    EXCLUSION = 1
    INCLUSION = 2

    LASER_MASK = 2**0
    DIAG0_MASK = 2**1
    BSYD_MASK = 2**2
    HXR_MASK = 2**3
    SXR_MASK = 2**4

    TS1_MASK = 2**0
    TS2_MASK = 2**1
    TS3_MASK = 2**2
    TS4_MASK = 2**3
    TS5_MASK = 2**4
    TS6_MASK = 2**5

    def __init__(self, idx: int, sys: str, unit: str, dests: list = None, time_slots: list = None):
        self.idx = idx
        self.sys = sys
        self.unit = unit
        self.base_pv = f'TPG:SYS0:1:RM{self.idx}'
        self.dest_mask = dests
        self.time_slot_mask = time_slots
        self.fixedRateMode()
        self.inclusionDestMode()

    @classmethod
    def rate_tpg_to_real(cls, rate_tpg):
        """
        Returns real rate when given tpg rate
        variable names a little goofy to match pvs
        """
        rate_real = round(rate_tpg / 0.98)
        return rate_real

    @classmethod
    def rate_real_to_tpg(cls, rate_real):
        """
        Returns tpg rate when given real rate
        """
        rate_tpg = round(rate_real * 0.98)
        return rate_tpg

    @property
    def idx(self):
        return self._idx
    
    @idx.setter
    def idx(self, v_idx):
        """
        validate index, don't want to be out of bounds
        """
        if type(v_idx) != int:
            raise TypeError(f"idx must be int, is {type(v_idx)}")
        if v_idx < 0 or 23 < v_idx:
            raise ValueError(f'idx must be between 0 and 23, is {v_idx}')

        v_idx = str(v_idx)
        if len(v_idx) < 2:
            v_idx = '0' + v_idx
        self._idx = v_idx
    
    @property
    def rate_tpg(self):
        """
        Return the rate of the counter
        """
        return caget(f'{self.base_pv}:CNT')
    
    @property
    def rate_real(self):
        """
        Returns the calculated real rate of the counter
        """
        rate_tpg = caget(f'{self.base_pv}:CNT')
        return RateMeasure.rate_tpg_to_real(rate_tpg)

    @property
    def base_pv(self):
        return self._base_pv
    
    @base_pv.setter
    def base_pv(self, base_pv):
        self._base_pv = base_pv

    def start(self):
        """
        starts rate measure
        """
        caput(f'{self.base_pv}:CTRL', RateMeasure.ON)

    def stop(self):
        """
        stops rate measure
        """
        caput(f'{self.base_pv}:CTRL', RateMeasure.OFF)

    def restart(self):
        """
        stops then starts rate measure
        """
        caput(f'{self.base_pv}:CTRL', RateMeasure.OFF)
        caput(f'{self.base_pv}:CTRL', RateMeasure.ON)

    @property
    def dest_mask(self):
        """
        retrieve dest mask
        """
        return self._dest_mask

    @dest_mask.setter
    def dest_mask(self, dests: list):
        """
        sets the dest mask to include all destinations passed in
        dests can be dest name, or dest number in integer or string form
        ie
        dest names = LASER, DIAG0, BSYD, HXR, SXR
        dest num as string = '00', '01', '02', ect.
        dest num as int = 0, 1, 2, 3, ... 16
        duplicates are ignored
        """
        dest_mask = 0

        if dests == None:
            self._dest_mask = dest_mask
            return

        if 'LASER' in dests or '00' in dests or 0 in dests:
            dest_mask = dest_mask + RateMeasure.LASER_MASK
        if 'DIAG0' in dests or 'SC_DIAG0' in dests or '01' in dests or 1 in dests:
            dest_mask = dest_mask + RateMeasure.DIAG0_MASK
        if 'BSYD' in dests or 'SC_BSYD' in dests or '02' in dests or 2 in dests:
            dest_mask = dest_mask + RateMeasure.BSYD_MASK
        if 'HXR' in dests or 'SC_HXR' in dests or '03' in dests or 3 in dests:
            dest_mask = dest_mask + RateMeasure.HXR_MASK
        if 'SXR' in dests or 'SC_SXR' in dests or '04' in dests or 4 in dests:
            dest_mask = dest_mask + RateMeasure.SXR_MASK

        self._dest_mask = dest_mask
        caput(f'{self.base_pv}:DESTMASK', dest_mask)

    @property
    def time_slot_mask(self):
        """
        rerieve the time slot mask
        """
        return self._time_slot_mask
    
    @time_slot_mask.setter
    def time_slot_mask(self, time_slots: list):
        """
        sets the dest mask to include all time slots given in the list
        time slots can be name, or time slot number in integer or string form
        ie
        ['TS1', 'TS2', 'TS3', 'TS4', 'TS5', 'TS6']
        ['1', '2', '3', '4', '5', '6']
        [1, 2, 3, 4, 5, 6]
        """
        time_slot_mask = 0

        if time_slots == None:
            self._time_slot_mask = time_slot_mask
            return

        if any(ts1 in time_slots for ts1 in ('TS1', '1', 1)):
            time_slot_mask = time_slot_mask + RateMeasure.TS1_MASK
        if any(ts2 in time_slots for ts2 in ('TS2', '2', 2)):
            time_slot_mask = time_slot_mask + RateMeasure.TS2_MASK
        if any(ts3 in time_slots for ts3 in ('TS3', '3', 3)):
            time_slot_mask = time_slot_mask + RateMeasure.TS3_MASK
        if any(ts4 in time_slots for ts4 in ('TS4', '4', 4)):
            time_slot_mask = time_slot_mask + RateMeasure.TS4_MASK
        if any(ts5 in time_slots for ts5 in ('TS5', '5', 5)):
            time_slot_mask = time_slot_mask + RateMeasure.TS5_MASK
        if any(ts6 in time_slots for ts6 in ('TS6', '6', 6)):
            time_slot_mask = time_slot_mask + RateMeasure.TS6_MASK

        self._time_slot_mask = time_slot_mask
        caput(f'{self.base_pv}:TSLOTMASK', self.time_slot_mask)
    @property
    def rate_mode(self) -> int:
        """
        return rate mode, defalut to fixed rate mode
        """
        return self._rate_mode
    
    def fixedRateMode(self):
        """
        set rate_mode to fixed rate
        """
        self._rate_mode = RateMeasure.FIXEDRATE
        caput(f'{self.base_pv}:RATEMODE', self.rate_mode)
    
    def acRateMode(self):
        """
        set rate_mode to ac rate
        """
        self._rate_mode = RateMeasure.ACRATE
        caput(f'{self.base_pv}:RATEMODE', self.rate_mode)

    def expRateMode(self):
        """
        set rate_mode to experimental sequence
        """
        self._rate_mode = RateMeasure.EXPSEQ
        caput(f'{self.base_pv}:RATEMODE', self.rate_mode)

    @property
    def dest_mode(self) -> int:
        """
        return dest mode, defalut to inclusion
        """
        return self._dest_mode
    
    def disableDestMode(self):
        """
        set rate_mode to fixed rate
        """
        self._dest_mode = RateMeasure.DISABLE
        caput(f'{self.base_pv}:DESTMODE', self.dest_mode)
    
    def exclusionDestMode(self):
        """
        set rate_mode to ac rate
        """
        self._dest_mode = RateMeasure.EXCLUSION
        caput(f'{self.base_pv}:DESTMODE', self.dest_mode)

    def inclusionDestMode(self):
        """
        set rate_mode to experimental sequence
        """
        self._dest_mode = RateMeasure.INCLUSION
        caput(f'{self.base_pv}:DESTMODE', self.dest_mode)


    @property
    def fixed_rate(self):
        """
        return fixed rate
        """
        return self._fixed_rate
    
    def fr_megaHz(self):
        """
        set rate_mode to fixed rate
        """
        self._fixed_rate = RateMeasure.FR_1MZ
        caput(f'{self.base_pv}:FIXEDRATE', self.fixed_rate)

    @property
    def ac_rate(self):
        """
        return ac_rate
        """
        return self._ac_rate
    
    def ac_60Hz(self):
        """
        set rate_mode to fixed rate
        """
        self._ac_rate = RateMeasure.AC_60HZ
        caput(f'{self.base_pv}:ACRATE', self._ac_rate)

    @property
    def exp_num_bit(self) -> list:
        """
        get list of experimental sequence and bit
        ie
        [1,13]
        num = 1, bit = 13
        """
        return self._exp_num_bit
    
    @exp_num_bit.setter
    def exp_num_bit(self, exp_num_bit: list):
        """
        set list of experimental sequence and bit
        ie
        [1,13]
        num = 1, bit = 13
        """
        if not ((type(exp_num_bit) is not list) or (type(exp_num_bit) is not tuple)):
            raise TypeError("exp_num_bit must be type list or tuple")
        if len(exp_num_bit) != 2:
            raise ValueError("exp_num_bit must have length 2")
        for element in exp_num_bit:
            if type(element) is not int:
                raise TypeError("exp_num_bit must only contain ints")
        self._exp_num_bit = exp_num_bit
        caput(f'{self.base_pv}:EXPSEQ', self.exp_num_bit[0])
        caput(f'{self.base_pv}:EXPSEQBIT', self.exp_num_bit[1])