app.py

import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import numpy as np
from datetime import datetime
import calendar
import io

# Configuración de la aplicación
st.set_page_config(page_title="Gestión de la Estrategia", page_icon="📊",layout="wide")

# Estado inicial si es primera carga
if "objetivos" not in st.session_state:
    st.session_state["objetivos"] = [
        {
            "Objetivo": "Mejorar la satisfacción del cliente",
            "Progreso": 50,
            "Key Results": [
                {
                    "KR": "Aumentar la calificación de satisfacción en un 10%",
                    "Meta": 10,
                    "Actual": 5,
                    "Tareas": [
                        {"tarea": "Encuesta de satisfacción", "fecha_inicio": "2024-01-01", "fecha_fin": "2024-01-10", "estado": "On track"},
                        {"tarea": "Capacitación al equipo de soporte", "fecha_inicio": "2024-01-15", "fecha_fin": "2024-01-20", "estado": "At risk"},
                    ]
                },
                {
                    "KR": "Reducir el tiempo de respuesta en un 20%",
                    "Meta": 20,
                    "Actual": 15,
                    "Tareas": [
                        {"tarea": "Implementación de chatbot", "fecha_inicio": "2024-01-05", "fecha_fin": "2024-01-25", "estado": "On track"},
                    ]
                }
            ]
        },
        {
            "Objetivo": "Incrementar las ventas en línea",
            "Progreso": 70,
            "Key Results": [
                {
                    "KR": "Aumentar las visitas al sitio web en un 30%",
                    "Meta": 30,
                    "Actual": 25,
                    "Tareas": [
                        {"tarea": "Campaña de Google Ads", "fecha_inicio": "2024-01-01", "fecha_fin": "2024-01-30", "estado": "On track"},
                        {"tarea": "Optimización SEO", "fecha_inicio": "2024-01-10", "fecha_fin": "2024-01-20", "estado": "Off track"},
                    ]
                }
            ]
        }
    ]

# Función para obtener dataframe de los objetivos
def obtener_df_objetivos():
    return pd.DataFrame(st.session_state["objetivos"])

# Display the image above the title
st.image('Strategy hub.jpg', use_container_width=True)
# Tabulación de la aplicación
tab1, tab2, tab3, tab4, tab5 = st.tabs([
    "📘 Reseñas de Libros", 
    "📈 Gestión de OKRs", 
    "📊 Balanced Scorecard", 
    "🌀 Hoshin Kanri", 
    "👤 Acerca de mí"
])

# Contenido de la primera pestaña (Reseña del libro)
with tab1:
    st.header("Reseñas de Libros")
    st.write("""
    A continuación, te comparto una cronología de diversos libros y sus autores, ofreciendo una variedad de visiones culturales, incluyendo escritores estadounidenses, alemanes, japoneses, argentinos y brasileños, en la siguiente selección y cronología elegidas:

    ### OKR's

    **1. High Output Management** (Andy Grove, 1983):  
    Este libro introduce los OKRs como una herramienta clave para la gestión de alto rendimiento, enfocándose en cómo establecer objetivos claros y medibles que maximicen el rendimiento de los equipos.

    **2. Mide lo que importa** (John Doerr, 2018):  
    En este libro, Doerr populariza el uso de los OKRs y explica cómo este marco ha sido utilizado por empresas como Google para alinear esfuerzos y fomentar la innovación. La obra destaca la importancia de establecer objetivos ambiciosos y medir el progreso a través de resultados clave.
    """)

    st.write("""
    ### Balanced Scorecard & Tableros de control

    **3. Balanced Scorecard** (Robert Kaplan y David Norton, 1996):  
    Un modelo que permite a las organizaciones traducir su estrategia en indicadores medibles a través de cuatro perspectivas: financiera, cliente, procesos internos y aprendizaje/crecimiento, asegurando un balance entre la medición del rendimiento y el logro de metas.

    **4. El Tablero de Control** (Alberto Ballvé, 2000, 2023):  
    Este sistema proporciona un marco para la toma de decisiones directivas, integrando información clave para ofrecer una visión clara del rendimiento organizacional y facilitar la alineación estratégica. Su versión del 2023 presenta una actualización de los tableros usando herramientas modernas de análisis de datos.
    """)

    st.write("""
    ### Hoshin Kanri y Gerenciamiento diario

    **5. Hoshin Kanri** (Yoji Akao, 1988):  
    Este enfoque se centra en alinear todos los niveles de la organización con los objetivos estratégicos a largo plazo, promoviendo una mejora continua mediante el despliegue de políticas que conectan la estrategia con las operaciones diarias.

    **6. Gerenciamiento diario para ejecutar la estrategia** (José Roberto Ferro, Robson Gouveia, 2021):  
    Es un libro que plantea de forma práctica cómo en nuestro día a día podemos llevar el control y mantener el enfoque en lo verdaderamente importante, ejecutando con consistencia, promoviendo el compromiso y la participación de todos.
    """)

    st.write("""
    ### Otros Libros recomendados

    **7. Las 4 Disciplinas de la Ejecución (4DX)** (Sean Covey, 2012):  
    Un enfoque que combina simplicidad y eficacia, centrado en metas crucialmente importantes y medidas de predicción, promoviendo la rendición de cuentas y una ejecución disciplinada de la estrategia.

    **8. Key Performance Indicators: The 75 Measures Every Manager Needs to Know** (Bernard Marr, 2012):  
    Proporciona una extensa colección de indicadores clave de rendimiento (KPI) para diferentes aspectos de una organización. El texto presenta una selección de estos KPIs, explicando su significado, la forma de medirlos, las fuentes de datos relevantes y algunas referencias adicionales. También ofrece ejemplos de cómo se pueden usar estos indicadores, junto con algunos consejos y advertencias sobre su interpretación.
    
    ###### *Te invito a revisar cada pestaña de la aplicación y explores mi aproximación para cada modelo, en una aplicación que se puede escalar en diferentes negocios y sectores.*
    """)


