modules/ui/ui.py

# modules/ui/ui.py
# Importaciones generales

# modules/ui/ui.py
import streamlit as st
from streamlit_player import st_player
import logging
from datetime import datetime
from dateutil.parser import parse

# Importaciones locales
from session_state import initialize_session_state, logout
from translations import get_translations

from ..auth.auth import authenticate_user, authenticate_student, authenticate_admin

from ..database.sql_db import store_application_request

#from .user_page import user_page
try:
    from .user_page import user_page
except ImportError:
    logger.error("No se pudo importar user_page. Asegúrate de que el archivo existe.")
    # Definir una función de respaldo
    def user_page(lang_code, t):
        st.error("La página de usuario no está disponible. Por favor, contacta al administrador.")

from ..admin.admin_ui import admin_page

# Configuración del logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

#############################################################
def main():
    logger.info(f"Entrando en main() - Página actual: {st.session_state.page}")

    if 'nlp_models' not in st.session_state:
        logger.error("Los modelos NLP no están inicializados.")
        st.error("Los modelos NLP no están inicializados. Por favor, reinicie la aplicación.")
        return

    lang_code = st.session_state.get('lang_code', 'es')
    t = get_translations(lang_code)

    logger.info(f"Página actual antes de la lógica de enrutamiento: {st.session_state.page}")

    if st.session_state.get('logged_out', False):
        st.session_state.logged_out = False
        st.session_state.page = 'login'
        st.rerun()

    if not st.session_state.get('logged_in', False):
        logger.info("Usuario no ha iniciado sesión. Mostrando página de login/registro")
        login_register_page(lang_code, t)
    elif st.session_state.page == 'user':
        if st.session_state.role == 'Administrador':
            logger.info("Redirigiendo a la página de administrador")
            st.session_state.page = 'Admin'
            st.rerun()
        else:
            logger.info("Renderizando página de usuario")
            user_page(lang_code, t)
    elif st.session_state.page == "Admin":
        logger.info("Renderizando página de administrador")
        admin_page()
    else:
        logger.error(f"Página no reconocida: {st.session_state.page}")
        st.error(t.get('unrecognized_page', 'Página no reconocida'))
        # Redirigir a la página de usuario en caso de error
        st.session_state.page = 'user'
        st.rerun()

    logger.info(f"Saliendo de main() - Estado final de la sesión: {st.session_state}")

#############################################################
#############################################################    
def login_register_page(lang_code, t):
    # st.title("AIdeaText")
    # st.write(t.get("welcome_message", "Bienvenido. Por favor, inicie sesión o regístrese."))

    left_column, right_column = st.columns([1, 3])

    with left_column:
        tab1, tab2 = st.tabs([t.get("login", "Iniciar Sesión"), 
                             t.get("register", "Registrarse")])

        with tab1:
            login_form(lang_code, t)

        with tab2:
            register_form(lang_code, t)

    with right_column:
        display_videos_and_info(lang_code, t)

#############################################################
#############################################################
def login_form(lang_code, t):
    with st.form("login_form"):
        username = st.text_input(t.get("email", "Correo electrónico"))
        password = st.text_input(t.get("password", "Contraseña"), type="password")
        submit_button = st.form_submit_button(t.get("login", "Iniciar Sesión"))

    if submit_button:
        success, role = authenticate_user(username, password)
        if success:
            st.session_state.logged_in = True
            st.session_state.username = username
            st.session_state.role = role
            if role == 'Administrador':
                st.session_state.page = 'Admin'
            else:
                st.session_state.page = 'user'
            logger.info(f"Usuario autenticado: {username}, Rol: {role}")
            st.rerun()
        else:
            st.error(t.get("invalid_credentials", "Credenciales incorrectas"))


