"""
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, caget_many, caput, PV, camonitor, camonitor_clear
from edef import BSABuffer
import sys
import os
import tools.globals as globals
from tools.patternNameParser import parse_pattern_name
from tools.metaParser import meta_parse
import check_bpm
import rm_checks
import time
import config
import subprocess
from pathlib import Path
import argparse
import datetime
import glob
import numpy
import socket
from re import split as re_split
import json
import argparse
from epics_script_controls import EpicsControls

start = time.time()

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()

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

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(" ")
date = tod_list[0]
REPORT_TOP = globals.get_report_top(args.IOC)
epics_ctrls.break_point(REPORT_TOP)
REPORT_DATE = os.path.join(REPORT_TOP, date)
DATA_FILE = os.path.join(REPORT_DATE, 'pattern_verify_data.json')
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')



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

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

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

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 {date}---')
        info_file.write("\ngenerated by verify_patter.py in TpgScripts\n")


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
    bsss_bsa_pid_match_flag = True
    bsss_bsa_tmit_match_flag = 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_bsa_tmit_match_flag = 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:
            bsss_bsa_pid_match_flag = 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]["BSSS_BSA_PID_match"] = bsss_bsa_pid_match_flag
    bpm_dict[bpm][buff_num]["BSSS_BSA_TMIT_match"] = bsss_bsa_tmit_match_flag

    if bsss_bsa_pid_match_flag and bsss_bsa_tmit_match_flag:
        bsss_bsa_match = True
    else:
        bsss_bsa_match = False
    
    # return agrigate of flags, as that is what matters, need to check the dict for troubleshooting :(
    return bpm_dict, bsss_bsa_match

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}')

    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)

    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
    """

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
NTpattern_dict = parse_pattern_name(patternName)
NTpattern_dict['PATTERN_NAME']=patternName

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

#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
                break
    
    epics_ctrls.break_point("Waiting for aquisitions to complete")
    
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"]["bsss_and_bsa_match"] = match_bsss_and_bsa(bpm_dict)

print(f'\n****************************')
print(f'Pattern Name: {patternName}')
print(f'Time: {tod_list[1]}')
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}')
make_file(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: {tod_list[1]}')
            
            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 results of tests        
epics_ctrls.break_point(f'saving reports to: {REPORT_FILE}')
json_report = json.dumps(pattern_report, indent=4)
try:
    with open(REPORT_FILE, "a") as report_file:
        report_file.write(json_report)
except:
    epics_ctrls.break_point("unable to save 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(patternName)
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')