from huggingface_hub import InferenceClient
import streamlit as st
import pandas as pd
import plotly.express as px
from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
import nltk
from nltk.corpus import stopwords
from wordcloud import WordCloud
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import numpy as np
import plotly.graph_objects as go
import os

client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
medios = ["reforma.com", "eluniversal.com.mx", "excelsior.com.mx", "animalpolitico.com", "latinus.us", "jornada.com.mx", "radioformula.com.mx"]
candidatos = {"Xochitl Gálvez vs Claudia Sheinbaum": ("Xóchitl Gálvez", "Claudia Sheinbaum"), "Rocío Nahle vs Pepé Yunes": ("Rocío Nahle", "José Yunés Zorrilla"), "Alejandro Armenta vs Eduardo Rivera": ("Alejandro Armenta", "Eduardo Rivera")}

def generar_texto(prompt, tipo_prompt):
    if tipo_prompt == "sentimientos":
        response = client.text_generation(f"Califica sentimientos: {prompt}")
    elif tipo_prompt == "palabras_clave":
        response = client.text_generation(f"Extrae las palabras clave de estas noticias: {prompt}")
    elif tipo_prompt == "sintesis":
        response = client.text_generation(f"Crea un resumen a modo de síntesis de cada medio: {prompt}")
    return response

def obtener_texto_noticia(candidato, medio):
    return f"Noticia sobre {candidato} en {medio}"

def extraer_palabras_clave(texto):
    response = generar_texto(texto, "palabras_clave")
    keywords = response.split(": ")[1].split(", ")
    return keywords

def sintetizar_texto(texto):
    response = generar_texto(texto, "sintesis")
    sintesis = response.split(": ")[1]
    return sintesis

def analizar_sentimientos(texto):
    response = generar_texto(texto, "sentimientos")
    sentimiento = response.split(": ")[1]
    return sentimiento

def generate_wordcloud(texto):
    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(texto)
    plt.figure(figsize=(10, 5))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.axis('off')
    st.pyplot(plt)

def generar_grafica_barras(df):
    fig = px.bar(df, x='Medio', y='Sentimiento', color='Candidato', title='Sentimientos por Medio')
    st.plotly_chart(fig)

def generar_nube_palabras_3d(keywords, relevancia_minima):
    embeddings = np.random.rand(len(keywords), 768)
    df = pd.DataFrame(embeddings, columns=[f'Feature_{i}' for i in range(768)])
    df['Keyword'] = keywords
    pca = PCA(n_components=3)
    scaler = StandardScaler()
    df_scaled = scaler.fit_transform(df.iloc[:, :-1])
    pca_result = pca.fit_transform(df_scaled)
    df['PCA1'], df['PCA2'], df['PCA3'] = pca_result[:, 0], pca_result[:, 1], pca_result[:, 2]
    fig = px.scatter_3d(df, x='PCA1', y='PCA2', z='PCA3', text='Keyword', opacity=0.9, width=1000, height=1000)
    for i in range(len(df)):
        fig.add_trace(go.Scatter3d(x=[df.iloc[i]['PCA1']],
                                   y=[df.iloc[i]['PCA2']],
                                   z=[df.iloc[i]['PCA3']],
                                   mode='markers',
                                   marker=dict(size=5, color='rgba(0, 0, 255, 0.8)', opacity=0.8),
                                   text=[df.iloc[i]['Keyword']]))
    st.plotly_chart(fig)

def calcular_similitud(representaciones):
    similarity_matrix = np.dot(representaciones, representaciones.T)
    np.fill_diagonal(similarity_matrix, 0)
    return similarity_matrix

def obtener_tamano_color_relevancia_esferas(df, relevancia_minima):
    sizes = []
    colors = []
    for i in range(len(df)):
        relevance = np.max(df.iloc[i, :-4])
        size = 2 + relevance * 7
        color = 'rgba(0, 0, 255, 0.8)' if relevance < relevancia_minima else 'rgba(255, 0, 0, 0.8)'
        sizes.append(size)
        colors.append(color)
    return sizes, colors

def realizar_analisis():
    comparativa_seleccionada = st.selectbox("Selecciona una comparativa de candidatos:", list(candidatos.keys()))
    if st.button("Realizar Análisis Político"):
        candidato1, candidato2 = candidatos[comparativa_seleccionada]
        todas_las_noticias = {'Medio': [], 'Candidato': [], 'Sentimiento': [], 'Texto': []}
        keywords = []
        sintesis_medios = []
        for medio in medios:
            for candidato in [candidato1, candidato2]:
                texto = obtener_texto_noticia(candidato, medio)
                if texto:
                    sentimiento = analizar_sentimientos(texto)
                    todas_las_noticias['Medio'].append(medio)
                    todas_las_noticias['Candidato'].append(candidato)
                    todas_las_noticias['Sentimiento'].append(sentimiento)
                    todas_las_noticias['Texto'].append(texto)
                    keywords.extend(extraer_palabras_clave(texto))
                    sintesis = sintetizar_texto(texto)
                    sintesis_medios.append(f"{medio}: {sintesis}")
        df_noticias = pd.DataFrame(todas_las_noticias)
        generate_wordcloud(' '.join(keywords))
        generar_grafica_barras(df_noticias)
        generar_nube_palabras_3d(keywords, 0.5)
        st.table(df_noticias)
        st.write("Síntesis de Medios:")
        for sintesis in sintesis_medios:
            st.write(sintesis)

realizar_analisis()