import os
from unipath import Path
import pathlib
import pandas as pd
import numpy as np
import copy
import re
import pyprind
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
from keras.preprocessing.text import Tokenizer
from keras_preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense, Embedding, LSTM, SpatialDropout1D
from sklearn.model_selection import train_test_split
from keras.utils.np_utils import to_categorical
import re
from keras.models import model_from_json
from keras.models import load_model
from pandas import DataFrame

import nltk
nltk.download('stopwords')
nltk.download('wordnet') 
from nltk.stem.wordnet import WordNetLemmatizer
import numpy as np
import re
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from string import punctuation

import sqlite3
import pickle
print ('********** Módulos importados')

#FUNCIONES

#stop_words_sp = set(stopwords.words('spanish'))
#stop_words_en = set(stopwords.words('english')) #Concatenar las stopwords aplicándose a una cuenta que genera contenido en inglés y español
#stop_words = stop_words_sp | stop_words_en
#print(stop_words_sp)
def generarStopWords():
    ##Creating a list of stop words and adding custom stopwords
    stop_words = set(stopwords.words('spanish'))
    ##Creating a list of custom stopwords
    new_words = ['restaurante', 'saboresysalud']
    stop_words = stop_words.union(new_words)
    return stop_words

stop = generarStopWords()
porter = PorterStemmer()

def normalize(s):
    replacements = (
        ("á", "a"),
        ("é", "e"),
        ("í", "i"),
        ("ó", "o"),
        ("ú", "u"),
        ("à", "a"),
        ("è", "e"),
        ("ì", "i"),
        ("ò", "o"),
        ("ù", "u"),
        #("ñ", "n"),
    )
    for a, b in replacements:
        s = s.replace(a, b).replace(a.upper(), b.upper())
    return s

def preprocessor(text):#tokenizer
    #text = re.sub('[^a-zA-z0-9ñ\s]','',text)
    text=re.sub("</?.*?>"," <> ",text) #remove tags
    text = re.sub('<[^>]*>', '', text)
    emoticons = re.findall('(?::|;|=)(?:-)?(?:\)|\(|D|P)', text.lower())
    text = re.sub('[\W]+', ' ', text.lower()) + ' '.join(emoticons).replace('-', '')
    
    text = normalize(text)
    
    text = ''.join([c if c not in punctuation else ' '+c+' ' \
                    for c in text]).lower()    
    #text=re.sub("(\\d|\\W)+"," ",text) # remove special characters and digits
    ##Stemming
    text = text.split()
    #ps=PorterStemmer()
    #Lemmatisation
    lem = WordNetLemmatizer()
    text = [lem.lemmatize(word) for word in text if not word in  
            stop]
    tokenized = " ".join(text)
    return tokenized

def guardarRNN(model,nombreArchivoModelo):
    print("Guardando Red Neuronal en Archivo")  
    model.save(nombreArchivoModelo+'.h5')
    print("Red Neuronal Grabada en Archivo")   
    
def cargarRNN(nombreArchivoModelo):
    model = load_model(nombreArchivoModelo+'.h5')  
    print("Red Neuronal Cargada desde Archivo") 
    return model

def guardarTokenizer(tokenizer,nombreArchivoTokenizer):
    with open(nombreArchivoTokenizer+'.pickle', 'wb') as handle:
        pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)

def cargarTokenizer(nombreArchivoTokenizer):
    with open(nombreArchivoTokenizer+'.pickle', 'rb') as handle:
        tokenizer = pickle.load(handle)
    return tokenizer

def RepresentsInt(s):
    try: 
        int(s)
        print(s)
        return True
    except ValueError:
        return False
print('********* Funciones definidas')

import json

dirBaseDataset=pathlib.Path().absolute()
dirBaseDatasetPos=str(dirBaseDataset)+"\DatasetSentimientosRestaurante\data\output\pos"
#print(dirBaseDatasetPos)
listaArchivosDatasetPos = os.listdir(dirBaseDatasetPos)
comentarios = []
print("********** Cargando comentarios")
for archivo in listaArchivosDatasetPos:
    dirArchivo=dirBaseDatasetPos+"\\"+archivo
    if os.path.isfile(dirArchivo) and ((archivo.endswith('.json') or archivo.endswith('.JSON'))):
        with open(dirArchivo) as f_in:
            data = json.load(f_in) 
            i=0
            for comentario in data:
                i=i+1
                comentario=" ".join(comentario.split())
                if RepresentsInt(comentario):
                    print(archivo)
                    print(comentario)
                    print(i)
                if comentario == '':
                    print(archivo)
                    print(comentario)
                    print(i)
                comentarios.append([comentario,1])
print("Cantidad de comentarios cargados:",len(comentarios))

