# Universidad de Guanajuato
"""
Fuentes:
Jason Brownlee. How to Develop a Face Recognition System Using FaceNet in Keras.
https://machinelearningmastery.com/how-to-develop-a-face-recognition-system-using-facenet-in-keras-and-an-svm-classifier/


"""

from mtcnn.mtcnn import MTCNN
from keras.models import load_model
from keras_facenet import FaceNet
from sklearn.preprocessing import Normalizer
from sklearn.preprocessing import LabelEncoder
from sklearn.svm import SVC
from skimage.transform import resize
from skimage import io
from numpy import asarray
import numpy as np
import cv2 as cv2

from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget, QTextEdit, QLabel
from pyqtgraph import ImageView

isSaveClicked = False

# Regresa la porción de la cara dentro de una imagen
def returnFace(captura):
    soloCara = captura.copy()
    soloCara = soloCara[bbox[1]: bbox[1] + bbox[3], bbox[0]: bbox[0] + bbox[2]]
    return soloCara

# Ajusta la imagen de un rostro a 160x160 y la deja lista para ser usada en el modelo
def saveFace(face):
    face = resize(face, (160,160))
    caraNorm = face.reshape((1,160,160,3))
    return caraNorm

# Recibe un rostro y retorna el vector de caracteristicas del rostro
def convert(caraNorm):
    embeding = model.predict(caraNorm)
    return asarray(embeding[0])

# Normaliza el vector de caracteristicas de un rostro retorna el vector ya normalizado
def normalizar(nuevaCaraV):
    normalizador = Normalizer().fit(nuevaCaraV)
    temp = normalizador.transform(nuevaCaraV)
    return temp

def saveNewFace(textEdit, label):
    nombre = textEdit.toPlainText()
    n = nombre
    label.setText("Cargando...")
    return n
    # nombres.append(nombre)

def getName(textEdit):
    nombre = textEdit.toPlainText()
    textEdit.clear()
    return nombre

def getFlag(flag):
    print("switch pressed")
    if (isSaveClicked == False):
        return True
    else:
        return False

if __name__ == '__main__':
    cam = cv2.VideoCapture(0)
    mirror = True
    detector = MTCNN()
    model = load_model('./facenet_keras.h5')
    # Almacena los rostros
    caras = []
    # Almacena los nombres de cada rostro
    nombres = []
    captura = []
    isSaveClicked = False
    # Codigo interfaz
    app = QApplication([])
    win = QMainWindow()
    x=win.width()*0.8
    y=win.height()*1.5
    win.setFixedSize(x,y)
    central_widget = QWidget()
    txt = QTextEdit('nombre', central_widget)
    txt.setFixedSize(txt.width(), txt.height())
    button2 = QPushButton('Guardar nueva cara', central_widget)
    label = QLabel("Introduce un nombre", central_widget)
    button2.clicked.connect(lambda: saveNewFace(txt,label))
    layout = QVBoxLayout(central_widget)
    layout.addWidget(label)
    layout.addWidget(button2)
    layout.addWidget(txt)
    win.setCentralWidget(central_widget)
    win.show()

    image_view = ImageView()
    image_view.ui.histogram.hide()
    image_view.ui.roiBtn.hide()
    image_view.ui.menuBtn.hide()
    layout.addWidget(image_view)
    #app.exit(app.exec_())

    while True:
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

        ret_val, img = cam.read()

        if mirror:
            img = cv2.flip(img, 1)
        captura = cv2.resize(img, (320, 240))
        faces = detector.detect_faces(captura)



        if len(faces) > 0:
            for k in range(1):
                bbox = faces[k]['box']
                keypoints = faces[k]['keypoints']

                # Guarda un rostro nuevo
                # if cv2.waitKey(33) == ord('s'):

                if label.text() == "Cargando...":
                # Crea un vector que contendrá el nuevo rostro
                    print("nueva cara")
                    nuevaCaraV = []

                    soloCara = returnFace(captura)
                    caraNorm = saveFace(soloCara)
                    caraNorm = convert(caraNorm)
                    nuevaCaraV.append(caraNorm)
                    nuevaCaraV = normalizar(nuevaCaraV)

                    # Vector que almacenará las caracteristicas del vector del rostro normalizado
                    temp = []
                    for valor in nuevaCaraV[0]:
                        temp.append(valor)

                    caras.append(temp)
                    # nombre = input("Escribe tu nombre: ")
                    nombre = saveNewFace(txt, label)
                    nombres.append(nombre)
                    isSaveClicked = False
                    label.setText(nombre)

                # Cuando tengamos datos almacenados en caras comenzamos a comparar rostros
                if len(caras) > 0:
                    caraPruebaV = []
                    caraPrueba = returnFace(captura)


                    if caraPrueba.shape[0] > 0 and caraPrueba.shape[1] > 0:

                        soloCaraPrueba  = saveFace(caraPrueba)
                        soloCaraPrueba = convert(soloCaraPrueba)
                        caraPruebaV.append(soloCaraPrueba)
                        caraPruebaV = normalizar(caraPruebaV)
                        # Resultado o distancia menor (Mayor correspondencia de vector de rostros)
                        resultado = 100

                        for cara in caras:
                            suma = 0.0
                            #Calcular la distancia entre los vectores de la cara de prueba con los almacenados en caras
                            for i in range(128):
                                suma = suma + pow(caraPruebaV[0][i] - cara[i], 2)

                            distancia = pow(suma, 0.5)

                            # Si la distancia calculada es menor al resultado previo se reemplaza porque el rostro en prueba
                            # es mas "parecido" al almacenado
                            if  distancia < resultado:
                                # Guardamos el indice del nombre correspondiente a la cara mas parecida
                                indice = caras.index(cara)
                                resultado = distancia

                        # Si la distancia entre los vectores es menor a 1 consideramos que la estimación es acertada
                        if resultado < 1:
                            cv2.putText(captura, nombres[indice], (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), lineType=cv2.LINE_AA)
                            # cv2.circle(captura,(keypoints['right_eye']), 15, (0,0,0), 2)
                            # cv2.circle(captura,(keypoints['left_eye']), 15, (0,0,0), 2)
                            # cv2.circle(captura,(keypoints['nose']), 10, (0,0,255), -1)
                            # cv2.putText(captura, 'Feliz Navidad', (keypoints['mouth_left']), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), lineType=cv2.LINE_AA)
                            cv2.circle(captura, (10,15), 5,(0,255,0), -1 )
                            label.setText(nombres[indice])
                        else:
                            label.setText('Desconocido')
                            cv2.putText(captura, 'Desconocido', (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), lineType=cv2.LINE_AA)
                            cv2.circle(captura, (10,15), 5,(0,0,255), -1)

                captura = cv2.rectangle(captura, (bbox[0], bbox[1]), (bbox[0]+bbox[2], bbox[1]+bbox[3]), (0,255,0))

        image_view.setImage(captura.T)
        # cv2.imshow('Proyecto IA', captura)

    cam.release()
    cv2.destroyAllWindows()