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

"""
načtení vybraných kanálů ze souboru .d
"""

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

from funkce.nacteni import znaceni
from funkce.D_file_read import read_d_header, read_d_data
from fnusa_sigproc.methods_uni import pse, pac, fac
from pyentrp.entropy import *

#volba pacienta
seeg = 48
nazev, FR, vFR, uFR = znaceni(seeg)


sh, xh = read_d_header(nazev) #přemístit do print('\data\:',nazev)
type(sh) #je to dict

#výpis kanálů
ch_all = xh['channel_names']
type(ch_all)

''''''
#vybrání patřičného kanálu --- pozor, FR nemusí obsahovat všechny kanály značené v pacientovi
#ch_df = pd.DataFrame()
#ch_df = [FR.loc[:, 'ch_name'], vFR.loc[:, 'ch_name'], uFR.loc[:, 'ch_name']]

#byl by to list, převádím zpět do dataframe
#ch_df = pd.concat(ch)

ch1 = FR.ch_name.unique() #, vFR.ch_name.unique(), uFR.ch_name.unique())
#ch = [ch1[0], ch1[1]] #vzniká tuple

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


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

#vybírá pouze jeden kanál, další se mi nedaří 'appendovat' do listu
ch_idx = [xh['channel_names'].index(ch[0])]
    #ch = [xh['channel_names'].index(ch[0]), xh['channel_names'].index(ch[1])]

''''''
#ch = [xh['channel_names'].index(ch)]

#méně elegantní verze ###blokový komentář
if seeg == 15:
    ch_idx = [xh['channel_names'].index('G1')]
elif seeg == 32:
    ch_idx = [xh['channel_names'].index('G1'), xh['channel_names'].index('G2')]
elif seeg == 45:
    ch_idx = [xh['channel_names'].index('G1'), xh['channel_names'].index('G2')]
    print('doplnit')
elif seeg == 48:
    ch_idx = [xh['channel_names'].index('B2'), xh['channel_names'].index("B'1")]
elif seeg == 56:
    print('zatím neznám')

#převod do formátu list pro vstup do funkce
#ch_list = [ch]


#samp_start = int(0)

samp_end = int(sh['nsamp']-1) #9509244
#samp_end = int(samp_start_min + 150000)

#samp_end = int(200) #volba menšího úseku



#volba délky zpracovávaného signálu
samp_start_min = int(min(min(FR.start),  min(uFR.start), min(uFR.start)))
samp_end_max = int(max(max(FR.start),  max(uFR.start), max(uFR.start)))


#zmenšení dat
#potřebuji z dat - prvního sloupce vytáhnout vzorek 797950 a jeho blízké okolí (0,006 sekund)
okoli = round((0.06 * 5000)/2)
samp_start = int(samp_start_min - okoli)
samp_end = int(samp_start_min + okoli)

data = read_d_data(sh, ch_idx, samp_start, samp_end) #ch_idx stačí pro jeden kanál (data v samp_start nejsou značena v obou kanálech



#definice nových dataframe
sig_FR = pd.DataFrame()
sig_vFR = pd.DataFrame()
sig_uFR = pd.DataFrame()


#cyklus pro výběr dat

# Fasr Ripples
pocet = len(FR.start)

for i in range(0,pocet):

    samp_start = FR.start[i] - okoli
    samp_end = FR.start[i] + okoli
    data = read_d_data(sh, ch_idx, samp_start, samp_end)
    #data = data[:,0]
    #data_2[i] = data[:,0]

    sig_FR[i] = pd.DataFrame({'B1':data[:,0]})#,'Column2':data[:,1]})


#Very fast ripples

pocet = len(vFR.start)
for i in range(0, pocet):

    samp_start = vFR.start[i] - okoli
    samp_end = vFR.start[i] + okoli
    data = read_d_data(sh, ch_idx, samp_start, samp_end)
    sig_vFR[i] = pd.DataFrame({'B1':data[:,0]})


# Ultra fast ripples

