#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-

import sqlalchemy as sqla  # Import knihovny sqlalchemy - pro komunikaci s mysql serverem
import pandas as pd
import pickle

pd.set_option('expand_frame_repr', False)  # nastavené, aby v konzoli nezalomoval tabulky

"""
:param patient_id:          49
:return:    conn_df, conn_df2, conn_nB_channels_df, conn_corr_df

-------------------------------------------------------------------------------------
POPIS:
Tato funkce načítá data, k nimž jsou dopočítané hodnoty lin_corr_median a lin_corr_std z MySQL databáze, přiřazuje k jednotlivým kanálům lékařsky zhodnocené soz_info a na základě označení obou kanálů 
ze dvojice vyhodnotí dvojici jako patologickou (SOZ), nebo nepatologickou (NON_SOZ). 
Poté, na základě označení dvojice vykreslí boxploty s rozdělením lin_corr_median a lin_corr_std hodnot.

Popis tabulek:
conn_df - DataFrame obsahující názvy kanálů, všechny hodnoty lin_corr_median, lin_corr_std, soz_info_1, soz_info_2,.. bez záznamů BRIDGEs, soz_info roztřizuje dvojice do skupin SOZ, NON_SOZ, BRIDGE, jsou zde již spočítány průměrné hodnoty podle roztřídění podle low_fc
conn_nB_channels_df - Krátký DataFrame obsahující názvy dvojic posuzovaných kanálů, se kterými se bude dále pracovat, tedy těch, které josu zařazeny do skupin SOZ a NON_SOZ (neobsahuje BRIDGEs dvojice)
conn_corr_df - DataFrame se všemi záznamy jednotlivých dvojic kanálů, obsahuje pouze SOZ a NON_SOZ, obsahuje originální data - nesjednoceno dle low_fc
------------------------------------------------------------------------------------- 
"""

patient_id = 32

# ----připojení do databáze
db_remote = {'user':'', 'pwd':'', 'host': '', 'port':'', 'database':''}

db = db_remote
engine = sqla.create_engine(
    'mysql+pymysql://{}:{}@{}:{}/{}'.format(db['user'], db['pwd'], db['host'], db['port'], db['database']))
conn = engine.connect()

# ----ošetření vstupu patient_id
if patient_id / 10 == 0:
    id = '00'
elif patient_id / 100 == 0:
    id = '0'
else:
    id = ''

id += str(patient_id)  # volba pacienta ve formátu 01 až 49

seeg = id


#------------načtení ze souboru
try:
    with open('cache/connectivity_wm_seeg_' + seeg + '_marked.pkl', 'rb') as f:
        data2 = pickle.load(f)