# Contenido de la segunda pestaña (Gestión de OKRs)
with tab2:
    st.header("Gestión de OKRs")

    # Dashboard inicial
    col1, col2, col3, col4 = st.columns(4)
    
    # Calcular progreso promedio de los objetivos
    progreso_promedio = sum(obj["Progreso"] for obj in st.session_state["objetivos"]) / len(st.session_state["objetivos"])
    col1.metric("Progreso Promedio", f"{progreso_promedio:.2f}%")

    # Calcular el estado total de las tareas
    estados_tareas = {"On track": 0, "At risk": 0, "Off track": 0, "Closed": 0}
    for obj in st.session_state["objetivos"]:
        for kr in obj["Key Results"]:
            for tarea in kr["Tareas"]:
                estados_tareas[tarea["estado"]] += 1

    # Mostrar colores para las métricas de estado de tareas
    col2.markdown(f"<h3 style='color:green;'>Tareas On Track: {estados_tareas['On track']}</h3>", unsafe_allow_html=True)
    col3.markdown(f"<h3 style='color:yellow;'>Tareas At Risk: {estados_tareas['At risk']}</h3>", unsafe_allow_html=True)
    col4.markdown(f"<h3 style='color:red;'>Tareas Off Track: {estados_tareas['Off track']}</h3>", unsafe_allow_html=True)

    # Expander para agregar un nuevo objetivo
    with st.expander("Agregar un Nuevo Objetivo"):
        with st.form("agregar_objetivo"):
            objetivo = st.text_input("Objetivo")
            progreso = st.slider("Progreso del Objetivo (%)", 0, 100, 0)
            
            if st.form_submit_button("Agregar Objetivo"):
                nuevo_objetivo = {
                    "Objetivo": objetivo,
                    "Progreso": progreso,
                    "Key Results": []
                }
                st.session_state["objetivos"].append(nuevo_objetivo)
                st.success("Objetivo agregado exitosamente.")

    # Mostrar cada objetivo y permitir agregar key results
    for i, obj in enumerate(st.session_state["objetivos"]):
        with st.expander(f"Objetivo: {obj['Objetivo']} - Progreso: {obj['Progreso']}%"):
            # Edición del progreso del objetivo
            nuevo_progreso = st.slider(f"Actualizar Progreso ({obj['Objetivo']})", 0, 100, obj["Progreso"], key=f"progreso_{i}")
            if nuevo_progreso != obj["Progreso"]:
                obj["Progreso"] = nuevo_progreso
                st.success("Progreso actualizado.")

            # Botón para agregar un nuevo Key Result
            if st.button(f"Agregar un Nuevo Key Result a '{obj['Objetivo']}'", key=f"btn_kr_{i}"):
                st.session_state[f"show_kr_{i}"] = True  # Mostrar el formulario de Key Result

            # Formulario para agregar un nuevo Key Result (solo visible si se ha activado)
            if f"show_kr_{i}" in st.session_state and st.session_state[f"show_kr_{i}"]:
                with st.form(f"agregar_kr_{i}"):
                    st.write("Agregar un Nuevo Key Result")
                    kr = st.text_input("Key Result", key=f"kr_{i}")
                    meta = st.number_input("Meta", min_value=0, key=f"meta_{i}")
                    actual = st.number_input("Actual", min_value=0, key=f"actual_{i}")

                    if st.form_submit_button("Agregar Key Result"):
                        nuevo_kr = {
                            "KR": kr,
                            "Meta": meta,
                            "Actual": actual,
                            "Tareas": []
                        }
                        obj["Key Results"].append(nuevo_kr)
                        st.success("Key Result agregado exitosamente.")
                        st.session_state[f"show_kr_{i}"] = False  # Ocultar formulario después de agregar

            # Mostrar cada Key Result y permitir agregar tareas
            for j, kr in enumerate(obj["Key Results"]):
                st.subheader(f"Key Result: {kr['KR']} - Progreso: {kr['Actual']}/{kr['Meta']}")

                # Formulario para editar Key Result
                kr_actualizado = st.text_input(f"Editar KR", value=kr["KR"], key=f"kr_edit_{i}_{j}")
                kr_meta = st.number_input(f"Meta ({kr['KR']})", min_value=0, value=kr["Meta"], key=f"meta_edit_{i}_{j}")
                kr_actual = st.number_input(f"Actual ({kr['KR']})", min_value=0, value=kr["Actual"], key=f"actual_edit_{i}_{j}")

                if kr_actualizado != kr["KR"] or kr_meta != kr["Meta"] or kr_actual != kr["Actual"]:
                    kr["KR"] = kr_actualizado
                    kr["Meta"] = kr_meta
                    kr["Actual"] = kr_actual
                    st.success("Key Result actualizado.")

                # Botón para agregar una tarea al Key Result
                if st.button(f"Agregar Nueva Tarea a '{kr['KR']}'", key=f"btn_tarea_{i}_{j}"):
                    st.session_state[f"show_tarea_{i}_{j}"] = True  # Mostrar el formulario de Tarea

                # Formulario para agregar una tarea (solo visible si se ha activado)
                if f"show_tarea_{i}_{j}" in st.session_state and st.session_state[f"show_tarea_{i}_{j}"]:
                    with st.form(f"agregar_tarea_{i}_{j}"):
                        st.write("Agregar una Nueva Tarea")
                        tarea = st.text_input("Nombre de la Tarea", key=f"tarea_{i}_{j}")
                        fecha_inicio = st.date_input("Fecha de Inicio", key=f"fecha_inicio_{i}_{j}")
                        fecha_fin = st.date_input("Fecha de Fin", key=f"fecha_fin_{i}_{j}")
                        estado = st.selectbox("Estado de la Tarea", ["On track", "At risk", "Off track", "Closed"], key=f"estado_{i}_{j}")
                        
                        if st.form_submit_button("Agregar Tarea"):
                            nueva_tarea = {
                                "tarea": tarea,
                                "fecha_inicio": fecha_inicio,
                                "fecha_fin": fecha_fin,
                                "estado": estado
                            }
                            kr["Tareas"].append(nueva_tarea)
                            st.success("Tarea agregada exitosamente.")
                            st.session_state[f"show_tarea_{i}_{j}"] = False  # Ocultar formulario después de agregar

                # Mostrar tabla de tareas editable
                df_tareas = pd.DataFrame(kr["Tareas"])
                if not df_tareas.empty:
                    st.write("Tareas:")
                    df_tareas_editable = st.data_editor(df_tareas, use_container_width=True, key=f"editor_{i}_{j}")

                    # Gantt de tareas
                    fig = px.timeline(df_tareas_editable, x_start="fecha_inicio", x_end="fecha_fin", y="tarea", color="estado",
                                      color_discrete_map={"On track": "green", "At risk": "yellow", "Off track": "red", "Closed": "gray"})
                    fig.update_yaxes(categoryorder="total ascending")
                    st.plotly_chart(fig, use_container_width=True)