pocet = len(uFR.start)
for i in range(0, pocet):
    samp_start = uFR.start[i] - okoli
    samp_end = uFR.start[i] + okoli
    data = read_d_data(sh, ch_idx, samp_start, samp_end)
    sig_uFR[i] = pd.DataFrame({'B1':data[:,0]})







#první kanál
#data[:,0]


#sig = [FR.start, FR.stop+0.05]
#sig1 = [uFR.start[1], uFR.stop[1]]


#ps_entropy = pse(sig)
#sig_FR
#sig_vFR
#sig_uFR

### Power spectral entropy
pse_FR= pse(sig_FR)
pse_vFR= pse(sig_vFR)
pse_uFR= pse(sig_uFR)


#přidání do DF
FR['pse'] = pd.DataFrame(pse_FR)  # ,'Column2':data[:,1]})
vFR['pse'] = pd.DataFrame(pse_vFR)  # ,'Column2':data[:,1]})
uFR['pse'] = pd.DataFrame(pse_uFR)  # ,'Column2':data[:,1]})


### Frequency-amplitude coupling
FR['fac']=""
vFR['fac']=""
uFR['fac']=""

for i in range(0,len(sig_FR)):
    FR.fac.loc[i] = fac(sig_FR.loc[i], 5000)

for i in range(0,len(sig_vFR)):
    vFR.fac.loc[i] = fac(sig_vFR.loc[i], 5000)

for i in range(0,len(sig_uFR)):
    uFR.fac.loc[i] = fac(sig_uFR.loc[i], 5000)



### Phase-amplitude coupling
FR['pac']=""
vFR['pac']=""
uFR['pac']=""

for i in range(0,len(sig_FR)):
    FR.pac.loc[i] = pac(sig_FR.loc[i], 5000)

for i in range(0,len(sig_vFR)):
    vFR.pac.loc[i] = pac(sig_vFR.loc[i], 5000)

for i in range(0,len(sig_uFR)):
    uFR.pac.loc[i] = pac(sig_uFR.loc[i], 5000)


### Shannon entropy

FR['shannon_entropy']=""
vFR['shannon_entropy']=""
uFR['shannon_entropy']=""

for i in range(0,len(sig_FR)):
    FR.shannon_entropy.loc[i] = shannon_entropy(sig_FR.loc[i])

for i in range(0,len(sig_vFR)):
    vFR.shannon_entropy.loc[i] = shannon_entropy(sig_vFR.loc[i])

for i in range(0,len(sig_uFR)):
    uFR.shannon_entropy.loc[i] = shannon_entropy(sig_uFR.loc[i])



#vykreslení
import seaborn as sns
sns.set(style="whitegrid")
#pse_FR = sns.load_dataset("FR")
FR['typ'] = 'FR' #pd.DataFrame('FR',index=FR.index)
vFR['typ'] = 'vFR' #'vFR'
uFR['typ'] = 'uFR' #'uFR'

vykresleni = pd.concat([FR, vFR, uFR])
vykresleni.reset_index(drop=True)

#plt.figure(1)
#fig_pse = sns.boxplot(x = 'typ' ,y="pse", hue="ch_name", data=vykresleni, palette="Set2", orient="v", width=0.5)
fig_pse = sns.boxplot(x='typ', y="pse", data=vykresleni, orient="v", width=0.35)
fig_pse_sw = sns.swarmplot(x="typ", y="pse", data=vykresleni, color=".3", size=3)
#fig_pse.savefig("Power spectral entropy.png")

#plt.figure()
#Frequency-amplitude coupling
fig_fac = sns.boxplot(x='typ', y="fac", data=vykresleni, palette="Set2", orient="v", width=0.35)
#fig_fac = sns.swarmplot(x="typ", y="fac", data=vykresleni, color=".3", size=3)
#fig_pse.savefig("Frequency_amplitude coupling.png")

#Phase-amplitude coupling
fig_pac = sns.boxplot(x='typ', y="pac", data=vykresleni, palette="Set3", orient="v", width=0.35)
#fig_pse.savefig("Phase_amplitude coupling.png")

#Shannon entropy
fig_pse = sns.boxplot(x='typ', y="shannon_entropy", data=vykresleni, orient="v", width=0.35)

