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

from funkce2 import *
from sklearn import metrics
from roc_function import roc
from lib.utilities import load_or_get, save_data, load_data


"""--------------------
POPIS:
vytvoření jedné ROC pro všechny vybrané pacienty z normalizovaných hodnot
-------------------------------------------------------------------------------------"""
databases = [ 'LL_alg_Fnusa', 'Matt_alg_Fnusa', 'hilbert_alg_v2']

#--------vstupní parametry:
#patients = range(22, 26)
patients = [5, 7, 15, 18, 32]
database = databases[2] #volba 0, 1, 2
#----------


#-------důležité!---------pro výpočet dat resected odkomentovat druhý řádek, zakomentovat první, aby se data nepřepsala !
file_name = ("fpr" + '-'.join(str(pat) for pat in patients) + str(database))
#file_name = ("fpr_resected" + '-'.join(str(pat) for pat in patients) + str(database))

#----vytvoření proměnných
fpr = dict()
tpr = dict()
total_count = dict()
total_count_all_patients = dict()
normed_count_all_patients = dict()
doctor = dict()

#hodnoty tpr a fpr uložit jako tpr_vybrani_pacienti_algoritmus

data = load_data(file_name)

if 'tpr' in data:

    tpr = data['tpr']
    fpr = data['fpr']
else:
    #----získání hodnot fpr, tpr, počtů detekcí a lékařského označení
    for vybrany_pacient in patients:
        #----výpočet pro lékařsky označené záznamy
        fpr[vybrany_pacient], tpr[vybrany_pacient], total_count[vybrany_pacient], doctor[vybrany_pacient] = load_or_get(roc, database, vybrany_pacient, vybrany_pacient, 'channel_name')

        #---nebo pro výpočet resekované tkáně - funkce roc_resected:
        #fpr[vybrany_pacient], tpr[vybrany_pacient], total_count[vybrany_pacient], doctor[vybrany_pacient] = load_or_get(roc_resected, database, vybrany_pacient, vybrany_pacient, 'channel_name')


    #---ověření hodnot
    total_count.get(patients[1])

    len(total_count.get(patients[1]))
    len(total_count.get(patients[2]))

    # ---celkový počet kanálů
    len(total_count_all_patients)
    #len(doctor_table)

    #--- normalizace
    sum_total_count = dict()
    start = 0

    for j in range(0, len(patients)):
        sum_total_count[j] = sum(total_count.get(patients[j]))

        for radky in range(0, len(total_count.get(patients[j]))):  # len(total_count_all_patients)):
            normed_count_all_patients[j] = total_count.get(patients[j]).astype(np.float) / sum_total_count.get(j)
            #tcap.loc[radky, 'normed'] = float((tcap.loc[radky, 'total_count'])) / sum_total_count[j]  # / (float(table.loc[i, 'FP']) + float(table.loc[i, 'TN']))
        #start = start + len(total_count.get(patients[j]))


    #--- vytvoření prázdných DataFramů
    #total_count_all_patients = pd.DataFrame(0, index=np.arange(0), columns=['total_count', 'patient_No','channel_name']) #obsáhlejší verze
    total_count_all_patients = pd.DataFrame(0, index=np.arange(0), columns=['total_count'])#, 'patient_No','channel_name']) #kratší verze
    doctor_table= pd.DataFrame(0, index=np.arange(0), columns=['doctor']) #ev. SJEDNOTIT do jednoho, aby se předešlo chybám, nepřišla jsem však jak na to..
    normed_table= pd.DataFrame(0, index=np.arange(0), columns=['normed']) #ev. SJEDNOTIT do jednoho, aby se předešlo chybám, nepřišla jsem však jak na to..


    #----doplnění hodnot prvního pacienta
    total_count_all_patients = total_count.get(patients[0]) #kratší verze
    normed_table = normed_count_all_patients.get(0)
    doctor_table = doctor.get(patients[0])


    #---spojení počtu detekcí u vybraných pacientů do jednoho dict
    if len(patients)>1:
        for i in range(1,len(patients)): #potom přidat +1, aby bral včetně
            total_count_all_patients=np.append(total_count_all_patients, total_count.get(patients[i]))#total_count_all_patients.append(total_count.get(patients[i]))
            normed_table = np.append(normed_table, normed_count_all_patients.get(i))
            doctor_table=np.append(doctor_table, doctor.get(patients[i]))#doctor_table.append(doctor.get(patients[i]))

            #total_count_all_patients=total_count_all_patients.append(total_count.get(patients[3]))


    #---vytvoření DF pro normalizaci hodnot
    tcap = pd.DataFrame(0, index=np.arange(0), columns=['total_count', 'normed', 'doctor'])#, 'patient_No','channel_name']) #kratší verze
    tcap['total_count'] = total_count_all_patients #možno také přidat pouze head do total_count_all_patients
    tcap['doctor']=doctor_table
    tcap['normed']=normed_table

    #--seřazení od nejvyššího
    tcap = tcap.sort_values('normed', ascending=0)

    #--přeindexovat od nuly #update index after sorting dataframe
    tcap=tcap.reset_index(drop=True)

    #-----------výpočet FPR, TPR, později z tohoto udělat funkci pro tento skript
    # ------ výpočet FP, FN, TP, TN
    table = pd.DataFrame(0, index=np.arange(len(tcap)), columns=['FP', 'FN', 'TP', 'TN', 'FPR', 'TPR'])

    s = pd.DataFrame(0, index=np.arange(len(tcap)), columns=['doctor','detector'])

    s.loc['detector'] = 0  # později dát mimo cyklus
    s['doctor'] = tcap.doctor

    #update index after sorting dataframe
    s=s.reset_index(drop=True)

    #---- výpočet hodnot TP, FP, FN, TN
    for table_i in range(0, len(tcap)):  # count_df.soz_info)):

        for i in range(0, len(tcap)):

            a = int(s.loc[i, 'detector'])
            b = int(s.loc[i, 'doctor'])

            if a == 1 and b == 1:
                to_increment = 'TP'

            elif a == 1 and b == 0:  # s.loc[i,'detector']==1 and s.loc[i,'doctor']==0:
                to_increment = 'FP'

            elif a == 0 and b == 1:  # s.loc[i,'detector']==0 and s.loc[i,'doctor']==1:
                to_increment = 'FN'

            elif s.loc[i, 'detector'] == 0 and s.loc[i, 'doctor'] == 0:
                to_increment = 'TN'

            table.loc[table_i, to_increment] += 1

            s.set_value(table_i, 'detector', 1)


    #------ výpočet FPR a TPR, zápis do table
    for i in range(0, len(table)):

        if table.loc[i, 'FP'] != 0:
            table.loc[i, 'FPR'] = float(table.loc[i, 'FP']) / (float(table.loc[i, 'FP']) + float(table.loc[i, 'TN']))
        else:
            table.loc[i, 'FPR'] = 0

        if table.loc[i, 'TP'] != 0:
            table.loc[i, 'TPR'] = float(table.loc[i, 'TP']) / (float(table.loc[i, 'TP']) + float(table.loc[i, 'FN']))
        else:
            table.loc[i, 'TPR'] = 0

    fpr = np.array(table['FPR'])
    tpr = np.array(table['TPR'])

    # Ulož data
    data = {}
    data['tpr'] = tpr
    data['fpr'] = fpr
    save_data(file_name, data)


