"""
Functions for initializing and checking rate measures for pattern verification
"""

from rate_measure import RateMeasure
from epics import caput
import time
import config
import concurrent.futures

def len_equal_exp_num_bits(object):
    """
    checks length of object vs exp_num_bits
    """
    if len(object) != len(config.EXP_NUM_BITS):
        raise ValueError(f"dest_rates length must be equal to {len(config.EXP_NUM_BITS)}")

def init_rms(timingSources: dict[str], sys: str, unit: str) -> dict[list[RateMeasure]]:
    """
    Initialize all of the rate measures
    input
    ------

    output
    ------
    RateMeasures:
        Dictionary of lists of RateMeasure objects, keys are destinations
        RateMeasure objects are in order 1 Hz, 10 Hz, 100 Hx, full rate
    """
    RateMeasures = {}
    rm_index = config.RM_START_INDEX
    for dest in config.EXP_NUM_BITS:
        RateMeasures[dest] = []
        
        # config and restart rate measures that use experimental sequences
        for exp_num_bit in config.EXP_NUM_BITS[dest]:
            RateMeasures[dest].append(RateMeasure(rm_index, sys, unit))
            RateMeasures[dest][-1].dest_mask = [dest]
            RateMeasures[dest][-1].expRateMode()
            RateMeasures[dest][-1].exp_num_bit = exp_num_bit
            RateMeasures[dest][-1].inclusionDestMode()
            RateMeasures[dest][-1].restart()
            rm_index = rm_index + 1

        # shared between ac and fr
        RateMeasures[dest].append(RateMeasure(rm_index, sys, unit))
        RateMeasures[dest][-1].dest_mask = [dest]
        RateMeasures[dest][-1].inclusionDestMode()

        # init fixed or ac full scan RM
        if timingSources[dest] == 'FR':
            RateMeasures[dest][-1].fixedRateMode()
            RateMeasures[dest][-1].fr_megaHz()
            pass
        if timingSources[dest] == 'AC':
            RateMeasures[dest][-1].acRateMode()
            RateMeasures[dest][-1].time_slot_mask = [1, 4]
            RateMeasures[dest][-1].ac_60Hz()
            pass

        RateMeasures[dest][-1].restart()
        rm_index = rm_index + 1
    return RateMeasures

def check_all(RateMeasures: dict[list[RateMeasure]], 
              dest_rates: dict[int], 
              timingSources: dict[str],
              time_out:float = 5):
    """
    Checks rate measure dict for given destination rates
    input
    ------
    dest_rates:
        rate by destination starting from DIAG0 ending at SXR
    output
    ------
    all_rates_correct:
        Weather or not all rates are correct
    dest_info
    """
    # thread destination checks test
    print('checking all')
    start = time.time()
    timmed_out = False
    dest_info = {}
    for dest in dest_rates:
        dest_info[dest] = False
    all_rates_correct = False

    while not timmed_out and not all_rates_correct:
        all_rates_correct = True
        for dest in RateMeasures:
            print(f'checking {dest}')
            rate_correct, dest_info[dest] = check_dest(RateMeasures[dest], 
                                                       dest_rates[dest], 
                                                       timingSources[dest])
            if not rate_correct:
                all_rates_correct = False

        print(all_rates_correct)

        if time.time() - start > time_out:
            timmed_out = True

    if timmed_out:
        return False, dest_info
    else:
        return True, dest_info