#________________________________________________________________________________________________

# BSC
# Estado inicial si es primera carga
if "bsc" not in st.session_state:
    st.session_state["bsc"] = {
        "Financiera": {
            "indicador": "Rentabilidad",
            "cumplimiento": 75,
            "mejor_es_mayor": True,  # Indica si un mayor resultado es mejor
            "tendencia": [60, 70, 80, 75],
            "datos": pd.DataFrame({
                "Fecha": pd.date_range(start="2024-01-01", periods=4, freq='M'),
                "Resultados": [50000, 52000, 48000, 55000],
                "Meta": [60000, 60000, 60000, 60000]
            })
        },
        "Clientes": {
            "indicador": "Satisfacción",
            "cumplimiento": 85,
            "mejor_es_mayor": True,
            "tendencia": [70, 75, 80, 85],
            "datos": pd.DataFrame({
                "Fecha": pd.date_range(start="2024-01-01", periods=4, freq='M'),
                "Resultados": [90, 85, 92, 88],
                "Meta": [95, 95, 95, 95]
            })
        },
        "Procesos": {
            "indicador": "Eficiencia",
            "cumplimiento": 65,
            "mejor_es_mayor": True,
            "tendencia": [60, 65, 70, 65],
            "datos": pd.DataFrame({
                "Fecha": pd.date_range(start="2024-01-01", periods=4, freq='M'),
                "Resultados": [70, 68, 75, 65],
                "Meta": [80, 80, 80, 80]
            })
        },
        "Aprendizaje": {
            "indicador": "Capacitación",
            "cumplimiento": 90,
            "mejor_es_mayor": True,
            "tendencia": [80, 85, 90, 95],
            "datos": pd.DataFrame({
                "Fecha": pd.date_range(start="2024-01-01", periods=4, freq='M'),
                "Resultados": [95, 92, 98, 90],
                "Meta": [100, 100, 100, 100]
            })
        }
    }

