#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
popis
"""

import pandas as pd

pd.set_option('display.width', 2000)  # nezalamuj tabulky
from sel_lib import read_sel


def znaceni(seeg):
    """
    Function to load .sel files and sort HFOs by groups

    Parameters:
    -----------
    seeg - patient number (45, ..)\n
    
    Returns:
    --------
    FR - dataframe, group 0\n
    vFR - dataframe, group 1\n
    uFR - dataframe, group2\n
    """
    from sel_lib import read_sel

    # volba seeg
    # seeg = 45

    if seeg == 15:
        zn = read_sel('znacky/Easrec-1304120917_pac_seeg015.sel')  ###doplnit plnou cestu!
    elif seeg == 32:
        zn = read_sel(
            'znacky/Easrec_ic_exp-032_141008-1041.sel')  # /home/magda/Nextcloud/DP/Codes/znacky/Easrec_ic_exp-032_141008-1041.sel
    elif seeg == 45:
        zn = read_sel(
            'znacky/Easrec_sciexp-seeg045_160114-1023.sel')  # plná cesta /znacky/Easrec_sciexp-seeg045_160114-1023.sel
    elif seeg == 48:
        zn = read_sel('znacky/Easrec_sciexp-seeg048_160323-1036.sel')
    elif seeg == 56:
        print('zatím neznám název')

    print(zn)

    # převod dat z tuple do DataFrame

    if seeg == 15:
        nazev = ("Easrec-1304120917.d")  # ve zn[2] je pojmenován jako Easrec-1304120917_pac_seeg015.d
    else:
        nazev = zn[2]

    print('Název souboru:', nazev)
    print('Info o dalších kanálech:', zn[1])

    df_zn = pd.DataFrame()
    df_zn = zn[0]
    print('Značky:', zn[0])

    # nepotřebná data pryč
    del df_zn['info']  # info je pouze pořadí, jako kolikátý byl vzorek značen
    df_zn.loc[df_zn['validity'] != 0]
    del df_zn['validity']  # všude stejná

    # rozdělení HFO podle frekvencí, zatím nechávám kanály dohromady
    FR = df_zn.loc[df_zn['group'] == 0]
    vFR = df_zn.loc[df_zn['group'] == 1]
    uFR = df_zn.loc[df_zn['group'] == 2]
    # n_group = df_45.loc[df_45['group'] != 1]

    # indexování od nuly
    FR = FR.reset_index(drop=True)
    vFR = vFR.reset_index(drop=True)
    uFR = uFR.reset_index(drop=True)

    # pse_FR = sns.load_dataset("FR")
    FR['typ'] = 'FR'  # pd.DataFrame('FR',index=FR.index)
    vFR['typ'] = 'vFR'  # 'vFR'
    uFR['typ'] = 'uFR'  # 'uFR'

    df_all_groups: pd.DataFrame = pd.concat([FR, vFR, uFR])
    df_all_groups.reset_index(drop=True, inplace=True)

    df_all_groups.to_pickle(
        "Dataframes/df_all_groups_" + str(seeg) + ".pkl")  # ("Dataframes/df_all_groups_" + str(seeg) + ".pkl")

    return nazev, FR, vFR, uFR, df_all_groups


# from nacteni.py import znaceni()
# znaceni(45)


def info_o_patologii(seeg):
    """
    Function to add info about patology of the channel
    Parameters:
    -----------
    seegs - selected subjects
    Returns:
    --------
    FR, vFR, uFR - added info about pathology

    Note:
    """
    import pandas as pd
    import numpy as np
    pd.set_option('display.width', 2000)  # nezalamuj tabulky
    from funkce.nacteni import znaceni, channels, signal, sig_df_to_array
    from funkce.pocty_znacek import pocty_znacek
    from funkce.D_file_read import read_d_header
    from fnusa_sigproc.methods_uni import pse, pac, fac
    from pyentrp.entropy import shannon_entropy

    nazev, FR, vFR, uFR, df_all_groups = znaceni(seeg)

    # později hodit do fot cyklu -- pro všechna seeg

    if seeg == 15:
        # označení patologických kanálů
        FR['resection'] = np.where(FR['ch_name'] == "B'2", 'yes', 'no') #patologický je B'2
        vFR['resection'] = np.where(vFR['ch_name'] == "B'2", 'yes', 'no')
        uFR['resection'] = np.where(uFR['ch_name'] == "B'2", 'yes', 'no')


    elif seeg == 32:
        FR['resection'] = np.where(FR['ch_name'] == "A'2", 'yes', 'no')
        vFR['resection'] = np.where(vFR['ch_name'] == "A'2", 'yes', 'no')
        uFR['resection'] = np.where(uFR['ch_name'] == "A'2", 'yes', 'no')


    elif seeg == 45:
        FR['resection'] = np.where(FR['ch_name'] == 'B1', 'yes', 'no')
        vFR['resection'] = np.where(vFR['ch_name'] == 'B1', 'yes', 'no')
        uFR['resection'] = np.where(uFR['ch_name'] == 'B1', 'yes', 'no')


    elif seeg == 48:
        FR['resection'] = np.where(FR['ch_name'] == 'B2', 'yes', 'no')
        vFR['resection'] = np.where(vFR['ch_name'] == 'B2', 'yes', 'no')
        uFR['resection'] = np.where(uFR['ch_name'] == 'B2', 'yes', 'no')
    else:
        print('Nebyla přidána informace o patologii kanálů - nutno přidat do funkce info_o_patologii')

    df_all_groups: pd.DataFrame = pd.concat([FR, vFR, uFR])
    df_all_groups.reset_index(drop=True, inplace=True)

    df_all_groups.to_pickle(
        "Dataframes/df_all_groups_" + str(seeg) + ".pkl")  # ("Dataframes/df_all_groups_" + str(seeg) + ".pkl")

    return nazev, FR, vFR, uFR, df_all_groups


# --- výběr patřičného kanálu
def channels(seeg):  # (xh, FR, vFR, uFR):

    """
    Function to get names and indexes of marked channels
    
    Parameters:
    -----------
    seeg - patient number

    xh - all channels, from function read_d_header

    FR - dataframe, group 0\n, from function znaceni
    vFR - dataframe, group 1\n
    uFR - dataframe, group2\n
    
    Returns:
    --------
    ch_all - all channels
    ch_selected - names of selected channels
    ch_idx - indexes of selected channels
    Note: xh má jiné indexování -> ch_idx je neplatný, zdroj čísla kanálu přímo z FR, vFR, uFR (tedy ze souboru .sel)


    # čte z xh
       seeg  FR  vFR  uFR  ch_idx ch_name
    0    15  86  223   27      16     B'2
    1    32   0    0    0      47     A'2
    2    32   0    0    0       2     C'3
    3    48   0    0    0      92     B'1
    4    48  21   93   40      47      B2


    # čte přímo ze .sel filu
       seeg  FR  vFR  uFR  ch_idx ch_name
    0    15  86  223   27      16     B'2
    1    32  53   23   31      46     A'2
    2    32  56  152  232     151     C'3
    3    48   7   20    1      95     B'1
    4    48  21   93   40      47      B2

    """

    import numpy as np
    from funkce.D_file_read import read_d_data
    from funkce.D_file_read import read_d_header

    # získání důležitých informací o souboru
    nazev, FR, vFR, uFR, df_all_groups = znaceni(seeg)

    # --- načti soubor .d
    sh, xh = read_d_header("../../Data_fnusa/" + str(nazev) + "")  # type(sh) #je to dict

    # --- výpis všech kanálů (pro zajímavost)
    ch_all = xh['channel_names']
    # type(ch_all)

    # --- výpis kanálů, ve kterých bylo provedeno značení signálu # univerzální verze - kanály zohledňuje všechny groups

    ch_list = [FR.loc[:, 'ch_name'], vFR.loc[:, 'ch_name'], uFR.loc[:, 'ch_name']]

    ch_df = pd.DataFrame()

    ch_FR = ch_list[0]  # Series(np.random.randn(sLength), index=sig_FR.index)
    ch_vFR = ch_list[1]
    ch_uFR = ch_list[2]

    ch_df = ch_FR
    ch_df = ch_df.append(ch_vFR)
    ch_df = ch_df.append(ch_uFR)

    ch_selected = ch_df.unique()  # , vFR.ch_name.unique(), uFR.ch_name.unique())
    # ch_selected = FR.ch_name.unique() #, vFR.ch_name.unique(), uFR.ch_name.unique())

    ch = np.array(ch_selected).tolist()  # vzniká list

    # for i in range(0, len(ch_selected)):
    #     print('nazdar')
    #     ch = ch.append(ch[i])

    ch_xh_idx = [xh['channel_names'].index(ch_i) for ch_i in ch]

    # --- jiné hodnoty přímo ze .sel file
    ch_sel_idx = [FR.loc[:, 'ch_idx'], vFR.loc[:, 'ch_idx'], uFR.loc[:, 'ch_idx']]

    ch_FR = ch_sel_idx[0]  # Series(np.random.randn(sLength), index=sig_FR.index)
    ch_vFR = ch_sel_idx[1]
    ch_uFR = ch_sel_idx[2]

    ch_df = ch_FR
    ch_df = ch_df.append(ch_vFR)
    ch_df = ch_df.append(ch_uFR)

    # ch_idx = np.array(ch_sel_idx).tolist()

    ch_idx = ch_df.unique()  # , vFR.ch_name.unique(), uFR.ch_name.unique())
    ch_idx = np.array(ch_idx).tolist()

    ch_sel_idx = ch_idx

    # ch_idx = ch_xh_idx ## pokus

    return ch_all, ch_selected, ch_xh_idx, ch_sel_idx


def sig_df_to_array(sig_FR, sig_vFR, sig_uFR, okoli):
    """
    Function to convert sig_df to sig_array
    Parameters:
    -----------
    sig_FR - dataframe - dimension (signal length * number of marked signal sections
    sig_vFR
    sig_uFR
    Returns:
    --------
    sig_FR_array - a long array with aprox. 9000 samples
    sig_vFR_array
    sig_uFR_array
    Note:
    Remember the length of one signal section (number of samples)
    """
    import numpy as np
    # upravení tvaru vstupního signálu do array
    pocet1 = sig_FR.shape[1]
    pocet2 = sig_vFR.shape[1]
    pocet3 = sig_uFR.shape[1]

    sig_FR_array = np.array(sig_FR[0])
    sig_vFR_array = np.array(sig_vFR[0])
    sig_uFR_array = np.array(sig_uFR[0])

    # tady je někde chyba
    for pocet in range(0, pocet1):
        sig_FR_array = np.append(sig_FR_array, sig_FR[pocet])
    for pocet in range(0, pocet2):
        sig_vFR_array = np.append(sig_vFR_array, sig_vFR[pocet])
    for pocet in range(0, pocet3):
        sig_uFR_array = np.append(sig_uFR_array, sig_uFR[pocet])

    delka = print("délka jednoho úseku je " + str(2 * okoli) + " vzorků.")

    return sig_FR_array, sig_vFR_array, sig_uFR_array, delka




def signal(seeg, okoli):  # (FR, vFR, uFR, ch_sel_idx, ch_xh_idx, sh, okoli, seeg):
    """
    Function to get signal from .d file in respect to marks and required length of signal
    Parameters:
    -----------
    seeg = patient number (15, 32, 45, 48, ..)
    okoli - selection of signal length (interval)

    FR, vFR, uFR - groups of marks (output from function znaceni(seeg))
    sh - file information - from function read_d_header
    Returns:
    --------
    sig_FR, sig_vFR, sig_uFR - DataFrame with size count of marks x signal length
    Note: new call of function - signal need s also ch_sel_idx
    """

    import pandas as pd
    pd.set_option('display.width', 2000)  # nezalamuj tabulky

    from funkce.D_file_read import read_d_data
    from funkce.D_file_read import read_d_header


    # získání důležitých informací o souboru
    nazev, FR, vFR, uFR, df_all_groups = znaceni(seeg)

    # --- načti soubor .d
    sh, xh = read_d_header("../../Data_fnusa/" + str(nazev) + "")  # type(sh) #je to dict

    # --- výpis všech kanálů zvoleného pacienta (pro zajímavost)
    ch_all = xh['channel_names']  # type(ch_all) - list

    # --- výpis kanálů, ve kterých bylo provedeno značení signálu
    ch_all, ch_selected, ch_xh_idx, ch_sel_idx = channels(seeg)

    # # --- získání signálu -- pro vizuální kontrolu, zda data sedí
    # samp_start = int(FR.start[56] - okoli)
    # samp_end = int(FR.start[56] + okoli)
    # signal = read_d_data(sh, ch_xh_idx, samp_start, samp_end)  # ch_idx stačí pro jeden kanál (data v samp_start nejsou značena v obou kanálech
    # signal[0]

    # definice nových df

    sig_FR = pd.DataFrame()
    sig_vFR = pd.DataFrame()
    sig_uFR = pd.DataFrame()

    # zjištění počtu značek (pro zajímavost)
    pocet_znacek_kanaly_FR = len(FR.start)  # pocet = len(FR['start'].where(FR['ch_idx']==ch_idx[0]))
    pocet_znacek_kanaly_vFR = len(vFR.start)
    pocet_znacek_kanaly_uFR = len(uFR.start)

    # definice nových listů, kde budou poslední indexy značek (mějme 0..28 značek FR v kanálu C1 -> index bude 28, poté 29..34 značek FR v kanálu B1 -> index bude 34, další kanály..)
    FR_idx_posledni_znacky_v_danem_kanalu = list()  ##poslední index kanálu
    vFR_idx_posledni_znacky_v_danem_kanalu = list()
    uFR_idx_posledni_znacky_v_danem_kanalu = list()

    ## důležité najít index začátku jiného kanálu
    for ch in range(0, len(ch_sel_idx) - 1):  # ii pozdeji na ch #for ii in ch_sel_idx:
        # pocet_znacek_kanal.append(len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[ii]), "start"]))
        if ch in FR.ch_idx:  # pokud není prázdný
            FR_idx_posledni_znacky_v_danem_kanalu.append(max(FR.loc[(FR["start"] > 0) & (
                        FR["ch_idx"] == ch_sel_idx[ch]), "start"].index))  ##později ve for cyklu zaindexovat od nuly
        if ch in vFR.ch_idx:  # pokud není prázdný
            vFR_idx_posledni_znacky_v_danem_kanalu.append(
                max(vFR.loc[(vFR["start"] > 0) & (vFR["ch_idx"] == ch_sel_idx[ch]), "start"].index))
        if ch in uFR.ch_idx:  # pokud není prázdný
            uFR_idx_posledni_znacky_v_danem_kanalu.append(
                max(uFR.loc[(uFR["start"] > 0) & (uFR["ch_idx"] == ch_sel_idx[ch]), "start"].index))

        # pocet_znacek_kanal1 = len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[1]), "start"])
        # pocet_znacek_kanal2 = len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[2]), "start"])

    # --- elegantní cyklus pro výběr dat

    # Fast Ripples

    for i in range(0, pocet_znacek_kanaly_FR):

        samp_start = int(FR.start[i] - okoli)
        samp_end = int(FR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_FR[i] = sig


        elif len(ch_xh_idx) >= 2:

            if i <= FR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_FR[i] = sig[:, 0]

            else:
                for ch in range(1, len(ch_xh_idx)):

                    if i > FR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_FR[i] = sig[:, ch]

    # Very Fast Ripples

    for i in range(0, pocet_znacek_kanaly_vFR):
        samp_start = int(vFR.start[i] - okoli)
        samp_end = int(vFR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_vFR[i] = sig
        elif len(ch_xh_idx) >= 2:
            if i <= vFR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_vFR[i] = sig[:, 0]
            else:
                for ch in range(1, len(ch_xh_idx)):
                    if i > vFR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_vFR[i] = sig[:, ch]

    # Ultra Fast Ripples

    for i in range(0, pocet_znacek_kanaly_uFR):
        samp_start = int(uFR.start[i] - okoli)
        samp_end = int(uFR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_uFR[i] = sig

        elif len(ch_xh_idx) >= 2:
            if i <= uFR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_uFR[i] = sig[:, 0]
            else:
                for ch in range(1, len(ch_xh_idx)):
                    if i > uFR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_uFR[i] = sig[:, ch]

 
    sig_FR.to_pickle("Dataframes/sig_FR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
    sig_vFR.to_pickle("Dataframes/sig_vFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
    sig_uFR.to_pickle("Dataframes/sig_uFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")

    # pocty = pd.read_pickle("Dataframes/sig_FR_" + str(seeg) + "_okoli_" + str(2*okoli) + ".pkl")

    return sig_FR, sig_vFR, sig_uFR








##### smazat

def signal_cely(seeg, okoli):  # (FR, vFR, uFR, ch_sel_idx, ch_xh_idx, sh, okoli, seeg):
    """
    Function to get signal from .d file WITH NO respect to marks and required length of signal
    Parameters:
    -----------
    seeg = patient number (15, 32, 45, 48, ..)
    okoli - selection of signal length (interval)

    FR, vFR, uFR - groups of marks (output from function znaceni(seeg))
    sh - file information - from function read_d_header
    Returns:
    --------
    sig_FR, sig_vFR, sig_uFR - DataFrame with size count of marks x signal length
    Note: new call of function - signal need s also ch_sel_idx
    """

    import pandas as pd
    pd.set_option('display.width', 2000)  # nezalamuj tabulky

    from funkce.D_file_read import read_d_data
    from funkce.D_file_read import read_d_header


    # získání důležitých informací o souboru
    nazev, FR, vFR, uFR, df_all_groups = znaceni(seeg)

    # --- načti soubor .d
    sh, xh = read_d_header("../../Data_fnusa/" + str(nazev) + "")  # type(sh) #je to dict

    # --- výpis všech kanálů zvoleného pacienta (pro zajímavost)
    ch_all = xh['channel_names']  # type(ch_all) - list

    # --- výpis kanálů, ve kterých bylo provedeno značení signálu
    ch_all, ch_selected, ch_xh_idx, ch_sel_idx = channels(seeg)

    # # --- získání signálu -- pro vizuální kontrolu, zda data sedí
    # samp_start = int(FR.start[56] - okoli)
    # samp_end = int(FR.start[56] + okoli)
    # signal = read_d_data(sh, ch_xh_idx, samp_start, samp_end)  # ch_idx stačí pro jeden kanál (data v samp_start nejsou značena v obou kanálech
    # signal[0]

    # definice nových df

    sig_FR = pd.DataFrame()
    sig_vFR = pd.DataFrame()
    sig_uFR = pd.DataFrame()

    # zjištění počtu značek (pro zajímavost)
    pocet_znacek_kanaly_FR = len(FR.start)  # pocet = len(FR['start'].where(FR['ch_idx']==ch_idx[0]))
    pocet_znacek_kanaly_vFR = len(vFR.start)
    pocet_znacek_kanaly_uFR = len(uFR.start)

    # definice nových listů, kde budou poslední indexy značek (mějme 0..28 značek FR v kanálu C1 -> index bude 28, poté 29..34 značek FR v kanálu B1 -> index bude 34, další kanály..)
    FR_idx_posledni_znacky_v_danem_kanalu = list()  ##poslední index kanálu
    vFR_idx_posledni_znacky_v_danem_kanalu = list()
    uFR_idx_posledni_znacky_v_danem_kanalu = list()

    ## důležité najít index začátku jiného kanálu
    for ch in range(0, len(ch_sel_idx) - 1):  # ii pozdeji na ch #for ii in ch_sel_idx:
        # pocet_znacek_kanal.append(len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[ii]), "start"]))
        if ch in FR.ch_idx:  # pokud není prázdný
            FR_idx_posledni_znacky_v_danem_kanalu.append(max(FR.loc[(FR["start"] > 0) & (
                        FR["ch_idx"] == ch_sel_idx[ch]), "start"].index))  ##později ve for cyklu zaindexovat od nuly
        if ch in vFR.ch_idx:  # pokud není prázdný
            vFR_idx_posledni_znacky_v_danem_kanalu.append(
                max(vFR.loc[(vFR["start"] > 0) & (vFR["ch_idx"] == ch_sel_idx[ch]), "start"].index))
        if ch in uFR.ch_idx:  # pokud není prázdný
            uFR_idx_posledni_znacky_v_danem_kanalu.append(
                max(uFR.loc[(uFR["start"] > 0) & (uFR["ch_idx"] == ch_sel_idx[ch]), "start"].index))

        # pocet_znacek_kanal1 = len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[1]), "start"])
        # pocet_znacek_kanal2 = len(FR.loc[(FR["start"] > 0) & (FR["ch_idx"] == ch_sel_idx[2]), "start"])

    # --- elegantní cyklus pro výběr dat

    # Fast Ripples

    for i in range(0, pocet_znacek_kanaly_FR):

        samp_start = int(FR.start[i] - okoli)
        samp_end = int(FR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_FR[i] = sig


        elif len(ch_xh_idx) >= 2:

            if i <= FR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_FR[i] = sig[:, 0]

            else:
                for ch in range(1, len(ch_xh_idx)):

                    if i > FR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_FR[i] = sig[:, ch]

    # Very Fast Ripples

    for i in range(0, pocet_znacek_kanaly_vFR):
        samp_start = int(vFR.start[i] - okoli)
        samp_end = int(vFR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_vFR[i] = sig
        elif len(ch_xh_idx) >= 2:
            if i <= vFR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_vFR[i] = sig[:, 0]
            else:
                for ch in range(1, len(ch_xh_idx)):
                    if i > vFR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_vFR[i] = sig[:, ch]

    # Ultra Fast Ripples

    for i in range(0, pocet_znacek_kanaly_uFR):
        samp_start = int(uFR.start[i] - okoli)
        samp_end = int(uFR.start[i] + okoli)
        sig = read_d_data(sh, ch_xh_idx, samp_start, samp_end)

        if len(ch_xh_idx) == 1:  # nutno ošetřit mimo cyklus, protože sig nejde zavolat jako sig[:,0]
            sig_uFR[i] = sig

        elif len(ch_xh_idx) >= 2:
            if i <= uFR_idx_posledni_znacky_v_danem_kanalu[0]:
                sig_uFR[i] = sig[:, 0]
            else:
                for ch in range(1, len(ch_xh_idx)):
                    if i > uFR_idx_posledni_znacky_v_danem_kanalu[
                        ch - 1]:  # důležitý dodatek - pokud je to druhý kanál, zapisuje se druhý sloupec (ve funkci read_d_data to jinak napsat nešlo)
                        sig_uFR[i] = sig[:, ch]


    sig_FR.to_pickle("Dataframes/sig_FR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
    sig_vFR.to_pickle("Dataframes/sig_vFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
    sig_uFR.to_pickle("Dataframes/sig_uFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")

    # pocty = pd.read_pickle("Dataframes/sig_FR_" + str(seeg) + "_okoli_" + str(2*okoli) + ".pkl")

    return sig_FR, sig_vFR, sig_uFR