except:
    #pass

    # --- získávání soz_info z lékařsky označených kanálů
    print('Getting IZ_channels from seeg={}'.format(seeg))
    query = 'SELECT channel_name FROM reviewed_events.seizures WHERE seeg=' + str(
        seeg) + ' AND onset_channel="IrritativeZone"'
    res = conn.execute(query)
    IZ_channels = [x[0] for x in res.fetchall()]  # Seznam kanalu, ktere byly oznaceny jako IZ

    print('Getting SOZ_channels from seeg={}'.format(seeg))
    query = 'SELECT channel_name FROM reviewed_events.seizures WHERE seeg=' + str(seeg) + ' AND onset_channel="SOZ"'
    res = conn.execute(query)
    SOZ_channels = [x[0] for x in res.fetchall()]  # Seznam kanalu, ktere byly oznaceny jako SOZ

    print('Getting NON_SOZ_channels from seeg={}'.format(seeg))
    query = 'SELECT channel_name FROM reviewed_events.seizures WHERE seeg=' + str(seeg) + ' AND onset_channel="NON_SOZ"'
    res = conn.execute(query)
    NON_SOZ_channels = [x[0] for x in res.fetchall()]  # Seznam kanalu, ktere byly oznaceny jako SOZ

    # ---volba databáze
    database = 'connectivity_Fnusa'

    # ---vytažení dat z databáze - nove --------------------------------

    # Get channel_names
    query = 'SELECT channel_name FROM patientInfo.channel_map WHERE seeg=' + seeg + ' AND electrode_type="Macro"'
    res = conn.execute(query)
    channel_names = [x[0] for x in res.fetchall()]

    conn_df = pd.DataFrame(columns=('seeg', 'channel_name_1', 'channel_name_2', 'low_fc', 'high_fc',
                                    'lin_corr_median', 'ren_median', 'phase_sync_median', 'phase_const_median',
                                    'lin_corr_std', 'ren_std', 'phase_sync_std', 'phase_const_std'))
    out_i = 0
    for chan1 in channel_names:

        nums = [x for x in chan1 if x.isdigit()] # x není unicode (zápis x = u'neco'), proto x.isnumeric() nahrazena x.isdigit()
        ch_num = int(''.join(nums))
        chan2 = chan1[:-len(nums)] + str(ch_num + 1).zfill(len(nums))

        print(chan1 + ' - ' + chan2)

        query = 'SELECT channel_name_1,channel_name_2,low_fc,high_fc,lin_corr_median,ren,phase_sync,phase_const FROM ' + database + '.conn_' + str(
            seeg) + '_wm WHERE channel_name_1="' + chan1 + '" AND channel_name_2="' + chan2 + '"'
        chan_pair = pd.read_sql(query, conn)

        if len(chan_pair) == 0:
            query = 'SELECT channel_name_1,channel_name_2,low_fc,high_fc,lin_corr_median,ren,phase_sync,phase_const FROM ' + database + '.conn_' + str(
                seeg) + '_wm WHERE channel_name_1="' + chan2 + '" AND channel_name_2="' + chan1 + '"'
            chan_pair = pd.read_sql(query, conn)
            if len(chan_pair) == 0:
                continue

        for low_fc, high_fc in zip(chan_pair.low_fc.unique(), chan_pair.high_fc.unique()):
            band_subset = chan_pair.loc[chan_pair.low_fc == low_fc, :]
            out_list = [int(seeg), chan1, chan2, low_fc, high_fc,
                        band_subset.lin_corr_median.median(), band_subset.ren.median(), band_subset.phase_sync.median(),
                        band_subset.phase_const.median(),
                        band_subset.lin_corr_median.std(), band_subset.ren.std(), band_subset.phase_sync.std(),
                        band_subset.phase_const.std()]
            conn_df.loc[out_i, :] = out_list
            out_i += 1

            #conn_df.to_pickle('/home/jan_cimbalnik/Dropbox/connectivity_wm_seeg_'+seeg+'.pkl')
            conn_df.to_pickle('C:/Users/admin/ownCloud/BakalarskaPrace/cache/connectivity_wm_seeg_' + seeg + '.pkl')

    # -------------------------------------------------
    #conn_df = data
    # ---Vytvoreni noveho sloupecku v dataframu a oznaceni defaultni hodnoty jako NON_SOZ (nepatologicke)
    conn_df['soz_info_1'] = 'NON_SOZ'
    conn_df['soz_info_2'] = 'NON_SOZ'

    conn_df['soz_info'] = ''

    # ---Seznam kanalu v conn_df dataframu
    channels_1 = conn_df.channel_name_1.unique()
    channels_2 = conn_df.channel_name_2.unique()

    # ---přiřazování lékařsky zhodnocených soz_info ke kanálům
    print('Marking IZ & SOZ channels')

    for channel in channels_1:
        if channel in IZ_channels:
            conn_df.loc[(
                            conn_df.channel_name_1 == channel), 'soz_info_1'] = 'SOZ'  # puvodne IZ# Vsechny zaznamy v conn_df, ktere maji kanal v IZ seznamu jsou oznaceny jako IZ
        if channel in SOZ_channels:
            conn_df.loc[(
                            conn_df.channel_name_1 == channel), 'soz_info_1'] = 'SOZ'  # Vsechny zaznamy v conn_df, ktere maji kanal v SOZ seznamu jsou oznaceny jako SOZ (i pokud byl predtim oznacen jako IZ)
            # if channel in NON_SOZ_channels:
            #    conn_df.loc[(conn_df.channel_name_1 == channel), 'soz_info_1'] = 'NON_SOZ'

    # conn_df.loc[conn_df['soz_info_1'] == 'SOZ'] #pro zajímavost

    for channel in channels_2:
        if channel in IZ_channels:
            conn_df.loc[(
                            conn_df.channel_name_2 == channel), 'soz_info_2'] = 'SOZ'  ##puvodne IZ#  Vsechny zaznamy v conn_df, ktere maji kanal v IZ seznamu jsou oznaceny jako IZ
        if channel in SOZ_channels:
            conn_df.loc[(
                            conn_df.channel_name_2 == channel), 'soz_info_2'] = 'SOZ'  # Vsechny zaznamy v conn_df, ktere maji kanal v SOZ seznamu jsou oznaceny jako SOZ (i pokud byl predtim oznacen jako IZ)
            # if channel in NON_SOZ_channels:
            #    conn_df.loc[(conn_df.channel_name_2 == channel), 'soz_info_2'] = 'NON_SOZ'

    print('IZ & SOZ channels have been marked')

    #conn_df.to_pickle('C:/Users/admin/ownCloud/BakalarskaPrace/cache/connectivity_wm_seeg_' + seeg + '_marked.pkl')

    conn.close()


    print('záchytný bod č.1')

    # ---vytvoření DataFrame se všemi záznamy jednotlivých dvojic kanálů, obsahuje SOZ, NON_SOZ, BRIDGEs
    r = range(0, len(conn_df.soz_info_1))

    for i in r:
        if conn_df.soz_info_1[i] == conn_df.soz_info_2[i] == 'SOZ':
            conn_df.soz_info[i] = 'SOZ'
        elif conn_df.soz_info_1[i] == conn_df.soz_info_2[i] == 'NON_SOZ':
            conn_df.soz_info[i] = 'NON_SOZ'
        # elif conn_df2.soz_info_1[i] or conn_df2.soz_info_2[i] == 'N/A': #nyní jsou IZ kanály označeny jako SOZ, s IZ už se nepočítá
        #     conn_df2.soz_info[i] = 'NOT MARKED'
        # elif conn_df2.soz_info_1[i]  ==  conn_df2.soz_info_2[i] == 'IZ': #nyní jsou IZ kanály označeny jako SOZ, s IZ už se nepočítá
        #     conn_df2.soz_info[i] = 'IZ' #pro zajímavost
        # elif conn_df2.soz_info_1[i] == 'IZ' and conn_df2.soz_info_2[i] == 'SOZ':  # nyní jsou IZ kanály označeny jako SOZ, s IZ už se nepočítá
        #     conn_df2.soz_info[i] = 'SOZ'
        # elif conn_df2.soz_info_1[i] == 'SOZ' and conn_df2.soz_info_2[i] == 'IZ':  # nyní jsou IZ kanály označeny jako SOZ, s IZ už se nepočítá
        #     conn_df2.soz_info[i] = 'SOZ'
        else:
            conn_df.soz_info[i] = 'BRIDGE'

    #---odstranění BRIDGE záznamů
    #conn_df = conn_df.loc[conn_df['soz_info'] != 'BRIDGE']

    #---uložení do souboru
    conn_df.to_pickle('C:/Users/admin/ownCloud/BakalarskaPrace/cache/connectivity_wm_seeg_' + seeg + '_marked.pkl') #connectivity_wm_seeg_marked' + seeg + '.pkl')

    #----otevření a načtení souboru
    with open('C:/Users/admin/ownCloud/BakalarskaPrace/cache/connectivity_wm_seeg_' + seeg + '_marked.pkl', 'rb') as f:
        data4 = pickle.load(f)