with tab3:
    st.header("Balanced Scorecard")

    perspectives = list(st.session_state["bsc"].keys())
    col1, col2, col3, col4 = st.columns(4)

    for i, perspective in enumerate(perspectives):
        col = [col1, col2, col3, col4][i]
        with col:
            data = st.session_state["bsc"][perspective]

            # Contenido del expansor
            with st.expander(f"Datos de {perspective}", expanded=False):
                # Edición del nombre del indicador
                nuevo_indicador = st.text_input(
                    f"Nombre del Indicador ({perspective})",
                    value=data["indicador"],
                    help="Escribe el nombre del indicador para esta perspectiva.",
                    key=f"indicador_{perspective}"
                )
                st.session_state["bsc"][perspective]["indicador"] = nuevo_indicador

                # Configurar si un mayor resultado es mejor
                nuevo_mejor_es_mayor = st.radio(
                    f"¿Un mayor resultado es mejor para {perspective}?",
                    options=[True, False],
                    format_func=lambda x: "Sí" if x else "No",
                    index=0 if data["mejor_es_mayor"] else 1,
                    key=f"mejor_es_mayor_{perspective}"
                )
                st.session_state["bsc"][perspective]["mejor_es_mayor"] = nuevo_mejor_es_mayor

                # Editor de datos
                df_editable = st.data_editor(
                    data["datos"],
                    use_container_width=True,
                    num_rows="dynamic",
                    key=f"datos_{perspective}"
                )
                st.session_state["bsc"][perspective]["datos"] = df_editable

            # Actualizar datos para gráficos
            datos = st.session_state["bsc"][perspective]["datos"]
            target = datos["Meta"].mean()
            mean_result = datos["Resultados"].mean()

            # Evaluar cumplimiento según nueva configuración
            mejor_es_mayor = st.session_state["bsc"][perspective]["mejor_es_mayor"]
            cumplimiento = (
                mean_result >= target if mejor_es_mayor else mean_result <= target
            )
            color_barra = "green" if cumplimiento else "red"

            # Gauge Chart
            fig_gauge = go.Figure(go.Indicator(
                mode="gauge+number",
                value=mean_result,
                title={'text': f"{perspective} - {nuevo_indicador}"},
                gauge={
                    'axis': {'range': [0, target * 1.2]},
                    'bar': {'color': color_barra},
                    'threshold': {
                        'line': {'color': "blue", 'width': 4},
                        'value': target
                    }
                }
            ))
            fig_gauge.update_layout(height=250, width=220)
            st.plotly_chart(fig_gauge, use_container_width=True)

            # Control Chart
            colors = [
                'red' if (r < target and mejor_es_mayor) or (r > target and not mejor_es_mayor) else 'green'
                for r in datos["Resultados"]
            ]
            fig_control = go.Figure()
            fig_control.add_trace(go.Scatter(
                x=datos["Fecha"], y=datos["Resultados"],
                mode='markers', marker=dict(color=colors, size=10),
                name='Resultado'
            ))
            fig_control.add_hline(
                y=target, line_dash="dash", line_color="black",
                annotation_text="Meta", annotation_position="top right"
            )
            fig_control.add_trace(go.Scatter(
                x=datos["Fecha"], y=datos["Resultados"],
                mode='lines', line=dict(color='blue'),
                name='Tendencia'
            ))
            fig_control.update_layout(
                title=f'Desempeño de {perspective}',
                xaxis_title='Fecha', yaxis_title='Resultados',
                showlegend=False, autosize=True,
                width=250, height=300
            )
            st.plotly_chart(fig_control, use_container_width=True)

    # Resumen de acciones
    # Calcular el estado total de las acciones
    estados_acciones = {"Abiertas": 0, "Cerradas": 0, "Vencidas": 0, "Pendientes": 0}
    acciones = [
        {"descripcion": "Acción de revisión de presupuesto anual.", "fecha_inicio": "2024-11-01", "fecha_fin": "2024-11-10", "estado": "Abierta"},
        {"descripcion": "Evaluación de satisfacción de clientes.", "fecha_inicio": "2024-10-01", "fecha_fin": "2024-10-15", "estado": "Cerrada"},
        {"descripcion": "Revisión de procesos de producción.", "fecha_inicio": "2024-10-01", "fecha_fin": "2024-10-05", "estado": "Vencida"},
        {"descripcion": "Implementación de nueva estrategia de marketing.", "fecha_inicio": "2024-11-05", "fecha_fin": "2024-11-15", "estado": "Pendiente"},
        {"descripcion": "Evaluación de desempeño de equipos.", "fecha_inicio": "2024-11-02", "fecha_fin": "2024-11-08", "estado": "Abierta"},
        {"descripcion": "Rediseño de página web corporativa.", "fecha_inicio": "2024-11-01", "fecha_fin": "2024-11-20", "estado": "Pendiente"},
        {"descripcion": "Implementación de sistema ERP.", "fecha_inicio": "2024-10-10", "fecha_fin": "2024-10-12", "estado": "Vencida"},
        {"descripcion": "Revisión de estrategia de precios.", "fecha_inicio": "2024-11-03", "fecha_fin": "2024-11-09", "estado": "Abierta"}
    ]

    # Calcular la cantidad de acciones en cada estado
    for accion in acciones:
        if accion["estado"] == "Abierta":
            estados_acciones["Abiertas"] += 1
        elif accion["estado"] == "Cerrada":
            estados_acciones["Cerradas"] += 1
        elif accion["estado"] == "Vencida":
            estados_acciones["Vencidas"] += 1
        elif accion["estado"] == "Pendiente":
            estados_acciones["Pendientes"] += 1

    # Mostrar métricas con colores
    st.header("Resumen de Acciones")
    col1, col2, col3, col4 = st.columns(4)

    # Mostrar colores de estado de acciones
    col1.markdown(f"<h2 style='color:green;'>Acciones Abiertas: {estados_acciones['Abiertas']}</h2>", unsafe_allow_html=True)
    col2.markdown(f"<h2 style='color:gray;'>Acciones Cerradas: {estados_acciones['Cerradas']}</h2>", unsafe_allow_html=True)
    col3.markdown(f"<h2 style='color:red;'>Acciones Vencidas: {estados_acciones['Vencidas']}</h2>", unsafe_allow_html=True)
    col4.markdown(f"<h2 style='color:yellow;'>Acciones Pendientes: {estados_acciones['Pendientes']}</h2>", unsafe_allow_html=True)

    # Expansor para mostrar las acciones en detalle (por ejemplo, un Gantt)
    with st.expander("Ver Detalle de Acciones", expanded=False):
        # Crear DataFrame para mostrar las acciones
        df_acciones = pd.DataFrame(acciones)
                # Mostrar botón para agregar una nueva acción
        if st.button("Agregar Nueva Acción"):
            nueva_accion = {
                "descripcion": "Nueva Acción",
                "fecha_inicio": "2024-11-01",
                "fecha_fin": "2024-11-10",
                "estado": "Pendiente"
            }
            # Agregar la nueva acción a la lista de acciones
            acciones.append(nueva_accion)
            df_acciones = pd.DataFrame(acciones)  # Actualizar el DataFrame

        # Mostrar botón para eliminar una acción seleccionada
        st.write("Selecciona una acción para eliminar:")
        accion_a_eliminar = st.selectbox("Selecciona la acción a eliminar", df_acciones['descripcion'].tolist())
        
        if st.button("Eliminar Acción"):
            # Eliminar la acción seleccionada
            acciones = [accion for accion in acciones if accion["descripcion"] != accion_a_eliminar]
            df_acciones = pd.DataFrame(acciones)  # Actualizar el DataFrame


        # Permitir la edición de las acciones (editar y agregar nuevas)
        st.write("Detalle de Acciones:")
        df_acciones = st.data_editor(df_acciones, use_container_width=True)

        # Actualizar la lista de acciones con los cambios hechos
        acciones = df_acciones.to_dict(orient="records")
        
        # Calcular nuevamente los estados de las acciones después de la edición
        estados_acciones = {"Abiertas": 0, "Cerradas": 0, "Vencidas": 0, "Pendientes": 0}
        for accion in acciones:
            if accion["estado"] == "Abierta":
                estados_acciones["Abiertas"] += 1
            elif accion["estado"] == "Cerrada":
                estados_acciones["Cerradas"] += 1
            elif accion["estado"] == "Vencida":
                estados_acciones["Vencidas"] += 1
            elif accion["estado"] == "Pendiente":
                estados_acciones["Pendientes"] += 1

        # Gantt de acciones
        fig = px.timeline(df_acciones, x_start="fecha_inicio", x_end="fecha_fin", y="descripcion",
                        color="estado", color_discrete_map={
                            "Abierta": "green", "Cerrada": "gray", "Vencida": "red", "Pendiente": "yellow"
                        },
                        title="Estado de las Acciones", labels={"estado": "Estado de la Acción"})
        fig.update_yaxes(categoryorder="total ascending")  # Para ordenar las acciones por cantidad
        fig.update_layout(xaxis_title="Fechas", yaxis_title="Descripción de la Acción", showlegend=False)

        # Mostrar gráfico Gantt
        st.plotly_chart(fig, use_container_width=True)