dirBaseDataset=pathlib.Path().absolute()
dirBaseDatasetPos=str(dirBaseDataset)+"\DatasetSentimientosRestaurante\data\output\\neg"
#print(dirBaseDatasetPos)
listaArchivosDatasetPos = os.listdir(dirBaseDatasetPos)
for archivo in listaArchivosDatasetPos:
    dirArchivo=dirBaseDatasetPos+"\\"+archivo
    if os.path.isfile(dirArchivo) and ((archivo.endswith('.json') or archivo.endswith('.JSON'))):
        with open(dirArchivo) as f_in:
            data = json.load(f_in) 
            for comentario in data:
                comentario=" ".join(comentario.split())
                comentarios.append([comentario,0])
#print("Cantidad de comentarios cargados:",len(comentarios))
dfOriginal = DataFrame (comentarios,columns=['comentario','sentimiento'])
print('Cantidad total de comentarios cargados:',dfOriginal.shape[0])
dfOriginal.head(10)

import matplotlib.pyplot as plt
from collections import Counter
Y=dfOriginal['sentimiento'].tolist()
#Y.extend(y_test.tolist()) #para analizar la frecuencia de todo el conjunto de datos

# Utiliza Counter para contar las frecuencias de los elementos en la lista
frecuencias = Counter(Y)

# Separa las claves (elementos) y los valores (frecuencias) en listas separadas
elementos = list(frecuencias.keys())
frecuencias = list(frecuencias.values())

# Aumenta el tamaño del gráfico
plt.figure(figsize=(10, 6))

# Crea un gráfico de barras
plt.bar(elementos, frecuencias)

# Etiquetas y título
plt.xlabel('Categorías')
plt.ylabel('Frecuencia')
plt.title('Gráfico de Frecuencia')

# Establece las etiquetas del eje X
plt.xticks(elementos)

# Muestra los valores de los elementos en el gráfico
for i, v in enumerate(frecuencias):
    plt.text(elementos[i], v + 0.1, str(v), ha='center')

print('0 es comentario negativo')
print('1 es comentario positivo')
# Muestra el gráfico
plt.show()

#PREPROCESAMIENTO
dfOriginal['comentario'] = dfOriginal['comentario'].apply(preprocessor)
df=copy.deepcopy(dfOriginal)
df.head(15)

#TOKENIZER
#import tensorflow as tf
#max_fatures = 2000
#tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=max_fatures, split=' ')
#lines=df['comentario'].values
#print(lines)
#tokenizer.fit_on_texts(lines)
#text_sequences = tokenizer.texts_to_sequences(lines)
#X = tf.keras.preprocessing.sequence.pad_sequences(text_sequences, padding='post')
#X

max_fatures = 2000
tokenizer = Tokenizer(num_words=max_fatures, split=' ')
tokenizer.fit_on_texts(df['comentario'].values)
X = tokenizer.texts_to_sequences(df['comentario'].values)
X = pad_sequences(X)
X

#DISEÑO DE RNN
embed_dim = 128
lstm_out = 196

