"""
Pattern verification script
Verifies the spacing in a pattern using bsa TMITPIDHST
Verifies the beam is present using bsa TMITHST

Author: Ryan McClanahan (rpm)
"""

from epics import caget, caput, camonitor, camonitor_clear
from edef import BSABuffer
import os
import tools.globals as globals
from tools.patternParsers import meta_parse, parse_pattern_name
import check_bpm
import rm_checks
import time
import config
import argparse
import datetime
import socket
from re import split as re_split
import json
import argparse
from epics_script_controls import EpicsControls
import SCTimingPatterns


parser = argparse.ArgumentParser(
    formatter_class=argparse.RawDescriptionHelpFormatter,
    description="pattern verification for {IOC}, on {SYS}, with {UNIT}",
)
parser.add_argument(
    "--SYS",
    default="SYS0",
    help="macro like argument for the pattern server, eg SYS0, B015...",
)
parser.add_argument(
    "--UNIT",
    default="1",
    help="macro like argument for the pattern server, eg 1,2,3...",
)
parser.add_argument(
    "--IOC",
    default="sioc-sys0-ts01",
    help="macro like argument for the pattern server, eg sioc-sys0-ts01, sioc-b015-ts01",
)
parser.add_argument(
    "--ENABLE",
    action="store_true",
    help="Enables invasive testing, e.g. testing tpg beam classes",
)
# args = parser.parse_intermixed_args()
args = parser.parse_args()


DEST_NUMS = [0, 1, 2, 3, 4]
DISABLE = 0
EXCLUSION = 1
INCLUSION = 2

CURRENT_PATTERN = globals.get_path_pv(args.SYS, args.UNIT)

FIXED_RATE = 0
AC_RATE = 1
EXP_SEQ = 2

DEST_UNCHECKED = 0
DEST_CHECKED = 1

TIME_SLOTS = [1, 2, 3, 4, 5, 6]

TPG_BASE_PV = globals.get_tpg_base_pv(args.SYS, args.UNIT)

tod = datetime.datetime.now()
tod_list = str(tod).split(" ")
run_time = str(tod_list[1].split(".")[0])
run_date = tod_list[0]
REPORT_TOP = globals.get_report_top(args.IOC)
REPORT_DATE = os.path.join(REPORT_TOP, run_date)
INFO_FILE = os.path.join(REPORT_DATE, "pattern_verify_info.txt")
REPORT_FILE = os.path.join(REPORT_DATE, "pattern_verify_report.json")
PASSED_FILE = os.path.join(REPORT_DATE, "passed_patterns.txt")
FAILED_FILE = os.path.join(REPORT_DATE, "failed_patterns.txt")


def make_file(fname):
    """
    Makes the file if it does not exist
    """
    if not os.path.exists(fname):
        with open(fname, "w") as open_file:
            pass


def make_data_file(patternName):
    data_file_tail = patternName + "_" + run_time + ".json"
    data_file = os.path.join(REPORT_DATE, data_file_tail)

    return data_file