# with open('cache/connectivity_wm_seeg_' + seeg + '_marked.pkl', 'rb') as f:
#     data2 = pickle.load(f)

conn_df[conn_df.keys()[3:-3]] = conn_df[conn_df.keys()[3:-3]].apply(pd.to_numeric)

# with open('C:/Users/admin/ownCloud/BakalarskaPrace/cache/connectivity_wm_seeg_015.pkl', 'rb') as f:
#     data_bridges_32 = pickle.load(f)


#----odstranění BRIDGE záznamů - u pacienta 005 z 744 záznamů 688 nBRIDGEs
print('záchytný bod č.2')

# ---všechny kanály:
channels = [conn_df.channel_name_1.unique(), conn_df.channel_name_2.unique()]
l_all_channels = len(channels[1])

# ---neoznačené kanály:
not_marked_channels = [conn_df.channel_name_1.loc[conn_df['soz_info_1'] == 'N/A'].unique(),
                       conn_df.channel_name_2.loc[conn_df['soz_info_1'] == 'N/A'].unique()]
len(not_marked_channels)
l_marked_channels = len(not_marked_channels[1])

#---info o zaznamech
print ('Pocet jednotlivych kanalu: %s \nPocet neoznacenych kanalu: %s ' % (l_all_channels, l_marked_channels))