def check_dest(rate_measures, dest_rate, timingSource):
    """
    Checks the rate measures for the given destination
    """
    # TODO: account for ac experimental bits of 120 for scxhh
    info = {}
    all_rates_good = True
    for rm_index, rate_measure in enumerate(rate_measures):
        if rate_measure.rate_mode == RateMeasure.EXPSEQ:
            if timingSource == 'AC':
                exp_rate = config.EXP_NUM_BITS_AC_RATES[rm_index]
            else:
                exp_rate = config.EXP_NUM_BITS_RATES[rm_index]
            if dest_rate > exp_rate:
                desired_rate = exp_rate
            else:
                desired_rate = dest_rate
            rate_is_good, info[rate_measure.idx] = check_rm(rate_measure, desired_rate)
            if not rate_is_good:
                all_rates_good = False
        elif rate_measure.rate_mode == RateMeasure.FIXEDRATE:
            desired_rate = dest_rate
            rate_is_good, info[rate_measure.idx] = check_rm(rate_measure, desired_rate)
            if not rate_is_good:
                all_rates_good = False

        elif rate_measure.rate_mode == RateMeasure.ACRATE:
            desired_rate = dest_rate
            rate_is_good, info[rate_measure.idx] = check_rm(rate_measure, desired_rate)
            if not rate_is_good:
                all_rates_good = False

    return all_rates_good, info
    

def check_rm(rate_measure, expected_rate):
    """
    Checks the given rate measure 
    """
    # if in expseq mode use exp_num_bit to figure out
    rm_rate_real = rate_measure.rate_real
    print(f'checking {rate_measure.idx} for expected rate: {expected_rate}, actual rate: {rm_rate_real}')
    info = {}
    info['RATEMODE'] = rate_measure.rate_mode
    info['expected_rate'] = expected_rate
    info['real_rate'] = rm_rate_real
    if rm_rate_real == expected_rate:
        return True, info
    else:
        return False, info


if __name__ == "__main__":
    from epics_script_controls import EpicsControls

    SYS = 'SYS0'
    UNIT = '1'
    epics_ctrls = EpicsControls("TPG:SYS0:1", terminalMode = True)

    caput("TPG:SYS0:1:MANUAL_PATH", "verified/SC_HXR_STD_FR_0_Hz")
    caput("TPG:SYS0:1:MANUAL_LOAD", 1)
    caput("TPG:SYS0:1:APPLY", 1)

    time.sleep(2)

    caput("TPG:SYS0:1:MANUAL_PATH", "verified/SC_DIAG0_STD_AC_10_Hz_off_3_SC_BSYD_STD_FR_10_Hz_SC_SXR_EXP_FR_510_Hz_off_7")
    caput("TPG:SYS0:1:MANUAL_LOAD", 1)
    caput("TPG:SYS0:1:APPLY", 1)


    start = time.time()
    epics_ctrls.runtime_message("Configuring rate measures")
    RateMeasures = init_rms({'SC_DIAG0': 'AC', 'SC_BSYD': 'FR', 'SC_HXR': 'FR', 'SC_SXR': 'FR'}, SYS, UNIT)
    epics_ctrls.runtime_message("Done configuring rate measures")
    print(time.time() - start)

    start = time.time()
    epics_ctrls.runtime_message("Checking Rate Measures")
    check_all(RateMeasures, {'SC_DIAG0': 10, 'SC_BSYD': 10, 'SC_HXR': 0, 'SC_SXR': 510})
    epics_ctrls.runtime_message("Done Checking Rate Measures")
    print(time.time() - start)

    start = time.time()
    epics_ctrls.runtime_message("Checking Rate Measures second time")
    check_all(RateMeasures, {'SC_DIAG0': 10, 'SC_BSYD': 10, 'SC_HXR': 0, 'SC_SXR': 510})
    epics_ctrls.runtime_message("Done Checking Rate Measures second time")
    print(time.time() - start)
    """
    caput("TPG:SYS0:1:MANUAL_PATH", "verified/SC_DIAG0_EXP_AC_120_Hz_SC_SXR_EXP_FR_10_Hz_off_7")
    caput("TPG:SYS0:1:MANUAL_LOAD", 1)
    caput("TPG:SYS0:1:APPLY", 1)

    start = time.time()
    epics_ctrls.runtime_message("Checking Rate Measures for large ac rate")
    check_all(RateMeasures, {'SC_DIAG0': 120, 'SC_BSYD': 0, 'SC_HXR': 0, 'SC_SXR': 10})
    epics_ctrls.runtime_message("Done Checking Rate Measures second time")
    print(time.time() - start)
    """