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

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


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],
    ctrl_rates: dict[list[int]] = None,
    ctrl_rates_reduced: list[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
    """
    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:
            if ctrl_rates is None:
                dest_ctrl_rates = None
            else:
                if dest in ctrl_rates:
                    print(f"dest {dest} in ctrl_rates{ctrl_rates}")
                    dest_ctrl_rates = ctrl_rates[dest]
                else:
                    dest_ctrl_rates = None
                    print(f"dest {dest} in ctrl_rates{ctrl_rates}")
            dest_reduced = True if dest in ctrl_rates_reduced else False
            rate_correct, dest_info[dest] = check_dest(
                RateMeasures[dest],
                dest_rates[dest],
                timingSources[dest],
                dest_ctrl_rates,
                dest_reduced,
            )
            if not rate_correct:
                all_rates_correct = False

        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, ctrl_rates=None, dest_reduced=False
):
    """
    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 ctrl_rates is None:
                if timingSource == "AC":
                    exp_rate = config.EXP_NUM_BITS_AC_RATES[rm_index]
                else:
                    exp_rate = config.EXP_NUM_BITS_RATES[rm_index]
            else:
                exp_rate = ctrl_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, dest_reduced
            )
            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, dest_reduced
            )
            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, dest_reduced
            )
            if not rate_is_good:
                all_rates_good = False

    return all_rates_good, info


def check_rm(rate_measure, expected_rate, dest_reduced):
    """
    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
    info["expected reduced control requests"] = dest_reduced
    if rm_rate_real == expected_rate or rate_measure.rate_tpg == expected_rate:
        return True, info
    else:
        if dest_reduced and rm_rate_real > 0:
            return True, info
        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)
    """
