##############
#########student_activities.py
import streamlit as st
import re
import io
from io import BytesIO
import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt
from datetime import datetime
from spacy import displacy
import random
import base64
import seaborn as sns
import logging

logger = logging.getLogger(__name__)

###################################################################################

def display_student_progress(username, lang_code, t, student_data):
    if not student_data or len(student_data['entries']) == 0:
        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
        return

    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")

    with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
        total_entries = len(student_data['entries'])
        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")

        # Gráfico de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
        analysis_counts = pd.Series(analysis_types).value_counts()

        fig, ax = plt.subplots(figsize=(8, 4))
        analysis_counts.plot(kind='bar', ax=ax)
        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
        ax.set_ylabel(t.get("count", "Cantidad"))
        st.pyplot(fig)

    # Histórico de Análisis Morfosintácticos
    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
        morphosyntax_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'morphosyntax']
        if not morphosyntax_entries:
            st.warning("No se encontraron análisis morfosintácticos.")
        for entry in morphosyntax_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            if 'arc_diagrams' in entry and entry['arc_diagrams']:
                try:
                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
                except Exception as e:
                    logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
                    st.error("Error al mostrar el diagrama de arco.")
            else:
                st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))

    # Histórico de Análisis Semánticos
    with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
        semantic_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'semantic']
        if not semantic_entries:
            st.warning("No se encontraron análisis semánticos.")
        for entry in semantic_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            if 'key_concepts' in entry:
                st.write(t.get("key_concepts", "Conceptos clave:"))
                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            if 'graph' in entry:
                try:
                    img_bytes = base64.b64decode(entry['graph'])
                    st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
                except Exception as e:
                    logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
                    st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))

    # Histórico de Análisis Discursivos
    with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
        discourse_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'discourse']
        for entry in discourse_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            for i in [1, 2]:
                if f'key_concepts{i}' in entry:
                    st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            try:
                if 'combined_graph' in entry and entry['combined_graph']:
                    img_bytes = base64.b64decode(entry['combined_graph'])
                    st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
                elif 'graph1' in entry and 'graph2' in entry:
                    col1, col2 = st.columns(2)
                    with col1:
                        if entry['graph1']:
                            img_bytes1 = base64.b64decode(entry['graph1'])
                            st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
                    with col2:
                        if entry['graph2']:
                            img_bytes2 = base64.b64decode(entry['graph2'])
                            st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
            except Exception as e:
                st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))

    # Histórico de Conversaciones con el ChatBot
    with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
        if 'chat_history' in username and username['chat_history']:
            for i, chat in enumerate(username['chat_history']):
                st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
                for message in chat['messages']:
                    if message['role'] == 'user':
                        st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
                    else:
                        st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
                st.write("---")
        else:
            st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))

    # Añadir logs para depuración
    if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
        st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
        st.json(username)

        # Mostrar conteo de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in username['entries']]
        type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
        st.write("Conteo de tipos de análisis:")
        st.write(type_counts)




