"""
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
import tools.patternNameParser as patternNameParser
import check_bpm
import time
import subprocess
from pathlib import Path
import argparse
import datetime
import glob
import numpy
import socket
from re import split as re_split

SYS="SYS0"
UNIT="1"

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

CURRENT_PATTERN = globals.get_path_pv("SYS0","1")

FIXED_RATE = 0
AC_RATE = 1
EXP_SEQ = 2

DEST_UNCHECKED=0
DEST_CHECKED=1

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

IOC_DATA = os.environ.get('IOC_DATA')
PATTERN_TOP = os.path.join(IOC_DATA, 'sioc-sys0-ts01/TpgPatternSetup')
tod = datetime.datetime.now()
tod_list = str(tod).split(" ")
date = tod_list[0]
REPORT_TOP = os.path.join(PATTERN_TOP, "reports")
REPORT_DATE = os.path.join(REPORT_TOP, date)
REPORT_FILE = os.path.join(REPORT_DATE, 'pattern_verify_report.txt')
print(f'saving reports to: REPORT_DATE')
if not os.path.exists(REPORT_DATE):
    os.mkdir(REPORT_DATE)
    
if not os.path.exists(REPORT_FILE):
    with open(REPORT_FILE, "w") as report_file:
        report_file.write(f'---Pattern Verification Human Readable Reports for {date}---')
        report_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:SYS0:1:{bsa_buff.number}:DST{index}', DEST_UNCHECKED)

    #write to destination mode pv, want inclusion  
    caput(f'BSA:SYS0:1:{bsa_buff.number}:DESTMODE', inclusion)

    #write to all aplicable dest mask pvs
    caput(f'BSA:SYS0:1:{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:SYS0:1:{bsa_buff.number}:RATEMODE',1)
    caput(f'BSA:SYS0:1:{bsa_buff.number}:ACRATE','60Hz')

    for time_slot in TIME_SLOTS:
        if time_slot !=4 and time_slot !=1:
            caput(f'BSA:SYS0:1:{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
    """
    runtime_message(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
    """
    runtime_message(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 runtime_message(string):
    """
    caputs the string to the string pv that recieves messages during run time
    If in test mode, prints to terminal
    input
    ------
    string:
        string that can be no more than 40 characters long
        If not a string it is cast to a string and
        If longer than 40 characters it is reduced to 40 characters befor the caput or print
    output
    ------
    none:
        returns nothing, writes message to 
    """
    string = str(string)#make sure this is a string
    if len(string)>40: #epics pvs can only handle a charcter length of 40
        string = string[:40]
    print(string)
    #caput(f"BSA:SYS0:1:{args.destination}:LAUNCH_STS", string)#for runtime, need actual pv
    return

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:SYS0:1:BEAMREQHST{buff_num}')
    print(type(BEAMREQHST_data))
    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:SYS0:1: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])


def monitor_bsss(bpm_dict, suffix):
    """
    Test that monitor will work at 120hz
    """
    print('monitor bsss')
    for bpm in bpm_dict:
        for buff_num in bpm_dict[bpm]:
            bpm_dict[bpm][buff_num][f'BSSS_{suffix}'] = []
            bsss_pv = f'{bpm}:{suffix}{buff_num}'
            print(bsss_pv)
            #camonitor(bsss_pv, writer=bsss_writer)
            try:
                caget(bsss_pv)
            except:
                print('Error: cannot connect to bsss, exiting')
                exit(1)
            else:
                camonitor(bsss_pv, writer=bsss_writer, callback=monitor_bsss_callback)

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


def monitor_bsss_clear(bpm_dict, suffix):
    """
    Clear the monitor when done
    """
    print('monitor bsss clear')
    for bpm in bpm_dict:
        for buff_num in bpm_dict[bpm]:
            bsss_pv = f'{bpm}:{suffix}{buff_num}'
            camonitor(bsss_pv)

def match_bsss_and_bsa(bpm_dict):
    """
    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
    """
    
    for bpm in bpm_dict: #go through each bpm
        for buff_num in bpm_dict[bpm]: #go through each buffer assigned to that bpm

            #reset flag to true
            bsss_bsa_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_match_flag = False
                        print(f'Warning: BSSS and BSA TMIT do not match for pid {bpm_dict[bpm][buff_num]["BSSS_TMITPID"][bsss_pid_index]}')
                else:
                    bsss_bsa_match_flag = False
                    print(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]["TMIT_match"] = bsss_bsa_match_flag
            bpm_dict[bpm][buff_num]["TMITPID_match"] = bsss_bsa_match_flag
    return bpm_dict
            


patternName = caget(CURRENT_PATTERN, as_string=True)
print(patternName)

NTpattern_dict = patternNameParser.parse_pattern_name(patternName)
NTpattern_dict['PATTERN_NAME']=patternName

active_dests=[]
pattern_data = organize_pattern_data(NTpattern_dict)

print(pattern_data['Data'])

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 pattern_data["Data"][dest_num]["Active"]:
        
        if pattern_data["Data"][dest_num]["Timing Source"]=='AC':

            pattern_data["Data"][dest_num]["Buffer"]=run_AC_buffer(dest_num,meascnt)

        if pattern_data["Data"][dest_num]["Timing Source"]=='FR':

            pattern_data["Data"][dest_num]["Buffer"]=run_FR_buffer(dest_num,meascnt)




    
bpm_dict = {}
buff_nums = []
#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)
    #bpm_dict['BPMS:HTR:960']=[pattern_data["Data"][1]["Buffer"].number]
    #bpm_dict['BPMS:SLTD:895']={}
    #bpm_dict['BPMS:SLTD:895'][pattern_data["Data"][2]["Buffer"].number]={}
    buff_nums.append(pattern_data["Data"][1]["Buffer"].number)

#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)
    #bpm_dict['BPMS:SLTD:895']={}
    #bpm_dict['BPMS:SLTD:895'][pattern_data["Data"][2]["Buffer"].number]={}
    buff_nums.append(pattern_data["Data"][2]["Buffer"].number)

#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)
    bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:SPH:322', pattern_data["Data"][3]["Buffer"].number)
    #bpm_dict['BPMS:SPD:255']=[pattern_data["Data"][3]["Buffer"].number]
    #bpm_dict['BPMS:SPH:322']=[pattern_data["Data"][3]["Buffer"].number]
    buff_nums.append(pattern_data["Data"][3]["Buffer"].number)

#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)
    bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:SPD:420', pattern_data["Data"][4]["Buffer"].number)
    #bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:SPS:420', pattern_data["Data"][4]["Buffer"].number)
    bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:SPS:572', pattern_data["Data"][4]["Buffer"].number)
    #bpm_dict['BPMS:SPD:525']=[pattern_data["Data"][4]["Buffer"].number]
    #bpm_dict['BPMS:SPS:572']=[pattern_data["Data"][4]["Buffer"].number]
    buff_nums.append(pattern_data["Data"][4]["Buffer"].number)

host = socket.gethostbyaddr(socket.gethostname())[0]

if host.__contains__('lcls-dev3'):
    bpm_dict = {}
    if pattern_data["Data"][1]["Active"]:
        bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:BSYH:445', pattern_data["Data"][1]["Buffer"].number)
    if pattern_data["Data"][2]["Active"]:
        bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:BSYH:465', pattern_data["Data"][2]["Buffer"].number)
    if pattern_data["Data"][3]["Active"]:
        bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:UNDH:3190', pattern_data["Data"][3]["Buffer"].number)
    if pattern_data["Data"][4]["Active"]:
        bpm_dict = check_bpm.add_bpm(bpm_dict, 'BPMS:UNDH:3290', pattern_data["Data"][4]["Buffer"].number)

full_bsss_list=[]

print(bpm_dict)

monitor_bsss(bpm_dict, 'TMIT')
monitor_bsss(bpm_dict, 'TMITPID')

print(bpm_dict)
runtime_message("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()

#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:SYS0:{pattern_data["Data"][dest_num]["Buffer"].number}:HST_READY') == 0:
                bsa_ready = False
                break
    
    runtime_message("Waiting for aquisitions to complete")
    
monitor_bsss_clear(bpm_dict, 'TMIT')
monitor_bsss_clear(bpm_dict, '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:SYS0:1", "PIDLHST")
bpm_dict = check_bpm.get_tpg_bsa_data(bpm_dict, "TPG:SYS0:1", "BEAMREQHST")
    
json_file_path =  os.path.join(check_bpm.PATTERN_TOP, "reports/test.json")

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 = check_bpm.check_tmit(bpm_dict)

bpm_dict = match_bsss_and_bsa(bpm_dict)

print(f'\n****************************')
print(f'Pattern Name: {patternName}')
print(f'Time: {tod_list[1]}')

for bpm in bpm_dict:
    for buff_num in bpm_dict[bpm]:
        bpm_dict[bpm][buff_num]['report'] = [
                                                    f'bpm: {bpm}, buffer: {buff_num}',
                                                    f'bpm pid spacing count',
                                                    f'{bpm_dict[bpm][buff_num]["TMITPIDHST_spacing_count"]}',
                                                    f'tpg pid spacing count',
                                                    f'{bpm_dict[bpm][buff_num]["PIDLHST_spacing_count"]}',

                                                    f'BSSS pid spacing count',
                                                    f'{bpm_dict[bpm][buff_num]["BSSS_TMITPID_spacing_count"]}',
                                                    f'BSSS pid points aquired',
                                                    f'{len(bpm_dict[bpm][buff_num]["BSSS_TMITPID"])}',
                                                    f'BSSS tmit points aquired',
                                                    f'{len(bpm_dict[bpm][buff_num]["BSSS_TMIT"])}',

                                                    f'all BSSS pid in BSA',
                                                    f'{bpm_dict[bpm][buff_num]["TMIT_match"]}',
                                                    f'all BSSS tmit match BSA tmit on pid',
                                                    f'{bpm_dict[bpm][buff_num]["TMITPID_match"]}',

                                                    f'Pulses with beam, checked by tmit: {bpm_dict[bpm][buff_num]["n_good_tmit"]}',
                                                    f'Total pulses: {bpm_dict[bpm][buff_num]["n_pulses"]}',
                                                    f'BEAMREQHST',
                                                    f'{bpm_dict[bpm][buff_num]["BEAMREQHST_count"]}',
                                                    ]
        #print(f'bpm: {bpm}, buffer: {buff_num}')
        #print('pid spacing: count')
        #print(bpm_dict[bpm][buff_num]['TMITPIDHST_spacing'])
        #try:
        #    print(f'good tmit: {bpm_dict[bpm][buff_num]["n_good_tmit"]}')
        #    print(f'pulses: {bpm_dict[bpm][buff_num]["n_pulses"]}')
        #except:
        #    pass
        #print('\n')
        print("---------------")
        for string in bpm_dict[bpm][buff_num]['report']:
            print(string)
        """
        print(f'BEAMREQHST for {buff_num}')
        print(get_BEAMREQHST(buff_num))
        print(f'PIDLHST for {buff_num}')
        print(get_PIDLHST(buff_num))
        """
            
print(f'saving report to: {REPORT_FILE}')
            

try:
    with open(REPORT_FILE, "a") as report_file:
            report_file.write(f'\n****************************')
            report_file.write(f'\nPattern Name: {patternName}')
            report_file.write(f'\nTime: {tod_list[1]}')
            
            for bpm in bpm_dict:
                for buff_num in bpm_dict[bpm]:
                    report_file.write("\n---------------")
                    for string in bpm_dict[bpm][buff_num]['report']:
                        
                        report_file.write(f'\n{string}')
except:
    print("not able to save report")
        

        
print('releasing buffers')
#Release the buffers in use
for dest_num in pattern_data['Data']:
    if pattern_data["Data"][dest_num]["Active"]:
        pattern_data["Data"][dest_num]["Buffer"].release()
        


    



    
    
    
    
    
    
    
    
    
    