#############################################################
#############################################################
def register_form(lang_code, t):
    # st.header(t.get("request_trial", "Solicitar prueba de la aplicación"))
    name = st.text_input(t.get("name", "Nombre"))
    lastname = st.text_input(t.get("lastname", "Apellidos"))
    institution = st.text_input(t.get("institution", "Institución"))
    current_role = st.selectbox(t.get("current_role", "Rol en la institución donde labora"),
                                [t.get("professor", "Profesor"), t.get("student", "Estudiante"), t.get("administrative", "Administrativo")])
    
    # Definimos el rol por defecto como estudiante
    desired_role = t.get("student", "Estudiante")
    
    email = st.text_input(t.get("institutional_email", "Correo electrónico de su institución"))
    reason = st.text_area(t.get("interest_reason", "¿Por qué estás interesado en probar AIdeaText?"))
    
    if st.button(t.get("submit_application", "Enviar solicitud")):
        logger.info(f"Attempting to submit application for {email}")
        logger.debug(f"Form data: name={name}, lastname={lastname}, email={email}, institution={institution}, current_role={current_role}, desired_role={desired_role}, reason={reason}")
        
        if not name or not lastname or not email or not institution or not reason:
            logger.warning("Incomplete form submission")
            st.error(t.get("complete_all_fields", "Por favor, completa todos los campos."))
        elif not is_institutional_email(email):
            logger.warning(f"Non-institutional email used: {email}")
            st.error(t.get("use_institutional_email", "Por favor, utiliza un correo electrónico institucional."))
        else:
            logger.info(f"Attempting to store application for {email}")
            success = store_application_request(name, lastname, email, institution, current_role, desired_role, reason)
            if success:
                st.success(t.get("application_sent", "Tu solicitud ha sido enviada. Te contactaremos pronto."))
                logger.info(f"Application request stored successfully for {email}")
            else:
                st.error(t.get("application_error", "Hubo un problema al enviar tu solicitud. Por favor, intenta de nuevo más tarde."))
                logger.error(f"Failed to store application request for {email}")


#############################################################
#############################################################
def is_institutional_email(email):
        forbidden_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com']
        return not any(domain in email.lower() for domain in forbidden_domains)


#############################################################
#############################################################
def display_videos_and_info(lang_code, t):
    # Crear tabs para cada sección
    tab_use_case, tab_videos, tab_events, tab_gallery, tab_news = st.tabs([
        "Casos de uso", 
        "Videos de presentaciones", 
        "Ponencias académicas",
        "Fotos de eventos",
        "Control de versiones"
    ])