model = Sequential()
model.add(Embedding(max_fatures, embed_dim,input_length = X.shape[1]))
model.add(SpatialDropout1D(0.4))
model.add(LSTM(lstm_out, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(2,activation='softmax'))
model.compile(loss = 'categorical_crossentropy', optimizer='adam',metrics = ['accuracy'])
model.summary()

#SPLITTING EN TRAIN Y TEST
Y = pd.get_dummies(df['sentimiento']).values
X_train, X_test, Y_train, Y_test = train_test_split(X,Y, test_size = 0.33, random_state = 42)
print(X_train.shape,Y_train.shape)
print(X_test.shape,Y_test.shape)

#ENTRENAMIENTO
batch_size = 256
model.fit(X_train, Y_train, epochs = 1, batch_size=batch_size, verbose = 1, use_multiprocessing= 'TRUE')

score,acc = model.evaluate(X_test, Y_test, verbose = 1, batch_size = batch_size)
print("score: %.2f" % (score))
print("acc: %.2f" % (acc))

#Predicciones con el conjunto de Test
import pandas as pd
y_pred = model.predict(X_test)

#Obtener la clase/sentimiento por cada predicción y valor real
y_pred_Clase = np.argmax(y_pred, axis=-1) 
y_test_Clase = np.argmax(Y_test, axis=-1) 
len(y_test_Clase)

#Presentar una muestra para comparar valores reales y predicciones
dataframeFinal=pd.DataFrame({'real':y_test_Clase, 'predicción': y_pred_Clase})
np.set_printoptions(formatter={'float': lambda X: "{0:0.0f}".format(X)})
dataframeFinal.head(10)

# Se evalúa el modelo con otras medidas de calidad y se presenta la matriz de confusión
from sklearn.metrics import confusion_matrix
import seaborn as sns
from sklearn import metrics  
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from matplotlib import*
from matplotlib.cm import register_cmap
import matplotlib.pyplot as plt 

MAE=metrics.mean_absolute_error(y_test_Clase, y_pred_Clase)
MSE=metrics.mean_squared_error(y_test_Clase, y_pred_Clase)
RMSE=np.sqrt(metrics.mean_squared_error(y_test_Clase, y_pred_Clase))

MAE=str(round(MAE, 4))
MSE=str(round(MSE, 4))
RMSE=str(round(RMSE, 4))

print('Mean Absolute Error (MAE):', MAE)  
print('Mean Squared Error (MSE):', MSE)  
print('Root Mean Squared Error (RMSE):', RMSE) 

accuracyModeloBase=str(accuracy_score(y_test_Clase,y_pred_Clase))
print('Accuracy: ' + accuracyModeloBase) 

precision=precision_score(y_test_Clase,y_pred_Clase, average='weighted')#average one of [None, 'micro', 'macro', 'weighted']
precision=str(round(precision, 4))
print('Precision: ',precision)

recall=recall_score(y_test_Clase,y_pred_Clase, average='weighted')
recall=str(round(recall, 4))
print('Recall: ',recall)

f1=f1_score(y_test_Clase,y_pred_Clase, average='weighted')
f1=str(round(f1, 4))
print('F1:',f1)

print('Matriz de confusión:')
print(confusion_matrix(y_test_Clase,y_pred_Clase))  

plt.figure(figsize=(15,10))
fx=sns.heatmap(confusion_matrix(y_test_Clase,y_pred_Clase), annot=True, fmt=".2f",cmap="GnBu")
fx.set_title('Confusion Matrix \n');
fx.set_xlabel('\n Valores de predicción\n')
fx.set_ylabel('Valores reales\n');
plt.show()

# Se presenta la calidad de clasificación por categoría y a nivel general
from sklearn.metrics import classification_report
print(classification_report(y_test_Clase,y_pred_Clase))

#GUARDAR MODELO ENTRENADO
nombreArchivoModelo='modeloRNN'
guardarRNN(model,nombreArchivoModelo)

#CARGAR MODELO PARA COMPROBAR
nombreArchivoModelo='modeloRNN'
model=cargarRNN(nombreArchivoModelo) 
model.summary()

#EVALUAR POS_ACC Y NEG_ACC
pos_cnt, neg_cnt, pos_correct, neg_correct = 0, 0, 0, 0
for x in range(len(X_test)):
    if x % 1000==0:
        print(x)
    result = model.predict(X_test[x].reshape(1,X_test.shape[1]),batch_size=1,verbose = 0)[0]
   
    if np.argmax(result) == np.argmax(Y_test[x]):
        if np.argmax(Y_test[x]) == 0:
            neg_correct += 1
        else:
            pos_correct += 1
       
    if np.argmax(Y_test[x]) == 0:
        neg_cnt += 1
    else:
        pos_cnt += 1

print("pos_acc", pos_correct/pos_cnt*100, "%")
print("neg_acc", neg_correct/neg_cnt*100, "%")

#Habilitar siguiente línea para cargar modelos guardados
tokenizer, model=cargarTokenizeryModeloRNN()
twt = ['Regular atención']
texto_respuesta=predecirSentimiento(tokenizer, model,[twt])
print(texto_respuesta)

#Nuevo(s) comentario(s) con etiqueta(s) en el conjunto de entrenamiento
data = ['Regular atención',0]
twt = [data[0]]
salida = data[1]
classes = np.array([0, 1])        
print(twt)
#vectorizing the tweet by the pre-fitted tokenizer instance
twt = tokenizer.texts_to_sequences(twt)
#padding the tweet to have exactly the same shape as `embedding_2` input
twt = pad_sequences(twt, maxlen=X.shape[1], dtype='int32', value=0)
print(twt)
#Salida en formato binario: similar a get_dummies
if(salida) == 0:# comentario negativo
    salida=[1,0]
else:#comentario positivo
    salida=[0,1]
X_train=np.vstack([X_train, twt])
Y_train=np.vstack([Y_train, salida])

batch_size = 256
model.fit(X_train, Y_train, epochs = 1, batch_size=batch_size, verbose = 1, use_multiprocessing= 'TRUE')

#Nuevo comentario con etiqueta
data = ['Regular atención',0] # se indica que es un comentario negativo
twt = [data[0]]
salida = data[1]
#Salida en formato binario: similar a get_dummies
if(salida) == 0:
    salida=[1,0]
else:
    salida=[0,1]
#print(salida)
#Lista a array
salida = np.array([salida])

num_Columnas=model.input_shape[1]
#vectorizing the tweet by the pre-fitted tokenizer instance
twt = tokenizer.texts_to_sequences(twt)
#padding the tweet to have exactly the same shape as `embedding_2` input
twt = pad_sequences(twt, maxlen=num_Columnas, dtype='int32', value=0)
print(twt)

#Re-entrenamiento con nuevo sample
model.fit(twt, salida, epochs = 10, batch_size=1, verbose = 1, use_multiprocessing= 'TRUE')

#Probar con el(los) comentario(s) recientemente aprendido(s)
twt = ['Regular atención']
texto_respuesta=predecirSentimiento(tokenizer, model,[twt])
print(texto_respuesta)