#_________________________________________________________________________________________________________________________________________________________________

# Contenido del cuarto tab: Hoshin Kanri
with tab4:
    st.header("🌀 Matriz Hoshin Kanri")

    # Configuración del estado para mantener los datos entre rerenderizaciones
    if 'relationships_data' not in st.session_state:
        # Datos iniciales para cada sección
        st.session_state.top_level_priorities = {
            "Prioridades de Mejora de Alto Nivel": [
                "Reducir costos logísticos",
                "Mejorar la entrega a tiempo",
                "Incrementar ingresos operativos",
            ]
        }

        st.session_state.annual_goals = {
            "Metas Anuales": [
                "Alcanzar 98% de entregas a tiempo",
                "Reducir la rotación voluntaria",
                "Optimización de inventarios",
            ]
        }

        st.session_state.metrics = {
            "Métricas": [
                "Precisión de inventarios al 95%",
                "Tasa de desechos menor al 3%",
                "Meta de ventas de $18M",
            ]
        }

        st.session_state.breakthrough_objectives = {
            "Visión estratégica": [
                "Mejorar la entrega a tiempo",
                "Reducir la tasa de desechos",
                "Lograr un cambio significativo en precisión",
            ]
        }

        # Inicializar el DataFrame de relaciones con las dimensiones correctas
        st.session_state.relationships_data = pd.DataFrame({
            "Tipo de Relación": [
                "Metas Anuales vs Prioridades de Alto Nivel",
                "Prioridades de Alto Nivel vs Métricas",
                "Visión estratégica vs Metas Anuales",
            ],
            "Filas": [
                st.session_state.annual_goals["Metas Anuales"],
                st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"],
                st.session_state.breakthrough_objectives["Visión estratégica"],
            ],
            "Columnas": [
                st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"],
                st.session_state.metrics["Métricas"],
                st.session_state.annual_goals["Metas Anuales"],
            ],
            "Matriz": [
                [[1, 0, 1], [0, 1, 1], [1, 1, 0]],  # Relación 1 (3x3)
                [[1, 1, 0], [0, 1, 1], [1, 0, 1]],  # Relación 2 (3x3)
                [[1, 0, 1], [1, 1, 0], [0, 1, 1]],  # Relación 3 (3x3)
            ],
        })

    def create_heatmap(data, rows, cols, title):
        """Función mejorada para crear heatmaps con Plotly"""
        # Verificar que las dimensiones coincidan
        if isinstance(data, list):
            data = np.array(data)
        
        # Asegurarse de que las dimensiones coincidan
        if len(rows) != data.shape[0] or len(cols) != data.shape[1]:
            raise ValueError(f"Dimensiones no coinciden: Matriz {data.shape}, Filas {len(rows)}, Columnas {len(cols)}")
        
        heatmap_data = pd.DataFrame(
            data,
            index=rows,
            columns=cols
        )
        
        fig = go.Figure(data=go.Heatmap(
            z=heatmap_data.values,
            x=heatmap_data.columns,
            y=heatmap_data.index,
            colorscale='Viridis',
            showscale=True,
            text=np.round(heatmap_data.values, 2),
            texttemplate="%{text}",
            textfont={"size": 10},
            hoverongaps=False
        ))
        
        fig.update_layout(
            title=dict(
                text=title,
                font=dict(size=14),
                x=0.5,
                xanchor='center'
            ),
            xaxis_title="Columnas",
            yaxis_title="Filas",
            height=350,
            margin=dict(l=50, r=50, t=50, b=50),
            xaxis={'side': 'bottom'},
            yaxis_autorange='reversed'
        )
        
        return fig

    def update_relationships():
        """Función para actualizar las relaciones y matrices asegurando dimensiones correctas"""
        for i in range(len(st.session_state.relationships_data)):
            if i == 0:
                st.session_state.relationships_data.at[i, "Filas"] = st.session_state.annual_goals["Metas Anuales"]
                st.session_state.relationships_data.at[i, "Columnas"] = st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"]
            elif i == 1:
                st.session_state.relationships_data.at[i, "Filas"] = st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"]
                st.session_state.relationships_data.at[i, "Columnas"] = st.session_state.metrics["Métricas"]
            elif i == 2:
                st.session_state.relationships_data.at[i, "Filas"] = st.session_state.breakthrough_objectives["Visión estratégica"]
                st.session_state.relationships_data.at[i, "Columnas"] = st.session_state.annual_goals["Metas Anuales"]
            
            # Verificar y ajustar las dimensiones de la matriz si es necesario
            filas = len(st.session_state.relationships_data.at[i, "Filas"])
            columnas = len(st.session_state.relationships_data.at[i, "Columnas"])
            matriz_actual = st.session_state.relationships_data.at[i, "Matriz"]
            
            # Si las dimensiones no coinciden, crear una nueva matriz con las dimensiones correctas
            if len(matriz_actual) != filas or len(matriz_actual[0]) != columnas:
                nueva_matriz = [[0 for _ in range(columnas)] for _ in range(filas)]
                # Copiar los valores existentes que quepan en la nueva matriz
                for f in range(min(filas, len(matriz_actual))):
                    for c in range(min(columnas, len(matriz_actual[0]))):
                        nueva_matriz[f][c] = matriz_actual[f][c]
                st.session_state.relationships_data.at[i, "Matriz"] = nueva_matriz

    # Contenedor principal para organizar la cuadrícula
    with st.container():
        # Fila 1: Heatmap 1, DataFrame de Prioridades de Alto Nivel, Heatmap 2
        col1, col2, col3 = st.columns(3)
        
        with col1:
            try:
                st.plotly_chart(
                    create_heatmap(
                        st.session_state.relationships_data.at[0, "Matriz"],
                        st.session_state.relationships_data.at[0, "Filas"],
                        st.session_state.relationships_data.at[0, "Columnas"],
                        "Metas Anuales vs Prioridades de Alto Nivel"
                    ),
                    use_container_width=True
                )
            except Exception as e:
                st.error(f"Error al crear heatmap 1: {str(e)}")

        with col2:
            st.subheader("3. Prioridades de Mejora de Alto Nivel")
            top_level_df = pd.DataFrame({
                "Prioridades de Mejora de Alto Nivel": 
                st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"]
            })
            edited_top_level = st.data_editor(
                top_level_df,
                use_container_width=True,
                key="prioridades_alto_nivel",
                num_rows="dynamic"
            )
            st.session_state.top_level_priorities["Prioridades de Mejora de Alto Nivel"] = \
                edited_top_level["Prioridades de Mejora de Alto Nivel"].tolist()
            update_relationships()

        with col3:
            try:
                st.plotly_chart(
                    create_heatmap(
                        st.session_state.relationships_data.at[1, "Matriz"],
                        st.session_state.relationships_data.at[1, "Filas"],
                        st.session_state.relationships_data.at[1, "Columnas"],
                        "Prioridades de Alto Nivel vs Métricas"
                    ),
                    use_container_width=True
                )
            except Exception as e:
                st.error(f"Error al crear heatmap 2: {str(e)}")

    with st.container():
        # Fila 2: DataFrame de Metas Anuales, "Matriz X", DataFrame de Métricas
        col1, col2, col3 = st.columns(3)
        
        with col1:
            st.subheader("2. Metas Anuales")
            annual_goals_df = pd.DataFrame({
                "Metas Anuales": st.session_state.annual_goals["Metas Anuales"]
            })
            edited_annual_goals = st.data_editor(
                annual_goals_df,
                use_container_width=True,
                key="metas_anuales",
                num_rows="dynamic"
            )
            st.session_state.annual_goals["Metas Anuales"] = \
                edited_annual_goals["Metas Anuales"].tolist()
            update_relationships()

        with col2:
            st.image("X matrix.png", caption="Matriz X", use_container_width=True)


        with col3:
            st.subheader("4. Métricas")
            metrics_df = pd.DataFrame({
                "Métricas": st.session_state.metrics["Métricas"]
            })
            edited_metrics = st.data_editor(
                metrics_df,
                use_container_width=True,
                key="metricas",
                num_rows="dynamic"
            )
            st.session_state.metrics["Métricas"] = \
                edited_metrics["Métricas"].tolist()
            update_relationships()

    with st.container():
        # Fila 3: Heatmap 3, DataFrame de Visión estratégica, espacio vacío
        col1, col2, col3 = st.columns(3)
        
        with col1:
            try:
                st.plotly_chart(
                    create_heatmap(
                        st.session_state.relationships_data.at[2, "Matriz"],
                        st.session_state.relationships_data.at[2, "Filas"],
                        st.session_state.relationships_data.at[2, "Columnas"],
                        "Visión estratégica vs Metas Anuales"
                    ),
                    use_container_width=True
                )
            except Exception as e:
                st.error(f"Error al crear heatmap 3: {str(e)}")

        with col2:
            st.subheader("1. Visión estratégica")
            breakthrough_objectives_df = pd.DataFrame({
                "Visión estratégica": 
                st.session_state.breakthrough_objectives["Visión estratégica"]
            })
            edited_breakthrough = st.data_editor(
                breakthrough_objectives_df,
                use_container_width=True,
                key="vision_estrategica",
                num_rows="dynamic"
            )
            st.session_state.breakthrough_objectives["Visión estratégica"] = \
                edited_breakthrough["Visión estratégica"].tolist()
            update_relationships()

        with col3:
            st.empty()

    st.markdown("<h6>Ajusta las relaciones entre las diferentes entidades</h6>", unsafe_allow_html=True)
    # Editar relaciones con st.expander y callback para actualizaciones
    with st.expander("✏️ Editar Relaciones"):
        
        
        for i, row in st.session_state.relationships_data.iterrows():
            st.subheader(row["Tipo de Relación"])
            
            try:
                # Crear la matriz como DataFrame editable
                relationship_matrix = pd.DataFrame(
                    row["Matriz"],
                    columns=row["Columnas"],
                    index=row["Filas"]
                )
                
                # Editor de datos con callback para actualizaciones
                updated_matrix = st.data_editor(
                    relationship_matrix,
                    use_container_width=True,
                    key=f"relationship_{i}"
                )
                
                # Actualizar la matriz en el estado de la sesión
                st.session_state.relationships_data.at[i, "Matriz"] = \
                    updated_matrix.values.tolist()
            except Exception as e:
                st.error(f"Error al editar relación {i+1}: {str(e)}")

    # Asegurar que las relaciones estén actualizadas
    update_relationships()