# ----Vytvoření názvu/legendy grafu
databases = ['LL_alg_Fnusa', 'Matt_alg_Fnusa', 'hilbert_alg_v2']
nazev_grafu = []

if database == databases[0]:  # volba 0, 1, 2
    nazev_grafu = 'algoritmus zalozeny na vypoctu delky cary'
elif database == databases[1]:
    nazev_grafu = 'algoritmus zalozeny na vypoctu frekvencni homogenity'
elif database == databases[2]:
    nazev_grafu = 'algoritmus zalozeny na vypoctu Hilbertovy transformace'

#----výsledná ROC pro vybrané pacienty
plt.figure('ROC')
markerline, stemlines, baseline = plt.stem(fpr, tpr, '-.', 'g')
#plt.setp(baseline, 'color', 'r', 'linewidth', 2)
plt.setp(baseline, 'linewidth', 2.0, 'marker', '+')  # , 'linestyle', '--'

plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Pacienti cislo ' + str(patients) + ',  ' + str(nazev_grafu)) #'Pacient cislo ' + str(patient) + ' , AUC: ' + str(AUC[patient]) )

AUC = dict()
AUC[nazev_grafu] = round(metrics.auc(fpr, tpr), 3)

#plt.legend(str(AUC[nazev_grafu]))
plt.show()

#------jiné vykreslení
import numpy as np; np.random.seed(10)
import seaborn as sns; sns.set(color_codes=True)
#x, y = np.random.multivariate_normal(mean, cov, size=50).T
x = fpr
y = tpr
#ax = sns.kdeplot(y)

#ax = sns.kdeplot(x, shade=True, color="r")

#sns.distplot(y, hist=False, color="g", kde_kws={"shade": True})