zaznamy_SOZ = len(conn_df.loc[conn_df['soz_info'] == 'SOZ']) #pro zajímavost
zaznamy_NON_SOZ = len(conn_df.loc[conn_df['soz_info'] == 'NON_SOZ']) #pro zajímavost
zaznamy_BRIDGE = len(conn_df.loc[conn_df['soz_info'] == 'BRIDGE']) #pro zajímavost

print ('Pocet zaznamu dvojic kanalu: \nSOZ: %s\nNON_SOZ: %s\nBRIDGE: %s ' % (zaznamy_SOZ, zaznamy_NON_SOZ, zaznamy_BRIDGE))


# --- vytvoření DataFramu se záznamy, kde soz_info není BRIDGE
conn_nB_channels_df = conn_df.loc[conn_df['soz_info'] != 'neco'] #puvodne != BRIDGE
conn_df = conn_df.loc[conn_df['soz_info'] != 'neco']  #puvodne != BRIDGE

# conn_nB_channels_df = conn_nB_channels_df.loc[conn_df2['soz_info'] != 'NOT MARKED']

# conn_nB_channels_df.loc[conn_nB_channels_df['soz_info'] != 'SOZ'] #pro zajímavost

del conn_nB_channels_df['soz_info_1']
del conn_nB_channels_df['soz_info_2']

# ---přeindexování conn_nB_channels_df znovu od nuly
conn_nB_channels_df.reset_index(inplace=True)  # True
del conn_nB_channels_df['index']

conn_nB_channels_df.reset_index(inplace=True)  # True


# ---DataFrame conn_corr_df, přiřazení hodnot korelací jen nonBRIDGEs kanálům
print('Vytahuji nBRIDGE záznamy')

conn_corr_df = pd.DataFrame()
# conn_corr_df = conn_df.loc[conn_df['channel_name_1'] == conn_nB_channels_df.channel_name_1[0]] #---funkční zápis
# conn_df.loc[(conn_df['channel_name_1'] == 'A1') & conn_df['channel_name_2'].isin(['A2'])] #---funkční zápis
# conn_corr_df_pair = conn_df.loc[(conn_df['channel_name_1'] == conn_nB_channels_df.channel_name_1[l]) & conn_df['channel_name_2'].isin([conn_nB_channels_df.channel_name_2[l]])]

l_pairs = range(0, len(conn_nB_channels_df.channel_name_1))

for l in l_pairs:
    # print ('Selecting channels %s' %([conn_nB_channels_df.channel_name_1[l], conn_nB_channels_df.channel_name_2[l]]))
    conn_corr_df_pair = conn_df.loc[
        (conn_df['channel_name_1'] == conn_nB_channels_df.channel_name_1[l]) & conn_df['channel_name_2'].isin(
            [conn_nB_channels_df.channel_name_2[
                 l]])]  # chci vytáhnout conn_nB_channels_df z conn_df , zápis do conn_corr_df
    conn_corr_df = pd.concat([conn_corr_df, conn_corr_df_pair])

conn_corr_df['soz_info'] = ''
conn_corr_df.reset_index(inplace=True)  # True
del conn_corr_df['index']

# ---označení soz_info
conn_corr_df['soz_info'] = conn_corr_df['soz_info_1']
del conn_corr_df['soz_info_1']
del conn_corr_df['soz_info_2']

# pro zajímavost
print ('Počet BRIDGE záznamů: %s' % (len(conn_df) - len(conn_corr_df)))
print ('Počet NON_SOZ záznamů: %s\nPočet SOZ záznamů: %s' % (
    len(conn_corr_df.loc[conn_corr_df['soz_info'] != 'SOZ']),
    len(conn_corr_df.loc[conn_corr_df['soz_info'] != 'NON_SOZ'])))

# print('ALL channels: \n %s ' % conn_df)
print('Selected pairs of channels: \n %s ' % conn_nB_channels_df)
print('Data from selected pairs of channels: \n %s ' % conn_corr_df)


#---kontrola dat
len(conn_corr_df.loc[conn_corr_df['soz_info'] == 'SOZ'])
len(conn_df.loc[conn_corr_df['soz_info'] == 'SOZ'])
#len(data.loc[conn_corr_df['soz_info'] == 'SOZ'])

len(conn_corr_df.loc[conn_corr_df['soz_info'] == 'NON_SOZ'])
len(conn_df.loc[conn_corr_df['soz_info'] == 'NON_SOZ'])
#len(data.loc[conn_corr_df['soz_info'] == 'NON_SOZ'])