def bsa_buff_dest_init(bsa_buff, inclusion, dest_num):
    """
    Need to write to pvs to configure the bsa buffer
    """
    # reset all destination masks
    for index in range(1, 5):
        caput(
            f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:DST{index}", DEST_UNCHECKED
        )

    # write to destination mode pv, want inclusion
    caput(f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:DESTMODE", inclusion)

    # write to all aplicable dest mask pvs
    caput(f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:DST{dest_num}", DEST_CHECKED)
    time.sleep(
        1
    )  # need this or else the buffer will start before the inclusion mask is set


def bsa_buff_ac_init(bsa_buff):
    """
    Extra initialization for AC buffers
    Set time slot to TS4 and rate to 60Hz
    """
    caput(f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:RATEMODE", 1)
    caput(f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:ACRATE", "60Hz")

    for time_slot in TIME_SLOTS:
        if time_slot != 4 and time_slot != 1:
            caput(f"BSA:{args.SYS}:{args.UNIT}:{bsa_buff.number}:TS{time_slot}", 0)


def run_AC_buffer(dest_num, n_measurements):
    """
    input
    --------
    strin representation of destination number
    Runs an AC buffer based on the dest_num

    output
    --------
    AC Rate BSA Buffer
    """
    epics_ctrls.break_point(f"initializing AC buffer for dest{dest_num}")
    ac_buffer = BSABuffer(f"ACpattVerify dest{dest_num}", user="timing team")
    bsa_buff_dest_init(ac_buffer, INCLUSION, dest_num)
    bsa_buff_ac_init(ac_buffer)
    ac_buffer.n_measurements = n_measurements
    return ac_buffer


def run_FR_buffer(dest_num, n_measurements):
    """
    input
    --------
    strin representation of destination number
    Runs an FR buffer based on the dest_num

    output
    --------
    Fixed Rate BSA Buffer
    """
    epics_ctrls.break_point(f"initializing FR buffer for dest{dest_num}")
    fr_buffer = BSABuffer(f"FRpattVerify dest{dest_num}", user="timing team")
    bsa_buff_dest_init(fr_buffer, INCLUSION, dest_num)
    fr_buffer.n_measurements = n_measurements
    return fr_buffer


def get_actual_rates():
    """
    Get the actual rates
    """
    rate_pvs = []
    rates = []
    actual_rates = {}
    for dest in DEST_NUMS:
        if dest < 10:
            dest = "0" + str(dest)
        else:
            dest = str(dest)
        rate_pvs.append(f"{TPG_BASE_PV}:DST{dest}:RATE")


def organize_pattern_data(NTpattern_dict):
    """
    I wanted to make the structure of this a lot easier to follow and access
    Takes in a raw row from the sc timing patterns NTTable and formats it
    into a dictionary see the following example:

    pattern_data['PATTERN_NAME'] = SC_DIAG0_STD_AC_30_Hz_off_3_SC_BSYD_STD_FR_102_Hz_SC_SXR_EXP_FR_1.0_kHz_off_7

    pattern_data['Data'] = {
                    0: {'Name': 'LASER', 'Rate': 0, 'Active': False, 'Timing Source': 'FR'},
                    1: {'Name': 'SC_DIAG0', 'Rate': 30.0, 'Active': True, 'Timing Source': 'AC'},
                    2: {'Name': 'SC_BSYD', 'Rate': 102.0, 'Active': True, 'Timing Source': 'FR'},
                    3: {'Name': 'SC_HXR', 'Rate': 0, 'Active': False, 'Timing Source': 'FR'},
                    4: {'Name': 'SC_SXR', 'Rate': 1000.0, 'Active': True, 'Timing Source': 'FR'}
    }
    """
    pattern_data = {}
    pattern_data["PATTERN_NAME"] = NTpattern_dict[f"PATTERN_NAME"]
    pattern_data["Data"] = {}
    for dest_num in DEST_NUMS:

        pattern_data["Data"][dest_num] = {}

        pattern_data["Data"][dest_num]["Name"] = globals.DEST_NAMES[dest_num]

        pattern_data["Data"][dest_num]["Rate"] = NTpattern_dict[
            f"{globals.DEST_NAMES[dest_num]}_RATE_Hz"
        ]

        if pattern_data["Data"][dest_num]["Rate"] > 0:
            pattern_data["Data"][dest_num]["Active"] = True
        else:
            pattern_data["Data"][dest_num]["Active"] = False

        if NTpattern_dict[f"{globals.DEST_NAMES[dest_num]}_TIMING_SOURCE"].__contains__(
            "AC"
        ):
            pattern_data["Data"][dest_num]["Timing Source"] = "AC"
        else:
            pattern_data["Data"][dest_num]["Timing Source"] = "FR"

    return pattern_data


def get_BEAMREQHST(buff_num):
    """
    Returns the BEAMREQHST for the given buff_num
    """
    BEAMREQHST_data = caget(f"{TPG_BASE_PV}:BEAMREQHST{buff_num}")
    BEAMREQHST_data = BEAMREQHST_data.tolist()
    # BEAMREQHST = [bin(i) for i in BEAMREQHST.tolist()]
    for index, BEAMREQ_data in enumerate(BEAMREQHST_data):
        BEAMREQHST_data[int(index)] = bin(int(BEAMREQ_data))
    return BEAMREQHST_data


def get_PIDLHST(buff_num):
    """
    Returns the PIDLHST for the given buff_num
    """
    return caget(f"{TPG_BASE_PV}:PIDLHST{buff_num}")


def bsss_writer(*args):
    """
    Just needed the writer to not write to terminal, defalut none is write to terminal
    """
    # full_bsss_list.append(args[0])


@check_bpm.for_every_bpm
def monitor_bsss(bpm_dict, bpm, buff_num, **kwargs):
    """
    Test that monitor will work at 120hz
    """
    # for bpm in bpm_dict:
    #    for buff_num in bpm_dict[bpm]:
    bpm_dict[bpm][buff_num][f'BSSS_{kwargs["suffix"]}'] = []
    bsss_pv = f'{bpm}:{kwargs["suffix"]}{buff_num}'
    bsss_val = caget(bsss_pv)
    if bsss_val is None:
        epics_ctrls.break_point("Error: cannot connect to bsss, exiting")
        exit(1)
    else:
        camonitor(bsss_pv, writer=bsss_writer, callback=monitor_bsss_callback)
    return bpm_dict


def monitor_bsss_callback(**kwargs):
    """
    Callback for the bsss monitor
    This is not used as the writer works is lighter
    Leaving it in for now for a reference for myself for how a callback works with camonitor
    """
    bpm, trash, attribute = kwargs["pvname"].rpartition(":")
    suffix, buff_num = filter(None, re_split(r"(\d+)", attribute))
    bpm_dict[bpm][int(buff_num)][f"BSSS_{suffix}"].append(int(kwargs["value"]))


@check_bpm.for_every_bpm
def monitor_bsss_clear(bpm_dict, bpm, buff_num, **kwargs):
    """
    Clear the monitor when done
    """
    bsss_pv = f'{bpm}:{kwargs["suffix"]}{buff_num}'
    camonitor_clear(bsss_pv)
    return bpm_dict


@check_bpm.for_every_bpm_check
def match_bsss_and_bsa(bpm_dict, bpm, buff_num):
    """
    Make sure that each BSSS point is matched to a corrisponding BSA point
    Wish I could do this by suffix, but I need to match TMIT and TMITPID
    """
    # reset flag to true
    all_bsss_pid_in_bsa = True
    bsss_tmit_match_bsa_on_pid = True

    for bsss_pid_index, bsss_tmitpid in enumerate(
        bpm_dict[bpm][buff_num]["BSSS_TMITPID"]
    ):  # go through each bsss tmit pid

        if (
            bsss_tmitpid in bpm_dict[bpm][buff_num]["TMITPIDHST"]
        ):  # check if BSSS pid is in BSA pid

            bsa_pid_index = bpm_dict[bpm][buff_num]["TMITPIDHST"].index(bsss_tmitpid)

            # Check that tmit's match for the same pid using the bsa and bss pid index
            if (
                bpm_dict[bpm][buff_num]["TMITHST"][bsa_pid_index]
                != bpm_dict[bpm][buff_num]["BSSS_TMIT"][bsss_pid_index]
            ):
                bsss_tmit_match_bsa_on_pid = False
                epics_ctrls.break_point(
                    f'Warning: BSSS and BSA TMIT do not match for pid {bpm_dict[bpm][buff_num]["BSSS_TMITPID"][bsss_pid_index]}'
                )
        else:
            all_bsss_pid_in_bsa = False
            epics_ctrls.break_point(
                f'Warning: BSSS PID not in BSA for pid {bpm_dict[bpm][buff_num]["BSSS_TMITPID"][bsss_pid_index]}'
            )
            break

    bpm_dict[bpm][buff_num]["all_BSSS_PID_in_BSA"] = all_bsss_pid_in_bsa
    bpm_dict[bpm][buff_num]["BSSS_TMIT_match_BSA_on_PID"] = bsss_tmit_match_bsa_on_pid

    return bpm_dict, all_bsss_pid_in_bsa, bsss_tmit_match_bsa_on_pid


def init_bpm_dict(pattern_data):
    """
    init's the bpm dict with bpm names depending on active dest and dev/prod
    """

    bpm_dict = {}
    host = socket.gethostbyaddr(socket.gethostname())[0]
    print(f"*****host: {host}")

    print(pattern_data)

    if host.__contains__("lcls-dev3"):
        bpm_dict = init_dev_bpms(bpm_dict, pattern_data)
    else:
        bpm_dict = init_prod_bpms(bpm_dict, pattern_data)

    return bpm_dict


def init_prod_bpms(bpm_dict, pattern_data):
    """
    inits prod bpms
    """
    # check DIAG0 BPMS
    # BPMS:HTR:960
    if pattern_data["Data"][1]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:HTR:960", pattern_data["Data"][1]["Buffer"].number, True
        )

    # check BSYD BPMS
    # check BMPS:SLTD:895
    if pattern_data["Data"][2]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SLTD:895", pattern_data["Data"][2]["Buffer"].number, True
        )

    # check HXR BPMS
    # kicker: BPMS:SPD:255
    # inline: BPMS:SPH:322
    if pattern_data["Data"][3]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:255", pattern_data["Data"][3]["Buffer"].number, False
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:135", pattern_data["Data"][3]["Buffer"].number, True
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPH:322", pattern_data["Data"][3]["Buffer"].number, True
        )

    # check SXR BPMS
    # kicker: BPMS:SPD:525
    # inline: BPMS:SPS:572
    if pattern_data["Data"][4]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:525", pattern_data["Data"][4]["Buffer"].number, False
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:420", pattern_data["Data"][4]["Buffer"].number, True
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPS:572", pattern_data["Data"][4]["Buffer"].number, True
        )

    if pattern_data["Data"][5]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:700", pattern_data["Data"][4]["Buffer"].number, False
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:SPD:570", pattern_data["Data"][4]["Buffer"].number, True
        )
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:DASEL:300", pattern_data["Data"][4]["Buffer"].number, True
        )

    return bpm_dict