#_______________________________________________________________________________________________

    # Contenido del Bowling Chart
    st.header("🎯 Bowling Chart - Seguimiento de Métricas")

    if 'bowling_data' not in st.session_state:
        st.session_state.bowling_data = {
            "metrics": [
                {
                    "name": "Mejorar entregas a tiempo",
                    "unit": "%",
                    "type": "KPI",
                    "owner": "Juan Gomez",
                    "targets": {
                        "Ene": 100, "Feb": 100, "Mar": 100,
                        "Abr": 100, "May": 100, "Jun": 100,
                        "Jul": 100, "Ago": 100, "Sep": 100,
                        "Oct": 100, "Nov": 100, "Dic": 100
                    },
                    "actuals": {
                        "Ene": 100, "Feb": 98.1, "Mar": 100,
                        "Abr": 100, "May": None, "Jun": None,
                        "Jul": None, "Ago": None, "Sep": None,
                        "Oct": None, "Nov": None, "Dic": None
                    },
                    "better_if_less": False  # Mejor si es mayor
                },

                # Nueva métrica 1
                {
                    "name": "Precisión de inventarios al 95%",
                    "unit": "%",
                    "type": "KPI",
                    "owner": "Ana Morales",
                    "targets": {
                        "Ene": 95, "Feb": 95, "Mar": 95,
                        "Abr": 95, "May": 95, "Jun": 95,
                        "Jul": 95, "Ago": 95, "Sep": 95,
                        "Oct": 95, "Nov": 95, "Dic": 95
                    },
                    "actuals": {
                        "Ene": 94.5, "Feb": 95.2, "Mar": 95.0,
                        "Abr": 95.0, "May": None, "Jun": None,
                        "Jul": None, "Ago": None, "Sep": None,
                        "Oct": None, "Nov": None, "Dic": None
                    },
                    "better_if_less": False  # Mejor si es mayor
                },
                # Nueva métrica 2
                {
                    "name": "Tasa de desechos menor al 3%",
                    "unit": "%",
                    "type": "KPI",
                    "owner": "Luis Hernández",
                    "targets": {
                        "Ene": 3.00, "Feb": 3.00, "Mar": 3.00,
                        "Abr": 3.00, "May": 3.00, "Jun": 3.00,
                        "Jul": 3.00, "Ago": 3.00, "Sep": 3.00,
                        "Oct": 3.00, "Nov": 3.00, "Dic": 3.00
                    },
                    "actuals": {
                        "Ene": 2.90, "Feb": 3.10, "Mar": 2.80,
                        "Abr": 3.00, "May": None, "Jun": None,
                        "Jul": None, "Ago": None, "Sep": None,
                        "Oct": None, "Nov": None, "Dic": None
                    },
                    "better_if_less": True  # Mejor si es menor
                },
                # Nueva métrica 3
                {
                    "name": "Meta de ventas de $18M",
                    "unit": "USD",
                    "type": "KPI",
                    "owner": "Marta Pérez",
                    "targets": {
                        "Ene": 1500000, "Feb": 1500000, "Mar": 1500000,
                        "Abr": 1500000, "May": 1500000, "Jun": 1500000,
                        "Jul": 1500000, "Ago": 1500000, "Sep": 1500000,
                        "Oct": 1500000, "Nov": 1500000, "Dic": 1500000
                    },
                    "actuals": {
                        "Ene": 1600000, "Feb": 1505000, "Mar": 1502000,
                        "Abr": 1503000, "May": None, "Jun": None,
                        "Jul": None, "Ago": None, "Sep": None,
                        "Oct": None, "Nov": None, "Dic": None
                    },
                    "better_if_less": False  # Mejor si es mayor
                }
            ]
        }

    def get_status_color(actual, target, better_if_less):
        """Determina el color del estado basado en el valor actual vs objetivo"""
        if actual is None:
            return "gray"  # Si no hay valor actual, muestra gris

        if better_if_less:
            # Mejor si es menor, por ejemplo para Waste Rate
            if actual <= target:
                return "green"
            elif actual <= target * 1.05:  # 105% del objetivo
                return "yellow"
            return "red"
        else:
            # Mejor si es mayor, por ejemplo para On-Time Delivery
            if actual >= target:
                return "green"
            elif actual >= target * 0.95:  # 95% del objetivo
                return "yellow"
            return "red"

    def create_bowling_chart():
        """Crea la visualización del bowling chart"""
        # Crear la tabla de datos
        months = ["Ene", "Feb", "Mar", "Abr", "May", "Jun",
                "Jul", "Ago", "Sep", "Oct", "Nov", "Dic"]

        # Crear el diseño de la tabla
        header_cols = st.columns([2, 1, 1] + [1]*12)  # Columnas para "Metric Name", "Unit", "Owner" y los meses

        # Encabezados
        with header_cols[0]:
            st.write("**Nombre de la Métrica**")
        with header_cols[1]:
            st.write("**Unidad**")
        with header_cols[2]:
            st.write("**Propietario**")
        for i, month in enumerate(months):
            with header_cols[i + 3]:  # Los meses empiezan después de las tres primeras columnas
                st.write(f"**{month}**")

        # Datos de las métricas
        for metric in st.session_state.bowling_data["metrics"]:
            row = st.columns([2, 1, 1] + [1]*12)  # Fila para los valores de la métrica

            # Escribir los valores de la métrica
            with row[0]:
                st.write(metric["name"])
            with row[1]:
                st.write(metric["unit"])
            with row[2]:
                st.write(metric["owner"])
            
            # Escribir los valores mensuales (T: target, A: actual)
            for i, month in enumerate(months):
                with row[i + 3]:
                    target = metric["targets"].get(month)
                    actual = metric["actuals"].get(month)

                    # Crear contenedor con color de fondo según "Mejor si es"
                    color = get_status_color(actual, target, metric.get("better_if_less", False))  # Asegurarnos de que 'better_if_less' exista
                    st.markdown(
                        f"""
                        <div style="background-color: {color}; padding: 5px; border-radius: 5px; text-align: center; margin: 2px;">
                            <div style="font-size: 0.8em;">T: {target}</div>
                            <div style="font-size: 0.8em;">A: {actual if actual is not None else 'N/A'}</div>
                        </div>
                        """,
                        unsafe_allow_html=True
                    )

    # Llamada para generar el bowling chart
    create_bowling_chart()

    st.markdown("<h6>Ajusta los valores de las métricas o agrega nuevas </h6>", unsafe_allow_html=True)

    # Sección para editar valores
    with st.expander("✏️ Editar Valores"):
        metric_names = [metric["name"] for metric in st.session_state.bowling_data["metrics"]]
        selected_metric = st.selectbox("Seleccionar Métrica", metric_names)
        
        metric_index = metric_names.index(selected_metric)
        metric = st.session_state.bowling_data["metrics"][metric_index]
        
        better_if_less = st.checkbox("Mejor si es menor", value=metric.get("better_if_less", False))
        metric["better_if_less"] = better_if_less

        col1, col2 = st.columns(2)
        
        with col1:
            st.subheader("Objetivos")
            for month, target in metric["targets"].items():
                new_target = st.number_input(
                    f"Objetivo {month}",
                    value=float(target),
                    key=f"target_{selected_metric}_{month}"
                )
                metric["targets"][month] = new_target
                    
        with col2:
            st.subheader("Valores Actuales")
            for month, actual in metric["actuals"].items():
                new_actual = st.number_input(
                    f"Actual {month}",
                    value=float(actual) if actual is not None else 0.0,
                    key=f"actual_{selected_metric}_{month}"
                )
                metric["actuals"][month] = new_actual if new_actual != 0.0 else None

    # Sección para agregar nuevas métricas
    with st.expander("➕ Agregar Nueva Métrica"):
        with st.form("add_metric_form"):
            name = st.text_input("Nombre de la Métrica")
            unit = st.text_input("Unidad de Medida")
            owner = st.text_input("Propietario")
            
            # Checkbox para "Mejor si es menor" después de "Propietario"
            better_if_less = st.checkbox("Mejor si es menor")
            
            col1, col2 = st.columns(2)  # Columnas para los objetivos y valores actuales
            
            # Ingresar los objetivos mensuales
            with col1:
                st.subheader("Objetivos")
                targets = {}
                for month in ["Ene", "Feb", "Mar", "Abr", "May", "Jun", "Jul", "Ago", "Sep", "Oct", "Nov", "Dic"]:
                    targets[month] = st.number_input(f"Objetivo {month}", value=100, key=f"target_{month}")
            
            # Ingresar los valores actuales
            with col2:
                st.subheader("Valores Actuales")
                actuals = {}
                for month in ["Ene", "Feb", "Mar", "Abr", "May", "Jun", "Jul", "Ago", "Sep", "Oct", "Nov", "Dic"]:
                    actuals[month] = st.number_input(f"Actual {month}", value=None, format="%.2f", key=f"actual_{month}")

            # Botón de enviar para agregar la métrica
            submit_button = st.form_submit_button("Agregar Métrica")
            
            if submit_button:
                new_metric = {
                    "name": name,
                    "unit": unit,
                    "type": "KPI",
                    "owner": owner,
                    "targets": targets,
                    "actuals": actuals,
                    "better_if_less": better_if_less
                }
                st.session_state.bowling_data["metrics"].append(new_metric)
                st.success(f"Métrica '{name}' agregada exitosamente.")

#_________________________________________________________________________________________________________________________________________________________________

# Pestaña: Acerca de mí
with tab5:
    st.header("Acerca de mí")
    acerca_de_mi = """
    ¡Hola! Soy José Miguel, desarrollo herramientas para facilitar la visualización y organización de ideas mediante visualizaciones interactivas. Esta aplicación está diseñada para ayudarte a estructurar tus pensamientos de manera eficiente y creativa, utilizando tecnologías de desarrollo de aplicaciones en Python.

    **Características de la Aplicación:**
    - **Interfaz Intuitiva:** Agrega tu objetivos y kpi's de acuerdo al método que mejor se adapte a tu necesidad.
    - **Visualización Interactiva:** Explora los modelos de gestión estratégica de manera dinámica y visualmente atractiva.
    - **Personalización:** Cambia los datos y ajustalos a tus necesidades.

    **Contacto:**
    - **Correo Electrónico:** [mail](mailto:josemiguelaguilart.com)
    - **LinkedIn:** [LinkedIn](https://www.linkedin.com/in/josemaguilar/)
    """
    st.markdown(acerca_de_mi)