"""
Pattern verification script
Verifies the spacing in a pattern using bsa


"""

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]


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

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

#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:

    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")
    time.sleep(1)
    
bpm_dict = {}
buff_nums = []
#check DIAG0 BPMS
#BPMS:HTR:960
if pattern_data["Data"][1]["Active"]:
    bpm_dict['BPMS:HTR:960']=[pattern_data["Data"][1]["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['BMPS: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['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['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]={}


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

bpm_dict = check_bpm.get_bpm_bsa_data(bpm_dict, 'TMITHST')
    
json_file_path =  os.path.join(check_bpm.PATTERN_TOP, "reports/test.json")

bpm_dict = check_bpm.get_pid_variation(bpm_dict)

bpm_dict = check_bpm.check_tmit(bpm_dict)

for bpm in bpm_dict:
    for buff_num in bpm_dict[bpm]:
        print(f'bpm: {bpm}, buffer: {buff_num}')
        print('differences in pid: count')
        print(bpm_dict[bpm][buff_num]['pid_variation'])
        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')
  
for dest_num in pattern_data['Data']:

    if pattern_data["Data"][dest_num]["Active"]:
        
        pattern_data["Data"][dest_num]["Buffer"].release()





    
    
    
    
    
    
    
    
    
    