'''
##########versión 25-9-2024---02:30 ################ OK (username)####################

def display_student_progress(username, lang_code, t, student_data):
    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")

    if not student_data or len(student_data.get('entries', [])) == 0:
        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
        return

    with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
        total_entries = len(student_data['entries'])
        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")

        # Gráfico de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
        analysis_counts = pd.Series(analysis_types).value_counts()
        fig, ax = plt.subplots()
        analysis_counts.plot(kind='bar', ax=ax)
        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
        ax.set_ylabel(t.get("count", "Cantidad"))
        st.pyplot(fig)

    # Mostrar los últimos análisis morfosintácticos
    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
        for entry in morphosyntax_entries[:5]:  # Mostrar los últimos 5
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            if 'arc_diagrams' in entry and entry['arc_diagrams']:
                st.components.v1.html(entry['arc_diagrams'][0], height=300, scrolling=True)

    # Añadir secciones similares para análisis semánticos y discursivos si es necesario

    # Mostrar el historial de chat
    with st.expander(t.get("chat_history", "Historial de Chat")):
        if 'chat_history' in student_data:
            for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
                st.subheader(f"{t.get('chat_from', 'Chat del')} {chat['timestamp']}")
                for message in chat['messages']:
                    st.write(f"{message['role'].capitalize()}: {message['content']}")
                st.write("---")
        else:
            st.write(t.get("no_chat_history", "No hay historial de chat disponible."))


##########versión 24-9-2024---17:30 ################ OK FROM--V2 de def get_student_data(username)####################

def display_student_progress(username, lang_code, t, student_data):
    if not student_data or len(student_data['entries']) == 0:
        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
        return

    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")

    with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
        total_entries = len(student_data['entries'])
        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")

        # Gráfico de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
        analysis_counts = pd.Series(analysis_types).value_counts()

        fig, ax = plt.subplots(figsize=(8, 4))
        analysis_counts.plot(kind='bar', ax=ax)
        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
        ax.set_ylabel(t.get("count", "Cantidad"))
        st.pyplot(fig)

    # Histórico de Análisis Morfosintácticos
    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
        if not morphosyntax_entries:
            st.warning("No se encontraron análisis morfosintácticos.")
        for entry in morphosyntax_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            if 'arc_diagrams' in entry and entry['arc_diagrams']:
                try:
                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
                except Exception as e:
                    logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
                    st.error("Error al mostrar el diagrama de arco.")
            else:
                st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))

    # Histórico de Análisis Semánticos
    with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
        semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
        if not semantic_entries:
            st.warning("No se encontraron análisis semánticos.")
        for entry in semantic_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            if 'key_concepts' in entry:
                st.write(t.get("key_concepts", "Conceptos clave:"))
                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            if 'graph' in entry:
                try:
                    img_bytes = base64.b64decode(entry['graph'])
                    st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
                except Exception as e:
                    logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
                    st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))

    # Histórico de Análisis Discursivos
    with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
        discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
        for entry in discourse_entries:
            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
            for i in [1, 2]:
                if f'key_concepts{i}' in entry:
                    st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            try:
                if 'combined_graph' in entry and entry['combined_graph']:
                    img_bytes = base64.b64decode(entry['combined_graph'])
                    st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
                elif 'graph1' in entry and 'graph2' in entry:
                    col1, col2 = st.columns(2)
                    with col1:
                        if entry['graph1']:
                            img_bytes1 = base64.b64decode(entry['graph1'])
                            st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
                    with col2:
                        if entry['graph2']:
                            img_bytes2 = base64.b64decode(entry['graph2'])
                            st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
            except Exception as e:
                st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))

    # Histórico de Conversaciones con el ChatBot
    with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
        if 'chat_history' in student_data and student_data['chat_history']:
            for i, chat in enumerate(student_data['chat_history']):
                st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
                for message in chat['messages']:
                    if message['role'] == 'user':
                        st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
                    else:
                        st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
                st.write("---")
        else:
            st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))

    # Añadir logs para depuración
    if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
        st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
        st.json(student_data)

        # Mostrar conteo de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
        type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
        st.write("Conteo de tipos de análisis:")
        st.write(type_counts)


#############################--- Update 16:00 24-9 #########################################
def display_student_progress(username, lang_code, t, student_data):
    try:
        st.subheader(t.get('student_activities', 'Student Activitie'))

        if not student_data or all(len(student_data.get(key, [])) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
            st.warning(t.get('no_data_warning', 'No analysis data found for this student.'))
            return

        # Resumen de actividades
        total_analyses = sum(len(student_data.get(key, [])) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
        st.write(f"{t.get('total_analyses', 'Total analyses performed')}: {total_analyses}")

        # Gráfico de tipos de análisis
        analysis_counts = {
            t.get('morpho_analyses', 'Morphosyntactic Analyses'): len(student_data.get('morphosyntax_analyses', [])),
            t.get('semantic_analyses', 'Semantic Analyses'): len(student_data.get('semantic_analyses', [])),
            t.get('discourse_analyses', 'Discourse Analyses'): len(student_data.get('discourse_analyses', []))
        }
        # Configurar el estilo de seaborn para un aspecto más atractivo
        sns.set_style("whitegrid")

        # Crear una figura más pequeña
        fig, ax = plt.subplots(figsize=(6, 4))

        # Usar colores más atractivos
        colors = ['#ff9999', '#66b3ff', '#99ff99']

        # Crear el gráfico de barras
        bars = ax.bar(analysis_counts.keys(), analysis_counts.values(), color=colors)

        # Añadir etiquetas de valor encima de cada barra
        for bar in bars:
            height = bar.get_height()
            ax.text(bar.get_x() + bar.get_width()/2., height,
                    f'{height}',
                    ha='center', va='bottom')

        # Configurar el título y las etiquetas
        ax.set_title(t.get('analysis_types_chart', 'Types of analyses performed'), fontsize=12)
        ax.set_ylabel(t.get('count', 'Count'), fontsize=10)

        # Rotar las etiquetas del eje x para mejor legibilidad
        plt.xticks(rotation=45, ha='right')

        # Ajustar el diseño para que todo quepa
        plt.tight_layout()

        # Mostrar el gráfico en Streamlit
        st.pyplot(fig)

        # Mostrar los últimos análisis
        for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
            with st.expander(t.get(f'{analysis_type}_expander', f'{analysis_type.capitalize()} History')):
                for analysis in student_data.get(analysis_type, [])[:5]:  # Mostrar los últimos 5
                    st.subheader(f"{t.get('analysis_from', 'Analysis from')} {analysis.get('timestamp', 'N/A')}")
                    if analysis_type == 'morphosyntax_analyses':
                        if 'arc_diagrams' in analysis:
                            st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
                    elif analysis_type == 'semantic_analyses':
                        if 'key_concepts' in analysis:
                            st.write(t.get('key_concepts', 'Key concepts'))
                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
                        if 'graph' in analysis:
                            st.image(base64.b64decode(analysis['graph']))
                    elif analysis_type == 'discourse_analyses':
                        for i in [1, 2]:
                            if f'key_concepts{i}' in analysis:
                                st.write(f"{t.get('key_concepts', 'Key concepts')} {t.get('document', 'Document')} {i}")
                                st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
                        if 'combined_graph' in analysis:
                            st.image(base64.b64decode(analysis['combined_graph']))

        # Mostrar el historial de chat
        with st.expander(t.get('chat_history_expander', 'Chat History')):
            for chat in student_data.get('chat_history', [])[:5]:  # Mostrar las últimas 5 conversaciones
                st.subheader(f"{t.get('chat_from', 'Chat from')} {chat.get('timestamp', 'N/A')}")
                for message in chat.get('messages', []):
                    st.write(f"{message.get('role', 'Unknown').capitalize()}: {message.get('content', 'No content')}")
                st.write("---")

    except Exception as e:
        logger.error(f"Error in display_student_progress: {str(e)}", exc_info=True)
        st.error(t.get('error_loading_progress', 'Error loading student progress. Please try again later.'))



























#####################################################################
def display_student_progress(username, lang_code, t, student_data):
    st.subheader(t['student_progress'])

    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
        st.warning(t['no_data_warning'])
        return

    # Resumen de actividades
    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
    st.write(f"{t['total_analyses']}: {total_analyses}")

    # Gráfico de tipos de análisis
    analysis_counts = {
        t['morpho_analyses']: len(student_data['morphosyntax_analyses']),
        t['semantic_analyses']: len(student_data['semantic_analyses']),
        t['discourse_analyses']: len(student_data['discourse_analyses'])
    }
    fig, ax = plt.subplots()
    ax.bar(analysis_counts.keys(), analysis_counts.values())
    ax.set_title(t['analysis_types_chart'])
    st.pyplot(fig)

    # Mostrar los últimos análisis
    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
        with st.expander(t[f'{analysis_type}_expander']):
            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
                if analysis_type == 'morphosyntax_analyses':
                    if 'arc_diagrams' in analysis:
                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
                elif analysis_type == 'semantic_analyses':
                    if 'key_concepts' in analysis:
                        st.write(t['key_concepts'])
                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
                    if 'graph' in analysis:
                        st.image(base64.b64decode(analysis['graph']))
                elif analysis_type == 'discourse_analyses':
                    for i in [1, 2]:
                        if f'key_concepts{i}' in analysis:
                            st.write(f"{t['key_concepts']} {t['document']} {i}")
                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
                    if 'combined_graph' in analysis:
                        st.image(base64.b64decode(analysis['combined_graph']))

    # Mostrar el historial de chat
    with st.expander(t['chat_history_expander']):
        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
            for message in chat['messages']:
                st.write(f"{message['role'].capitalize()}: {message['content']}")
            st.write("---")



def display_student_progress(username, lang_code, t, student_data):
    st.subheader(t['student_activities'])

    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
        st.warning(t['no_data_warning'])
        return

    # Resumen de actividades
    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
    st.write(f"{t['total_analyses']}: {total_analyses}")

    # Gráfico de tipos de análisis
    analysis_counts = {
        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
        t['semantic_analyses']: len(student_data['semantic_analyses']),
        t['discourse_analyses']: len(student_data['discourse_analyses'])
    }
    fig, ax = plt.subplots()
    ax.bar(analysis_counts.keys(), analysis_counts.values())
    ax.set_title(t['analysis_types_chart'])
    st.pyplot(fig)

    # Mostrar los últimos análisis
    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
        with st.expander(t[f'{analysis_type}_expander']):
            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
                if analysis_type == 'morphosyntax_analyses':
                    if 'arc_diagrams' in analysis:
                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
                elif analysis_type == 'semantic_analyses':
                    if 'key_concepts' in analysis:
                        st.write(t['key_concepts'])
                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
                    if 'graph' in analysis:
                        st.image(base64.b64decode(analysis['graph']))
                elif analysis_type == 'discourse_analyses':
                    for i in [1, 2]:
                        if f'key_concepts{i}' in analysis:
                            st.write(f"{t['key_concepts']} {t['document']} {i}")
                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
                    if 'combined_graph' in analysis:
                        st.image(base64.b64decode(analysis['combined_graph']))

    # Mostrar el historial de chat
    with st.expander(t['chat_history_expander']):
        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
            for message in chat['messages']:
                st.write(f"{message['role'].capitalize()}: {message['content']}")
            st.write("---")




def display_student_progress(username, lang_code, t, student_data):
    st.subheader(t['student_activities'])

    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
        st.warning(t['no_data_warning'])
        return

    # Resumen de actividades
    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
    st.write(f"{t['total_analyses']}: {total_analyses}")

    # Gráfico de tipos de análisis
    analysis_counts = {
        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
        t['semantic_analyses']: len(student_data['semantic_analyses']),
        t['discourse_analyses']: len(student_data['discourse_analyses'])
    }
    fig, ax = plt.subplots()
    ax.bar(analysis_counts.keys(), analysis_counts.values())
    ax.set_title(t['analysis_types_chart'])
    st.pyplot(fig)

    # Mostrar los últimos análisis
    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
        with st.expander(t[f'{analysis_type}_expander']):
            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
                if analysis_type == 'morphosyntax_analyses':
                    if 'arc_diagrams' in analysis:
                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
                elif analysis_type == 'semantic_analyses':
                    if 'key_concepts' in analysis:
                        st.write(t['key_concepts'])
                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
                    if 'graph' in analysis:
                        st.image(base64.b64decode(analysis['graph']))
                elif analysis_type == 'discourse_analyses':
                    for i in [1, 2]:
                        if f'key_concepts{i}' in analysis:
                            st.write(f"{t['key_concepts']} {t['document']} {i}")
                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
                    if 'combined_graph' in analysis:
                        st.image(base64.b64decode(analysis['combined_graph']))

    # Mostrar el historial de chat
    with st.expander(t['chat_history_expander']):
        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
            for message in chat['messages']:
                st.write(f"{message['role'].capitalize()}: {message['content']}")
            st.write("---")




def display_student_progress(username, lang_code, t):
    st.subheader(t['student_activities'])
    st.write(f"{t['activities_message']} {username}")

    # Aquí puedes agregar más contenido estático o placeholder
    st.info(t['activities_placeholder'])

    # Si necesitas mostrar algún dato, puedes usar datos de ejemplo o placeholders
    col1, col2, col3 = st.columns(3)
    col1.metric(t['morpho_analyses'], "5")  # Ejemplo de dato
    col2.metric(t['semantic_analyses'], "3")  # Ejemplo de dato
    col3.metric(t['discourse_analyses'], "2")  # Ejemplo de dato



def display_student_progress(username, lang_code, t):
    st.title(f"Actividades de {username}")

    # Obtener todos los datos del estudiante
    student_data = get_student_data(username)

    if not student_data or len(student_data.get('entries', [])) == 0:
        st.warning("No se encontraron datos de análisis para este estudiante.")
        st.info("Intenta realizar algunos análisis de texto primero.")
        return

    # Resumen de actividades
    with st.expander("Resumen de Actividades", expanded=True):
        total_entries = len(student_data['entries'])
        st.write(f"Total de análisis realizados: {total_entries}")

        # Gráfico de tipos de análisis
        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
        analysis_counts = pd.Series(analysis_types).value_counts()
        fig, ax = plt.subplots()
        analysis_counts.plot(kind='bar', ax=ax)
        ax.set_title("Tipos de análisis realizados")
        ax.set_xlabel("Tipo de análisis")
        ax.set_ylabel("Cantidad")
        st.pyplot(fig)

    # Histórico de Análisis Morfosintácticos
    with st.expander("Histórico de Análisis Morfosintácticos"):
        morpho_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
        for analysis in morpho_analyses[:5]:  # Mostrar los últimos 5
            st.subheader(f"Análisis del {analysis['timestamp']}")
            if 'arc_diagrams' in analysis:
                st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)

    # Histórico de Análisis Semánticos
    with st.expander("Histórico de Análisis Semánticos"):
        semantic_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
        for analysis in semantic_analyses[:5]:  # Mostrar los últimos 5
            st.subheader(f"Análisis del {analysis['timestamp']}")
            if 'key_concepts' in analysis:
                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis['key_concepts']])
                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            if 'graph' in analysis:
                try:
                    img_bytes = base64.b64decode(analysis['graph'])
                    st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
                except Exception as e:
                    st.error(f"No se pudo mostrar el gráfico: {str(e)}")

    # Histórico de Análisis Discursivos
    with st.expander("Histórico de Análisis Discursivos"):
        discourse_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
        for analysis in discourse_analyses[:5]:  # Mostrar los últimos 5
            st.subheader(f"Análisis del {analysis['timestamp']}")
            for i in [1, 2]:
                if f'key_concepts{i}' in analysis:
                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis[f'key_concepts{i}']])
                    st.write(f"Conceptos clave del documento {i}:")
                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
            if 'combined_graph' in analysis:
                try:
                    img_bytes = base64.b64decode(analysis['combined_graph'])
                    st.image(img_bytes)
                except Exception as e:
                    st.error(f"No se pudo mostrar el gráfico combinado: {str(e)}")

    # Histórico de Conversaciones con el ChatBot
    with st.expander("Histórico de Conversaciones con el ChatBot"):
        if 'chat_history' in student_data:
            for i, chat in enumerate(student_data['chat_history'][:5]):  # Mostrar las últimas 5 conversaciones
                st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
                for message in chat['messages']:
                    st.write(f"{message['role'].capitalize()}: {message['content']}")
                st.write("---")
        else:
            st.write("No se encontraron conversaciones con el ChatBot.")

    # Opción para mostrar datos de depuración
    if st.checkbox("Mostrar datos de depuración"):
        st.write("Datos del estudiante (para depuración):")
        st.json(student_data)

'''