# Tab de Casos de uso
    with tab_use_case:
        use_case_videos = {
            "English - Radar use chart": "https://youtu.be/fFbbtlIewgs",
            "English - Use AI Bot and arcs charts fuctions": "https://youtu.be/XjM-1oOl-ao",
            "English - Arcs use charts, example 1": "https://youtu.be/PdK_bgigVaM",
            "English - Arcs use charts, excample 2": "https://youtu.be/7uaV1njPOng",   
            "Español - Uso del diagrama radar para verificar redacción": "https://www.youtube.com/watch?v=nJP6xscPLBU",
            "Español - Uso de los diagramas de arco, ejemplo 1": "https://www.youtube.com/watch?v=ApBIAr2S-bE",            
            "Español - Uso de los diagramas de arco, ejemplo 2": "https://www.youtube.com/watch?v=JnP2U1Fm0rc",
            "Español - Uso de los diagramas de arco, ejemplo 3": "https://www.youtube.com/watch?v=waWWwPTaI-Y",
            "Español - Uso del bot para buscar respuestas" : "https://www.youtube.com/watch?v=GFKDS0K2s7E" 
        }
        
        selected_title = st.selectbox("Selecciona un caso de uso en español o en inglés:", list(use_case_videos.keys()))
        if selected_title in use_case_videos:
            try:
                st_player(use_case_videos[selected_title])
            except Exception as e:
                st.error(f"Error al cargar el video: {str(e)}")

    # Tab de Videos
    with tab_videos:
        videos = {
            "Reel AIdeaText": "https://youtu.be/hXnwUvN1Q9Q",
            "Presentación en SENDA, UNAM. Ciudad de México, México" : "https://www.youtube.com/watch?v=XFLvjST2cE0",        
            "Presentación en PyCon 2024. Colombia, Medellín": "https://www.youtube.com/watch?v=Jn545-IKx5Q",
            "Presentación en la Fundación Ser Maaestro. Lima, Perú": "https://www.youtube.com/watch?v=imc4TI1q164",
            "Presentación en el programa de incubación Explora del IFE, TEC de Monterrey, Nuevo León, México": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s",
            "Entrevista con el Dr. Guillermo Ruíz. Lima, Perú": "https://www.youtube.com/watch?v=_ch8cRja3oc",
            "Demo de la versión de escritorio.": "https://www.youtube.com/watch?v=nP6eXbog-ZY"
        }

        selected_title = st.selectbox("Selecciona una conferencia:", list(videos.keys()))
        if selected_title in videos:
            try:
                st_player(videos[selected_title])
            except Exception as e:
                st.error(f"Error al cargar el video: {str(e)}")
                
    # Tab de Eventos
    with tab_events:
        st.markdown("""
        ## 2025
    
        **El Agente Cognitivo Vinculante como Innovación en el Aprendizaje Adaptativo: el caso de AIdeaText**  
        IFE CONFERENCE 2025. Organizado por el Instituto para el Futuro de la Educación del TEC de Monterrey. 
        Nuevo León, México. Del 28 al 30 enero 2025
    
        ## 2024
        [1]
        AIdeaText, AIdeaText, recurso digital que emplea la técnica de Análisis de Resonancia Central para perfeccionar textos académicos**  
        V Temporada SENDA - Organizado por el Seminario de Entornos y Narrativas Digitales en la Academia del 
        Instituto de Investigaciones Antropológicas (IIA) de la Universidad Autonóma de México (UNAM). 22 noviembre 2024
    
        [2]
        Aproximación al Agente Cognitivo Vinculante (ACV) desde la Teoría del Actor Red (TAR)**  
        Congreso HeETI 2024: Horizontes Expandidos de la Educación, la Tecnología y la Innovación  
        Universidad el Claustro de Sor Juana. Del 25 al 27 septiembre 2024
        [3]
        AIdeaText, visualización de mapas semánticos**
        PyCon 2024, Organizado por el grupo de desarrolladores independientes de Python. 
        Universidad EAFIT, Medellín, Colombia. Del 7 al 9 de junio de 2024. 
        
        ## 2023
        **Aproximación al Agente Cognitivo Vinculante (ACV) desde la Teoría del Actor Red (TAR)**  
        [1]
        XVII Congreso Nacional de Investigación Educativa - VII Encuentro de Estudiantes de Posgrado Educación.
        Consejo Mexicano de Investigación Educativa (COMIE)  
        Villahermosa, Tabasco, México. 
        Del 4 al 8 de diciembre 2023
        [2]
        XXXI Encuentro Internacional de Educación a Distancia  
        Universidad de Guadalajara. Jalisco, México. 
        Del 27 al 30 noviembre 2023
        [3]
        IV Temporada SENDA - Seminario de Entornos y Narrativas Digitales en la Academia  
        Instituto de Investigaciones Antropológicas (IIA), UNAM. 
        22 noviembre 2023
        [4]
        1er Congreso Internacional de Educación Digital  
        Instituto Politécnico Nacional, sede Zacatecas. México. 
        Del 23 al 24 de noviembre de 2023
    
        [5]
        La cuestión de la centralidad del maestro frente a las tecnologías digitales generativas**  
        Innova Fórum: Ecosistemas de Aprendizaje  
        Universidad de Guadalajara. Jalisco, México. 
        Del 16 al 18 de mayo 2023
        """)

    # Tab de Galería
    with tab_gallery:
        # Contenedor con ancho máximo
        with st.container():
            # Dividimos en dos columnas principales
            col_left, col_right = st.columns(2)
                        
            # Columna izquierda: Foto 1 grande
            with col_left:
                # Foto 2 arriba
                st.image("assets/img/socialmedia/_MG_2845.JPG", 
                        caption="MakerFaire CDMX 2024", 
                        width=480)  # Ajusta este valor según necesites
                        # use_column_width=True)
                
                # Foto 3 abajo
                st.image("assets/img/socialmedia/Facebook_CoverPhoto-1_820x312.jpg", 
                        caption="MakerFaire CDMX 2024", 
                        width=480)  # Ajusta este valor según necesites 
                        # use_column_width=True)

                            # Columna derecha: Fotos 2 y 3 una encima de otra
            with col_right:
                st.image("assets/img/socialmedia/_MG_2790.jpg", 
                        caption="MakerFaire CDMX 2024", 
                        width=540)  # Ajusta este valor según necesites

    
    # Tab de Novedades
    with tab_news:
        st.markdown("""
        ### Novedades de la versión actual
        - Interfaz mejorada para una mejor experiencia de usuario
        - Optimización del análisis morfosintáctico
        - Soporte para múltiples idiomas
        - Nuevo módulo de análisis del discurso
        - Sistema de chat integrado para soporte
        """)

# Definición de __all__ para especificar qué se exporta
__all__ = ['main', 'login_register_page', 'initialize_session_state']

# Bloque de ejecución condicional
if __name__ == "__main__":
    main()