#!/usr/bin/env python

"""
train_SVM.py
    
VARPA, University of Coruna
Mondejar Guerra, Victor M.
26 Oct 2017
"""

from sklearn import metrics
import numpy as np

class performance_measures:
    def __init__(self, n):
        self.n_classes          = n
        self.confusion_matrix   = np.empty([])
        self.Recall             = np.empty(n)
        self.Precision          = np.empty(n)
        self.Specificity        = np.empty(n)
        self.Acc                = np.empty(n)
        self.F_measure          = np.empty(n)

        self.gmean_se          = 0.0
        self.gmean_p           = 0.0

        self.Overall_Acc        = 0.0
        self.kappa              = 0.0
        self.Ij                 = 0.0
        self.Ijk                = 0.0



# Compute Cohen' kappa from a confussion matrix
# Kappa value:
#    < 0.20  Poor
# 0.21-0.40  Fair
# 0.41-0.60  Moderate
# 0.61-0.80  Good
# 0.81-1.00  Very good
def compute_cohen_kappa(confusion_matrix):
    prob_expectedA = np.empty(len(confusion_matrix))
    prob_expectedB = np.empty(len(confusion_matrix))
    prob_observed = 0
    
    for n in range(0, len(confusion_matrix)):
        prob_expectedA[n] = sum(confusion_matrix[n,:]) / sum(sum(confusion_matrix))
        prob_expectedB[n] = sum(confusion_matrix[:,n]) / sum(sum(confusion_matrix))
    
        prob_observed = prob_observed + confusion_matrix[n][n]

    prob_expected = np.dot(prob_expectedA, prob_expectedB)
    prob_observed = prob_observed / sum(sum(confusion_matrix))  

    kappa = (prob_observed - prob_expected) / (1 - prob_expected)

    return kappa, prob_observed, prob_expected

# Compute the performance measures following the AAMI recommendations.
# Using sensivity (recall), specificity (precision) and accuracy 
# for each class: (N, SVEB, VEB, F)
def compute_AAMI_performance_measures(predictions, gt_labels):
    n_classes = 4 #5
    pf_ms = performance_measures(n_classes)

    # TODO If conf_mat no llega a clases 4 por gt_labels o predictions...
    # hacer algo para que no falle el codigo...
    # NOTE: added labels=[0,1,2,3])...

    # Confussion matrix
    conf_mat = metrics.confusion_matrix(gt_labels, predictions, labels=[0,1,2,3])
    conf_mat = conf_mat.astype(float)
    pf_ms.confusion_matrix = conf_mat

    # Overall Acc
    pf_ms.Overall_Acc = metrics.accuracy_score(gt_labels, predictions)

    # AAMI: Sens, Spec, Acc 
    # N: 0, S: 1, V: 2, F: 3                        # (Q: 4) not used
    for i in range(0, n_classes):
        TP = conf_mat[i,i]
        FP = sum(conf_mat[:,i]) - conf_mat[i,i]
        TN = sum(sum(conf_mat)) - sum(conf_mat[i,:]) - sum(conf_mat[:,i]) + conf_mat[i,i]
        FN = sum(conf_mat[i,:]) - conf_mat[i,i]

        if i == 2: # V 
            # Exceptions for AAMI recomendations:
            # 1 do not reward or penalize a classifier for the classification of (F) as (V)
            FP = FP - conf_mat[i][3]
        
        pf_ms.Recall[i]       = TP / (TP + FN)
        pf_ms.Precision[i]    = TP / (TP + FP)
        pf_ms.Specificity[i]  = TN / (TN + FP); # 1-FPR
        pf_ms.Acc[i]          = (TP + TN) / (TP + TN + FP + FN)

        if TP == 0:
            pf_ms.F_measure[i] = 0.0
        else:
            pf_ms.F_measure[i] = 2 * (pf_ms.Precision[i] * pf_ms.Recall[i] )/ (pf_ms.Precision[i] + pf_ms.Recall[i])

    # Compute Cohen's Kappa
    pf_ms.kappa, prob_obsv, prob_expect = compute_cohen_kappa(conf_mat)

    # Compute Index-j   recall_S + recall_V + precision_S + precision_V
    pf_ms.Ij = pf_ms.Recall[1] + pf_ms.Recall[2] + pf_ms.Precision[1] + pf_ms.Precision[2]

    # Compute Index-jk
    w1 = 0.5
    w2 = 0.125
    pf_ms.Ijk = w1 * pf_ms.kappa + w2 * pf_ms.Ij

    return pf_ms


# Export to filename.txt file the performance measure score
def write_AAMI_results(performance_measures, filename):

    f = open(filename, "w") 

    f.write("Ijk: " + str(format(performance_measures.Ijk, '.4f')) + "\n")
    f.write("Ij: " + str(format(performance_measures.Ij, '.4f'))+ "\n")
    f.write("Cohen's Kappa: " + str(format(performance_measures.kappa, '.4f'))+ "\n\n")

    # Conf matrix
    f.write("Confusion Matrix:"+ "\n\n")
    f.write("\n".join(str(elem) for elem in performance_measures.confusion_matrix.astype(int))+ "\n\n")

    f.write("Overall ACC: " + str(format(performance_measures.Overall_Acc, '.4f'))+ "\n\n")

    f.write("mean Acc: " + str(format(np.average(performance_measures.Acc[:]), '.4f'))+ "\n")
    f.write("mean Recall: " + str(format(np.average(performance_measures.Recall[:]), '.4f'))+ "\n")
    f.write("mean Precision: " + str(format(np.average(performance_measures.Precision[:]), '.4f'))+ "\n")
  

    f.write("N:"+ "\n\n")
    f.write("Sens: " + str(format(performance_measures.Recall[0], '.4f'))+ "\n")
    f.write("Prec: " + str(format(performance_measures.Precision[0], '.4f'))+ "\n")
    f.write("Acc: " + str(format(performance_measures.Acc[0], '.4f'))+ "\n")

    f.write("SVEB:"+ "\n\n")
    f.write("Sens: " + str(format(performance_measures.Recall[1], '.4f'))+ "\n")
    f.write("Prec: " + str(format(performance_measures.Precision[1], '.4f'))+ "\n")
    f.write("Acc: " + str(format(performance_measures.Acc[1], '.4f'))+ "\n")

    f.write("VEB:"+ "\n\n")
    f.write("Sens: " + str(format(performance_measures.Recall[2], '.4f'))+ "\n")
    f.write("Prec: " + str(format(performance_measures.Precision[2], '.4f'))+ "\n")
    f.write("Acc: " + str(format(performance_measures.Acc[2], '.4f'))+ "\n")

    f.write("F:"+ "\n\n")
    f.write("Sens: " + str(format(performance_measures.Recall[3], '.4f'))+ "\n")
    f.write("Prec: " + str(format(performance_measures.Precision[3], '.4f'))+ "\n")
    f.write("Acc: " + str(format(performance_measures.Acc[3], '.4f'))+ "\n")


    f.close()