def init_dev_bpms(bpm_dict, pattern_data):
    """
    inits dev bpms
    """
    if pattern_data["Data"][1]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:BSYH:445", pattern_data["Data"][1]["Buffer"].number, True
        )
    if pattern_data["Data"][2]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:BSYH:465", pattern_data["Data"][2]["Buffer"].number, True
        )
    if pattern_data["Data"][3]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:UNDH:3190", pattern_data["Data"][3]["Buffer"].number, True
        )
    if pattern_data["Data"][4]["Active"]:
        bpm_dict = check_bpm.add_bpm(
            bpm_dict, "BPMS:UNDH:3290", pattern_data["Data"][4]["Buffer"].number, False
        )

    return bpm_dict


def check_display_rate():
    """
    check the pvs that display the rate
    want to check that they are zero for non active dests to
    """


def save_report(pattern_report):
    """
    Saves the report of the passed or failed tests
    """
    try:
        with open(REPORT_FILE, "r") as report_file:
            old_reports = json.load(report_file)
    except:
        epics_ctrls.break_point("unable to open reports")

    report_file.append(pattern_report)

    epics_ctrls.break_point(f"saving reports to: {REPORT_FILE}")
    json_report = json.dumps(report_file, indent=4)
    try:
        with open(REPORT_FILE, "w") as report_file:
            report_file.write(json_report)
    except:
        epics_ctrls.break_point("unable to save report")


