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

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

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'])
runtime_message("Starting BSA Buffers")
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)


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


    
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 = {}
    bpm_dict['BPMS:BSYH:445']={}
    bpm_dict['BPMS:BSYH:465']={}
    bpm_dict['BPMS:UNDH:3190']={}
    bpm_dict['BPMS:UNDH:3290']={}
    for buff_num in buff_nums:
        bpm_dict['BPMS:BSYH:445'][buff_num]={}
        bpm_dict['BPMS:BSYH:465'][buff_num]={}
        bpm_dict['BPMS:UNDH:3190'][buff_num]={}
        bpm_dict['BPMS:UNDH:3290'][buff_num]={}

print(bpm_dict)

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

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_count(bpm_dict, "BEAMREQHST")

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


    



    
    
    
    
    
    
    
    
    
    
