import tools.globals

def convert_old_burst_pattern(pattern_name):
    pattern_dict = {}
    destination_dict = {
                        0:"LASER",
                        1:"SC_DIAG0",
                        2:"SC_BSYD",
                        3:"SC_HXR",
                        4:"SC_SXR"
                        }
    pattern_list = pattern_name.split(" ")

    for destination in destination_dict:
        if pattern_list[0].__contains__(str(destination)):
            active_dest = destination_dict[destination]

    burst_list=pattern_list[2].split(".")
    burst_list=burst_list[1].split("b_")
    burst_list[0]=burst_list[0].replace('b','')

    try:
        burst_list[1]
    except:
        
        burst_list.append(0)
    
    pattern_name = f'{active_dest}_B_bs_{burst_list[1]}_bpt_{burst_list[0]}'
    return(pattern_name)

def parse_pattern_name(pattern_name):
    """
    parses the given pattern name and returns a dictionary of rates and pattern types
    Extracts meta data from the pattern name and returns the following dict
    pattern_dict = {
                'SC DIAG0 RATE Hz':0,'SC DIAG0 PATTERN TYPE':None,
                'SC BSYD RATE Hz':0,'SC DIAG0 PATTERN TYPE':None,
                'SC HXR RATE Hz':0,'SC DIAG0 PATTERN TYPE':None,
                'SC SXR RATE Hz':0,'SC DIAG0 PATTERN TYPE':None
                }
    """
    if pattern_name.__contains__(" "):
        pattern_name = convert_old_burst_pattern(pattern_name)

    pattern_dict = {}
    dest_data_dict = {}
    #list of all possible destinations
    
    #dictionary of shortened and expanded pattern types
    pattern_types_dict = {'_FR_':"FR", "_AC_": "AC", "_B_":"B"}

    active_dests=[]

    #find active destinations and comma deliminate the pattern name
    #this works as pattern names are always generated in destination order
    for dest in tools.globals.DEST_NAMES:
        if dest in pattern_name:
            active_dests.append(dest)
            if len(active_dests)>1:
                pattern_name = pattern_name.replace(dest, ",")
            else:
                pattern_name = pattern_name.replace(dest, "")

    #use the comma deliminated pattern_name string to create dest_data_dict
    #a dictionary with the destinations as keys and their meta data as elements
    dest_data = pattern_name.split(",")
    for index, dest in enumerate(active_dests):
        dest_data_dict[dest] = dest_data[index]

    #Go destination by destination to create the pattern dict
    for dest in tools.globals.DEST_NAMES:
        dest_rate_key=dest+"_RATE_Hz"       #key for destination rate
        dest_pattern_key=dest+"_PATTERN_TYPE" #key for destination type
        dest_bpt_key = dest+"_BUNCHES_PER_TRAIN"
        dest_bs_key = dest+"_BUNCH_SPACING"
        if dest in active_dests:
            """extract meta data from dest_data_dict"""
            pattern_type = ""

            """
            if 'EXP' in dest_data_dict[dest]:
                pattern_type = pattern_type + 'EXPERIMENTAL'
            else:
                pattern_type = pattern_type + 'STANDARD'
            """

            #figure out fixed rate vs. AC vs. burst
            for key in pattern_types_dict:
                if key in dest_data_dict[dest]:
                    pattern_type = pattern_type+pattern_types_dict[key]

            pattern_dict[dest_pattern_key] = pattern_type

            #extract the rate and save it, rate is always followed by "Hz"
            #so split name by "_" then look at the element in the new list in front of "Hz"
            dest_data_list = dest_data_dict[dest].split("_")
            if "Hz" in dest_data_list:
                pattern_dict[dest_rate_key] = float(dest_data_list[dest_data_list.index('Hz')-1])
            elif "kHz" in dest_data_list:
                pattern_dict[dest_rate_key] = 1000*float(dest_data_list[dest_data_list.index('kHz')-1])

            # handling for burst patterns
            # extract bunches per train and bunch spacing from string
            if "B" in dest_data_list:
                pattern_dict[dest_rate_key] = int(dest_data_list[dest_data_list.index('bpt')+1])
                pattern_dict[dest_bpt_key] = int(dest_data_list[dest_data_list.index('bpt')+1])
                pattern_dict[dest_bs_key] = int(dest_data_list[dest_data_list.index('bs')+1])
            else:
                pattern_dict[dest_bpt_key] = 0
                pattern_dict[dest_bs_key] = 0
        #non active destinations have no rate and no pattern
        else:
            
            pattern_dict[dest_rate_key] = 0
            pattern_dict[dest_pattern_key] = 'None'
            pattern_dict[dest_bpt_key] = 0
            pattern_dict[dest_bs_key] = 0

    return pattern_dict