len(conn_corr_df.loc[conn_corr_df['soz_info'] == 'BRIDGE'])
len(conn_df.loc[conn_corr_df['soz_info'] == 'BRIDGE'])
#len(data.loc[conn_corr_df['soz_info'] == 'BRIDGE'])


#return(conn_corr_df, conn_df)
#----konec funkce


#-----klidně již hodit do souboru connectivity.py

#-------pro zajímavosr
len(conn_corr_df.loc[conn_corr_df['low_fc'] == 1])
len(conn_df.loc[conn_corr_df['low_fc'] == 1])

len(conn_df.loc[conn_corr_df['soz_info'] == 'BRIDGE'])


#------selekce dat podle low_fc
selected_low_fc = dict()
average_lin_corr_median = dict()
average_ren_median = dict()

low_fc_unique = conn_df.low_fc.unique()

# for low in range(0, len(low_fc_unique)):
#     selected_low_fc[low]  = conn_df.loc[conn_corr_df['low_fc'] == low_fc_unique[low]]
#     average_lin_corr_median[low] = sum(selected_low_fc[low].lin_corr_median)/len(selected_low_fc[low]) #---chci získat průměrné hodnoty všech sloupců
#     average_ren_median[low] = sum(selected_low_fc[low].ren_median) / len(selected_low_fc[low])  # ---chci získat průměrné hodnoty všech sloupců
#

#-----prumerne hodnoty
#conn_df = data4
conn_df[conn_df.keys()[3:-3]] = conn_df[conn_df.keys()[3:-3]].apply(pd.to_numeric)

average_values_df = conn_df.groupby(['low_fc', 'soz_info']).mean()



'''
#---případně stažení dat přímo z databáze

db_remote = {'user':'', 'pwd':'', 'host': '', 'port':'', 'database':''} 
db = db_remote
engine = sqla.create_engine('mysql+pymysql://{}:{}@{}:{}/{}'.format(db['user'],db['pwd'],db['host'],db['port'],db['database']))
conn = engine.connect()


if patient_id / 10 == 0:
    id = '00'
elif patient_id / 100 == 0:
    id = '0'
else:
    id = ''

id += str(patient_id) # volba pacienta ve formátu 01 až 49

columns = 'channel_name_1, channel_name_2, lin_corr_median, lin_corr_std'

#print('požadavek: SELECT * FROM connectivity_Fnusa.lin_entrop_002 WHERE channel_name_1 = "X,1" and channel_name_2 = "X,6";')

k1 = range(0, len(conn_nB_channels_df))
#k1 = range(13,17) #conn_nB_channels_df

table_conn = pd.DataFrame()

for k in k1:
    nB_channel_name_1 = conn_nB_channels_df.channel_name_1[k] # oba způsoby: conn_nB_channels_df.loc[5,'channel_name_1']
    nB_channel_name_2 = conn_nB_channels_df.channel_name_2[k]

    query = 'SELECT {} FROM connectivity_Fnusa.lin_entrop_{} WHERE channel_name_1 = "{}" and channel_name_2 = "{}";'.format(columns, id, nB_channel_name_1, nB_channel_name_2)
    #query = 'SELECT {} FROM connectivity_Fnusa.lin_entrop_002 WHERE channel_name_1 = "{}" and channel_name_2 = "{}";'.format(columns, nB_channel_name_1, nB_channel_name_2) #funguje

    print (query)

    conn_corr_df = pd.read_sql(query,conn) #chci zápis všech query do jedné tabulky

    conn_corr_df['soz_info'] = 'N/A'
    info = conn_nB_channels_df.soz_info[k]
    conn_corr_df.soz_info[0:len(conn_nB_channels_df.soz_info)] = info #ne všem, aby pak nepřepsal celou tabulku

    conn_corr_df

    table_conn = pd.concat([table_conn,conn_corr_df])

table_conn

#table_conn_SOZ = table_conn['soz_info' == 'SOZ'] #vybrat jen pro SOZ

table_conn_SOZ = pd.DataFrame()
table_conn_NON_SOZ = pd.DataFrame()

table_conn_SOZ = table_conn.loc[(table_conn.soz_info == "SOZ")]
table_conn_NON_SOZ = table_conn.loc[(table_conn.soz_info == "NON_SOZ")]

'''