if __name__ == "__main__":

    start = time.time()

    epics_ctrls = EpicsControls(
        f"TPG:{args.SYS}:{args.UNIT}:PATT_VERIFY",
        terminalMessages=True,
        pvMessages=True,
        heartbeat=True,
    )

    epics_ctrls.break_point(REPORT_TOP)

    epics_ctrls.break_point(f"saving reports to: {REPORT_DATE}")

    if not os.path.exists(REPORT_DATE):
        os.mkdir(REPORT_DATE)

    patternName = caget(CURRENT_PATTERN, as_string=True)
    epics_ctrls.break_point(patternName)
    pattern_report = {}
    pattern_report["Name"] = patternName
    pattern_report["Checks"] = {}
    # TODO: make this import the NTTable instead of parsing patttern names

    scPatterns = SCTimingPatterns.SCTimingPatterns("sys0", "1")
    test = scPatterns.get_current_pattern_data_raw()
    print(f"scPatterns")
    print(test)

    NTpattern_dict = parse_pattern_name(patternName)
    print("ntpattern_dict")
    print(NTpattern_dict)

    epics_ctrls.break_point(f"info to {INFO_FILE}")

    if not os.path.exists(INFO_FILE):
        with open(INFO_FILE, "w") as info_file:
            info_file.write(
                f"---Pattern Verification Human Readable INFO for {run_date}---"
            )
            info_file.write("\ngenerated by verify_patter.py in TpgScripts\n")

    NTpattern_dict["PATTERN_NAME"] = patternName

    if patternName.__contains__("/"):
        cleanPatternName = patternName.split("/")[1]

    DATA_FILE = make_data_file(cleanPatternName)
    make_file(DATA_FILE)

    pattern_data = organize_pattern_data(NTpattern_dict)

    for dest_num in pattern_data["Data"]:
        # run for 5 sec if possible
        # cap rate at 20000
        meascnt = int(pattern_data["Data"][dest_num]["Rate"])
        meascnt = meascnt * 5
        if meascnt > 20000:
            meascnt = 20000

        if not pattern_data["Data"][dest_num]["Active"]:
            continue

        if pattern_data["Data"][dest_num]["Timing Source"] == "AC":
            pattern_data["Data"][dest_num]["Buffer"] = run_AC_buffer(dest_num, meascnt)

        elif pattern_data["Data"][dest_num]["Timing Source"] == "FR":
            pattern_data["Data"][dest_num]["Buffer"] = run_FR_buffer(dest_num, meascnt)

    bpm_dict = init_bpm_dict(pattern_data)

    full_bsss_list = []

    print(bpm_dict)

    monitor_bsss(bpm_dict, suffix="TMIT")
    monitor_bsss(bpm_dict, suffix="TMITPID")

    epics_ctrls.break_point("Configuring rate measures")

    rm_dest_time_sources = {}
    rm_dest_rates = {}
    for dest in config.RM_DESTS:
        rm_dest_time_sources[dest] = NTpattern_dict[f"{dest}_TIMING_SOURCE"]
        rm_dest_rates[dest] = NTpattern_dict[f"{dest}_RATE_Hz"]

    print(rm_dest_time_sources)

    RateMeasures = rm_checks.init_rms(rm_dest_time_sources, args.SYS, args.UNIT)

    print(bpm_dict)
    epics_ctrls.break_point("Starting BSA Buffers")
    # start the aquisitions
    for dest_num in pattern_data["Data"]:
        if pattern_data["Data"][dest_num]["Active"]:
            pattern_data["Data"][dest_num]["Buffer"].start()

    # Check the Rate Measures, these should finish before the bsa
    pattern_report["Checks"]["rate_measures"], rm_info = rm_checks.check_all(
        RateMeasures, rm_dest_rates, rm_dest_time_sources
    )
    print(rm_info)
    epics_ctrls.break_point(
        f'rate measure check passed: {pattern_report["Checks"]["rate_measures"]}'
    )

    # initialize bsa_ready flag to False before starting tests
    bsa_ready = False

    buffer_start = time.time()

    # Check each aquisition if it is ready, sleep for one second if not all aquisitions are ready
    # Don't need too wait for each to be ready, possible improvement in future if need speed
    while bsa_ready == False:
        time.sleep(1)
        bsa_ready = True

        for dest_num in pattern_data["Data"]:
            if pattern_data["Data"][dest_num]["Active"]:
                if (
                    caget(
                        f'BSA:{args.SYS}:{pattern_data["Data"][dest_num]["Buffer"].number}:HST_READY'
                    )
                    == 0
                ):
                    bsa_ready = False
                    pattern_report["Checks"]["bsa_buff_complete"] = True
                    break

        if time.time() - buffer_start >= 60:
            bsa_ready = True
            pattern_report["Checks"]["bsa_buff_complete"] = False

        epics_ctrls.break_point("Waiting for aquisitions to complete")

    # TODO: check that CNT pv is greater than zero.  If it is zero fail the pattern

    monitor_bsss_clear(bpm_dict, suffix="TMIT")
    monitor_bsss_clear(bpm_dict, suffix="TMITPID")

    bpm_dict = check_bpm.get_bpm_bsa_data(bpm_dict, "TMITPIDHST")

    bpm_dict = check_bpm.get_bpm_bsa_data(bpm_dict, "TMITHST")

    bpm_dict = check_bpm.get_tpg_bsa_data(bpm_dict, TPG_BASE_PV, "PIDLHST")
    bpm_dict = check_bpm.get_tpg_bsa_data(bpm_dict, TPG_BASE_PV, "BEAMREQHST")

    bpm_dict = check_bpm.get_spacing_count(bpm_dict, "TMITPIDHST")
    bpm_dict = check_bpm.get_spacing_count(bpm_dict, "PIDLHST")
    bpm_dict = check_bpm.get_spacing_count(bpm_dict, "BSSS_TMITPID")

    bpm_dict = check_bpm.get_count(bpm_dict, "BEAMREQHST")

    bpm_dict, pattern_report["Checks"]["has_good_tmit"] = check_bpm.check_tmit(bpm_dict)
    epics_ctrls.break_point(f"pattern_report: {pattern_report}")
    (
        bpm_dict,
        pattern_report["Checks"]["all_bsss_pid_in_bsa"],
        pattern_report["Checks"]["bsss_tmit_match_bsa_on_pid"],
    ) = match_bsss_and_bsa(bpm_dict)

    print(f"\n****************************")
    print(f"Pattern Name: {patternName}")
    print(f"Time: {run_time}")
    print("---------------")

    epics_ctrls.break_point("writing bpm info")
    bpm_dict = check_bpm.write_info(bpm_dict)
    epics_ctrls.break_point("bpm info written")
    bpm_info = check_bpm.get_info(bpm_dict)

    print(bpm_info)
    # Save data
    epics_ctrls.break_point("releasing buffers")
    # Release the buffers in use
    for dest_num in pattern_data["Data"]:
        if not pattern_data["Data"][dest_num]["Active"]:
            continue
        pattern_data["Data"][dest_num]["Buffer"].release()

    epics_ctrls.break_point(f"saving data to: {DATA_FILE}")

    for dest_num in pattern_data["Data"]:
        if not pattern_data["Data"][dest_num]["Active"]:
            continue
        del pattern_data["Data"][dest_num]["Buffer"]

    json_pattern = json.dumps(pattern_data, indent=4)
    json_bpm = json.dumps(bpm_dict, indent=4)
    json_rm_info = json.dumps(rm_info, indent=4)

    epics_ctrls.break_point(f"saving data to: {DATA_FILE}")
    try:
        with open(DATA_FILE, "a") as data_file:
            data_file.write(json_pattern)
            data_file.write(json_bpm)
            data_file.write(json_rm_info)

    except:
        epics_ctrls.break_point(f"unable to save data")

    # Save analysis of data
    epics_ctrls.break_point(f"saving info to: {INFO_FILE}")
    try:
        with open(INFO_FILE, "a") as info_file:
            info_file.write(f"\n****************************")
            info_file.write(f"\nPattern Name: {patternName}")
            info_file.write(f"\nTime: {run_time}")

            info_file.write(bpm_info)
            info_file.write("Rate Measure info:\n")
            info_file.write(json_rm_info)
    except:
        epics_ctrls.break_point("unable to save info")

    save_report(pattern_report)

    make_file(PASSED_FILE)
    make_file(FAILED_FILE)

    all_checks_passed = True
    for check in pattern_report["Checks"]:
        if not pattern_report["Checks"][check]:
            all_checks_passed = False

    if all_checks_passed:
        result_file = PASSED_FILE
    else:
        result_file = FAILED_FILE

    try:
        with open(result_file, "a") as results:
            results.write(f"{patternName}\n")
    except:
        epics_ctrls.break_point("unable to write to pass/fail file")

    total_time = time.time() - start
    epics_ctrls.break_point(
        f"End of Pattern Verification.  Time to complete: {total_time} seconds"
    )
