"""
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 time
import subprocess
from pathlib import Path
import argparse
import datetime
import glob
import numpy

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)
    

