app.py

import numpy as np
import pandas as pd
import statsmodels.formula.api as smf
import statsmodels.api as sm
import plotly.graph_objects as go
from scipy.optimize import minimize
import plotly.express as px
from scipy.stats import f
import gradio as gr
import io
import zipfile
import tempfile
from datetime import datetime
import docx
from docx.shared import Inches, Pt
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
import os
from pyDOE import bbdesign, ccdesign

# --- Clase RSM_ExperimentalDesign ---
class RSM_ExperimentalDesign:
    def __init__(self, data, design_type, factor_names, y_name, factor_levels):
        """
        Inicializa la clase con los datos del diseño experimental.
        
        Args:
            data (pd.DataFrame): Datos del experimento.
            design_type (str): Tipo de diseño ('Box-Behnken' o 'Central Compuesto').
            factor_names (list): Lista de nombres de los factores.
            y_name (str): Nombre de la variable dependiente.
            factor_levels (dict): Diccionario con los niveles de cada factor.
        """
        self.data = data.copy()
        self.design_type = design_type
        self.factor_names = factor_names
        self.y_name = y_name
        self.factor_levels = factor_levels
        self.model = None
        self.model_simplified = None
        self.optimized_results = None
        self.optimal_levels = None
        self.all_figures = []
        self.selected_factors = []

    def generate_design(self):
        """
        Genera el diseño experimental basado en el tipo especificado y asigna los niveles naturales.
        """
        num_factors = len(self.factor_names)
        if self.design_type == 'Box-Behnken':
            design = bbdesign(num_factors)
        elif self.design_type == 'Central Compuesto':
            design = ccdesign(num_factors, center=(3, 3))  # Puedes ajustar los puntos centrales si lo deseas
        else:
            raise ValueError("Tipo de diseño no soportado. Elige 'Box-Behnken' o 'Central Compuesto'.")
        
        # Asignar niveles naturales a las variables
        for i, factor in enumerate(self.factor_names):
            self.data[factor] = self.coded_to_natural(design[:, i], factor)
        
        return self.data

    def coded_to_natural(self, coded_value, variable_name):
        """Convierte un valor codificado a su valor natural."""
        levels = self.factor_levels[variable_name]
        if len(levels) != 3:
            raise ValueError(f"Se requieren exactamente 3 niveles para el factor '{variable_name}'.")
        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2

    def natural_to_coded(self, natural_value, variable_name):
        """Convierte un valor natural a su valor codificado."""
        levels = self.factor_levels[variable_name]
        return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])

    def fit_model(self):
        """
        Ajusta el modelo de segundo orden completo a los datos.
        """
        terms = self.factor_names.copy()
        # Términos cuadráticos
        terms += [f'I({var}**2)' for var in self.factor_names]
        # Términos de interacción
        for i in range(len(self.factor_names)):
            for j in range(i+1, len(self.factor_names)):
                terms.append(f'{self.factor_names[i]}:{self.factor_names[j]}')
        
        formula = f'{self.y_name} ~ ' + ' + '.join(terms)
        self.model = smf.ols(formula, data=self.data).fit()
        print("Modelo Completo:")
        print(self.model.summary())
        return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")

    def fit_simplified_model(self, selected_factors):
        """
        Ajusta el modelo simplificado basado en los factores seleccionados.
        
        Args:
            selected_factors (list): Lista de factores a incluir en el modelo.
        """
        self.selected_factors = selected_factors
        terms = selected_factors.copy()
        # Términos cuadráticos
        terms += [f'I({var}**2)' for var in selected_factors]
        formula = f'{self.y_name} ~ ' + ' + '.join(terms)
        self.model_simplified = smf.ols(formula, data=self.data).fit()
        print("\nModelo Simplificado:")
        print(self.model_simplified.summary())
        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")

    def optimize(self, method='Nelder-Mead'):
        """
        Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return
        
        def objective_function(x):
            input_data = {var: [x[i]] for i, var in enumerate(self.selected_factors)}
            return -self.model_simplified.predict(pd.DataFrame(input_data)).values[0]
        
        # Definir límites codificados para cada factor
        bounds = [(-1, 1) for _ in self.selected_factors]
        x0 = [0] * len(self.selected_factors)
        
        self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
        self.optimal_levels = self.optimized_results.x
        
        # Convertir niveles óptimos de codificados a naturales
        optimal_levels_natural = [
            self.coded_to_natural(self.optimal_levels[i], self.selected_factors[i])
            for i in range(len(self.selected_factors))
        ]
        
        # Crear la tabla de optimización
        optimization_table = pd.DataFrame({
            'Variable': self.selected_factors,
            'Nivel Óptimo (Natural)': optimal_levels_natural,
            'Nivel Óptimo (Codificado)': self.optimal_levels
        })
        
        return optimization_table.round(3)

    def plot_rsm_individual(self, fixed_variable, fixed_level):
        """
        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return None

        varying_variables = [var for var in self.selected_factors if var != fixed_variable]
        if len(varying_variables) < 2:
            print("Se requieren al menos dos variables para generar un gráfico de superficie.")
            return None
        
        var1, var2 = varying_variables[:2]  # Solo tomar las dos primeras variables para el gráfico
        
        # Determinar los niveles naturales para las variables que varían
        x_natural_levels = self.factor_levels[var1]
        y_natural_levels = self.factor_levels[var2]

        # Crear una malla de puntos para las variables que varían (en unidades naturales)
        x_range_natural = np.linspace(x_natural_levels[0], x_natural_levels[-1], 100)
        y_range_natural = np.linspace(y_natural_levels[0], y_natural_levels[-1], 100)
        x_grid_natural, y_grid_natural = np.meshgrid(x_range_natural, y_range_natural)

        # Convertir la malla de variables naturales a codificadas
        x_grid_coded = self.natural_to_coded(x_grid_natural, var1)
        y_grid_coded = self.natural_to_coded(y_grid_natural, var2)

        # Crear un DataFrame para la predicción con variables codificadas
        prediction_data = pd.DataFrame({
            var1: x_grid_coded.flatten(),
            var2: y_grid_coded.flatten(),
        })

        # Asignar valores codificados a las otras variables fijas
        for var in self.selected_factors:
            if var not in [var1, var2]:
                prediction_data[var] = self.natural_to_coded(fixed_level, var)

        # Calcular los valores predichos
        z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)

        # Crear el gráfico de superficie
        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])

        # Añadir líneas de cuadrícula
        for i in range(x_grid_natural.shape[0]):
            fig.add_trace(go.Scatter3d(
                x=x_grid_natural[i, :],
                y=y_grid_natural[i, :],
                z=z_pred[i, :],
                mode='lines',
                line=dict(color='gray', width=2),
                showlegend=False,
                hoverinfo='skip'
            ))
        for j in range(x_grid_natural.shape[1]):
            fig.add_trace(go.Scatter3d(
                x=x_grid_natural[:, j],
                y=y_grid_natural[:, j],
                z=z_pred[:, j],
                mode='lines',
                line=dict(color='gray', width=2),
                showlegend=False,
                hoverinfo='skip'
            ))

        # Añadir los puntos de los experimentos
        experiments_data = self.data.copy()
        experiments_data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
        colors = px.colors.qualitative.Safe
        point_labels = [f"{row[self.y_name]:.3f}" for _, row in experiments_data.iterrows()]

        fig.add_trace(go.Scatter3d(
            x=experiments_data[var1],
            y=experiments_data[var2],
            z=experiments_data[self.y_name],
            mode='markers+text',
            marker=dict(size=4, color=colors[:len(experiments_data)]),
            text=point_labels,
            textposition='top center',
            name='Experimentos'
        ))

        # Añadir etiquetas y título con variables naturales
        fig.update_layout(
            scene=dict(
                xaxis_title=f"{var1} ({self.get_units(var1)})",
                yaxis_title=f"{var2} ({self.get_units(var2)})",
                zaxis_title=self.y_name,
            ),
            title=f"{self.y_name} vs {var1} y {var2}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
            height=800,
            width=1000,
            showlegend=True
        )
        return fig

    def get_units(self, variable_name):
        """
        Define las unidades de las variables para etiquetas.
        Puedes personalizar este método según tus necesidades.
        """
        units = {
            'Glucosa': 'g/L',
            'Extracto_de_Levadura': 'g/L',
            'Triptófano': 'g/L',
            'AIA_ppm': 'ppm',
            # Agrega más unidades según tus variables
        }
        return units.get(variable_name, '')

    def generate_all_plots(self):
        """
        Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
        Almacena las figuras en self.all_figures.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return

        self.all_figures = []  # Resetear la lista de figuras

        # Niveles naturales para graficar
        for fixed_variable in self.selected_factors:
            for level in self.factor_levels[fixed_variable]:
                fig = self.plot_rsm_individual(fixed_variable, level)
                if fig is not None:
                    self.all_figures.append(fig)

    def pareto_chart(self, model, title):
        """
        Genera un diagrama de Pareto para los efectos usando estadísticos F,
        incluyendo la línea de significancia.
        """
        # Calcular los estadísticos F para cada término
        fvalues = model.tvalues[1:]**2  # Excluir la Intercept y convertir t a F
        abs_fvalues = np.abs(fvalues)
        sorted_idx = np.argsort(abs_fvalues)[::-1]
        sorted_fvalues = abs_fvalues[sorted_idx]
        sorted_names = fvalues.index[sorted_idx]

        # Calcular el valor crítico de F para la línea de significancia
        alpha = 0.05  # Nivel de significancia
        dof_num = 1  # Grados de libertad del numerador (cada término)
        dof_den = model.df_resid  # Grados de libertad residuales
        f_critical = f.ppf(1 - alpha, dof_num, dof_den)

        # Crear el diagrama de Pareto
        fig = px.bar(
            x=sorted_fvalues.round(3),
            y=sorted_names,
            orientation='h',
            labels={'x': 'Estadístico F', 'y': 'Término'},
            title=title
        )
        fig.update_yaxes(autorange="reversed")

        # Agregar la línea de significancia
        fig.add_vline(x=f_critical, line_dash="dot",
                     annotation_text=f"F crítico = {f_critical:.3f}",
                     annotation_position="bottom right")

        return fig

    def get_simplified_equation(self):
        """
        Retorna la ecuación del modelo simplificado como una cadena de texto.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return None

        coefficients = self.model_simplified.params
        equation = f"{self.y_name} = {coefficients['Intercept']:.3f}"

        for term, coef in coefficients.items():
            if term != 'Intercept':
                if term.startswith('I('):
                    equation += f" + {coef:.3f}*{term[2:-1]}"
                elif ':' in term:
                    equation += f" + {coef:.3f}*{term}"
                else:
                    equation += f" + {coef:.3f}*{term}"
        
        return equation

    def generate_prediction_table(self):
        """
        Genera una tabla con los valores actuales, predichos y residuales.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return None

        self.data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
        self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']

        return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)

    def calculate_contribution_percentage(self):
        """
        Calcula el porcentaje de contribución de cada factor usando estadísticos F.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return None
    
        # ANOVA del modelo simplificado
        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
    
        # Suma de cuadrados total
        ss_total = anova_table['sum_sq'].sum()
    
        # Crear tabla de contribución
        contribution_table = pd.DataFrame({
            'Fuente de Variación': [],
            'Suma de Cuadrados': [],
            'Grados de Libertad': [],
            'Cuadrado Medio': [],
            'F': [],
            'Valor p': [],
            '% Contribución': []
        })
    
        # Calcular estadísticos F y porcentaje de contribución para cada factor
        ms_error = anova_table.loc['Residual', 'sum_sq'] / anova_table.loc['Residual', 'df']
    
        # Agregar filas para cada término del modelo
        for index, row in anova_table.iterrows():
            if index != 'Residual':
                factor_name = index
                if factor_name.startswith('I('):
                    factor_name = factor_name[2:-1]  # Quitar 'I(' y ')'
                ss_factor = row['sum_sq']
                df_factor = row['df']
                ms_factor = ss_factor / df_factor
                f_stat = ms_factor / ms_error
                p_value = f.sf(f_stat, df_factor, anova_table.loc['Residual', 'df'])
                contribution_percentage = (ss_factor / ss_total) * 100

                contribution_table = pd.concat([contribution_table, pd.DataFrame({
                    'Fuente de Variación': [factor_name],
                    'Suma de Cuadrados': [ss_factor],
                    'Grados de Libertad': [df_factor],
                    'Cuadrado Medio': [ms_factor],
                    'F': [f_stat],
                    'Valor p': [p_value],
                    '% Contribución': [contribution_percentage]
                })], ignore_index=True)
    
        # Agregar fila para Cor Total
        contribution_table = pd.concat([contribution_table, pd.DataFrame({
            'Fuente de Variación': ['Cor Total'],
            'Suma de Cuadrados': [ss_total],
            'Grados de Libertad': [len(self.data) - 1],
            'Cuadrado Medio': [np.nan],
            'F': [np.nan],
            'Valor p': [np.nan],
            '% Contribución': [100]
        })], ignore_index=True)
    
        return contribution_table.round(3)

    def calculate_detailed_anova(self):
        """
        Calcula la tabla ANOVA detallada con la descomposición del error residual.
        """
        if self.model_simplified is None:
            print("Error: Ajusta el modelo simplificado primero.")
            return None

        # ANOVA del modelo simplificado
        anova_reduced = sm.stats.anova_lm(self.model_simplified, typ=2)

        # Suma de cuadrados total
        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)

        # Suma de cuadrados de la regresión
        ss_regression = anova_reduced['sum_sq'].sum()

        # Grados de libertad de la regresión
        df_regression = anova_reduced['df'].sum()

        # Suma de cuadrados del error residual
        ss_residual = anova_reduced.loc['Residual', 'sum_sq']
        df_residual = anova_reduced.loc['Residual', 'df']

        # Suma de cuadrados del error puro (si hay réplicas)
        duplicates = self.data.duplicated(subset=self.selected_factors, keep=False)
        if duplicates.any():
            ss_pure_error = self.data[duplicates].groupby(self.selected_factors)[self.y_name].var().sum() * self.data[duplicates].groupby(self.selected_factors).ngroups()
            df_pure_error = self.data[duplicates].shape[0] - self.data[duplicates].groupby(self.selected_factors).ngroups()
        else:
            ss_pure_error = np.nan
            df_pure_error = np.nan

        # Suma de cuadrados de la falta de ajuste
        ss_lack_of_fit = ss_residual - ss_pure_error if not np.isnan(ss_pure_error) else np.nan
        df_lack_of_fit = df_residual - df_pure_error if not np.isnan(df_pure_error) else np.nan

        # Cuadrados medios
        ms_regression = ss_regression / df_regression
        ms_residual = ss_residual / df_residual
        ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if not np.isnan(ss_lack_of_fit) else np.nan
        ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(ss_pure_error) else np.nan

        # Estadísticos F y valores p
        f_regression = ms_regression / ms_residual
        p_regression = 1 - f.cdf(f_regression, df_regression, df_residual)

        f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) else np.nan
        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if not np.isnan(f_lack_of_fit) else np.nan

        # Crear la tabla ANOVA detallada
        detailed_anova_table = pd.DataFrame({
            'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
            'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
            'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, len(self.data) - 1],
            'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
            'F': [f_regression, np.nan, f_lack_of_fit, np.nan, np.nan],
            'Valor p': [p_regression, np.nan, p_lack_of_fit, np.nan, np.nan]
        })

        # Reorganizar las filas y resetear el índice
        detailed_anova_table = detailed_anova_table.reindex([0, 1, 2, 3, 4]).reset_index(drop=True)

        return detailed_anova_table.round(3)

    def get_all_tables(self):
        """
        Obtiene todas las tablas generadas para ser exportadas a Excel.
        """
        prediction_table = self.generate_prediction_table()
        contribution_table = self.calculate_contribution_percentage()
        anova_table = self.calculate_detailed_anova()

        return {
            'Predicciones': prediction_table,
            '% Contribución': contribution_table,
            'ANOVA Detallada': anova_table
        }

    def save_figures_to_zip(self):
        """
        Guarda todas las figuras almacenadas en self.all_figures a un archivo ZIP en memoria.
        """
        if not self.all_figures:
            return None

        zip_buffer = io.BytesIO()
        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
            for idx, fig in enumerate(self.all_figures, start=1):
                img_bytes = fig.to_image(format="png")
                zip_file.writestr(f'Grafico_{idx}.png', img_bytes)
        zip_buffer.seek(0)

        # Guardar en un archivo temporal
        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
            temp_file.write(zip_buffer.read())
            temp_path = temp_file.name

        return temp_path

    def save_fig_to_bytes(self, fig):
        """
        Convierte una figura Plotly a bytes en formato PNG.
        """
        return fig.to_image(format="png")

    def save_tables_to_excel(self):
        """
        Guarda todas las tablas en un archivo Excel con múltiples hojas y retorna la ruta del archivo.
        """
        tables = self.get_all_tables()
        excel_buffer = io.BytesIO()
        with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
            for sheet_name, table in tables.items():
                table.to_excel(writer, sheet_name=sheet_name, index=False)
        excel_buffer.seek(0)
        excel_bytes = excel_buffer.read()

        # Guardar en un archivo temporal
        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as temp_file:
            temp_file.write(excel_bytes)
            temp_path = temp_file.name

        return temp_path

    def export_tables_to_word(self, tables_dict):
        """
        Exporta las tablas proporcionadas a un documento de Word.
        """
        if not tables_dict:
            return None

        doc = docx.Document()

        # Configurar estilo de fuente
        style = doc.styles['Normal']
        font = style.font
        font.name = 'Times New Roman'
        font.size = Pt(12)

        # Título del informe
        titulo = doc.add_heading('Informe de Optimización de Producción de AIA', 0)
        titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER

        doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}").alignment = WD_PARAGRAPH_ALIGNMENT.CENTER

        doc.add_paragraph('\n')  # Espacio

        for sheet_name, table in tables_dict.items():
            # Añadir título de la tabla
            doc.add_heading(sheet_name, level=1)

            if table.empty:
                doc.add_paragraph("No hay datos disponibles para esta tabla.")
                continue

            # Añadir tabla al documento
            table_doc = doc.add_table(rows=1, cols=len(table.columns))
            table_doc.style = 'Light List Accent 1'

            # Añadir encabezados
            hdr_cells = table_doc.rows[0].cells
            for idx, col_name in enumerate(table.columns):
                hdr_cells[idx].text = col_name

            # Añadir filas de datos
            for _, row in table.iterrows():
                row_cells = table_doc.add_row().cells
                for idx, item in enumerate(row):
                    row_cells[idx].text = str(item)

            doc.add_paragraph('\n')  # Espacio entre tablas

        # Guardar el documento en un archivo temporal
        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
            doc.save(tmp.name)
            tmp_path = tmp.name

        return tmp_path

# --- Funciones para la Interfaz de Gradio ---

def load_data(design_type, factor_names, factor_levels, y_name, data_str):
    """
    Carga los datos del diseño experimental desde las entradas y crea la instancia de RSM_ExperimentalDesign.
    """
    try:
        # Parsear nombres de factores
        factor_names = [fn.strip() for fn in factor_names.split(',')]
        num_factors = len(factor_names)

        # Parsear niveles de factores
        factor_levels_dict = {}
        levels = factor_levels.split(';')
        if len(levels) != num_factors:
            raise ValueError(f"Se esperaban {num_factors} conjuntos de niveles separados por ';'.")
        for i, level_str in enumerate(levels):
            level_values = [float(x.strip()) for x in level_str.split(',')]
            if len(level_values) != 3:
                raise ValueError(f"El factor '{factor_names[i]}' requiere exactamente 3 niveles separados por comas.")
            factor_levels_dict[factor_names[i]] = level_values

        # Crear DataFrame a partir de la cadena de datos
        data_list = [row.split(',') for row in data_str.strip().split('\n')]
        column_names = ['Exp.'] + factor_names + [y_name]
        data = pd.DataFrame(data_list, columns=column_names)
        data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico

        # Crear la instancia de RSM_ExperimentalDesign
        global rsm
        rsm = RSM_ExperimentalDesign(
            data=data,
            design_type=design_type,
            factor_names=factor_names,
            y_name=y_name,
            factor_levels=factor_levels_dict
        )

        # Generar el diseño
        rsm.generate_design()

        return data.round(3), gr.update(visible=True), factor_names

    except Exception as e:
        # Mostrar mensaje de error
        error_message = f"Error al cargar los datos: {str(e)}"
        print(error_message)
        return None, gr.update(visible=False), []

def fit_and_optimize_model(selected_factors):
    if 'rsm' not in globals():
        return [None]*11  # Ajustar el número de outputs

    if not selected_factors:
        return [None]*11  # No se han seleccionado factores

    # Ajustar modelos y optimizar
    model_completo, pareto_completo = rsm.fit_model()
    rsm.selected_factors = selected_factors
    model_simplificado, pareto_simplificado = rsm.fit_simplified_model(selected_factors)
    optimization_table = rsm.optimize()
    equation = rsm.get_simplified_equation()
    prediction_table = rsm.generate_prediction_table()
    contribution_table = rsm.calculate_contribution_percentage()
    anova_table = rsm.calculate_detailed_anova()

    # Generar todas las figuras y almacenarlas
    rsm.generate_all_plots()

    # Formatear la ecuación para que se vea mejor en Markdown
    if equation:
        equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
        equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
    else:
        equation_formatted = "No se pudo generar la ecuación del modelo simplificado."

    # Guardar las tablas en Excel temporal
    excel_path = rsm.save_tables_to_excel()

    # Guardar todas las figuras en un ZIP temporal
    zip_path = rsm.save_figures_to_zip()

    return (
        model_completo.summary().as_html(),
        pareto_completo,
        model_simplificado.summary().as_html(),
        pareto_simplificado,
        equation_formatted,
        optimization_table,
        prediction_table,
        contribution_table,
        anova_table,
        zip_path,    # Ruta del ZIP de gráficos
        excel_path   # Ruta del Excel de tablas
    )

def download_current_plot(all_figures, current_index):
    """
    Descarga la figura actual como PNG.
    """
    if not all_figures:
        return None
    fig = all_figures[current_index]
    img_bytes = rsm.save_fig_to_bytes(fig)
    filename = f"Grafico_RSM_{current_index + 1}.png"

    return (filename, img_bytes)

def download_all_plots_zip():
    """
    Descarga todas las figuras en un archivo ZIP.
    """
    if 'rsm' not in globals():
        return None
    zip_path = rsm.save_figures_to_zip()
    if zip_path:
        with open(zip_path, 'rb') as f:
            zip_bytes = f.read()
        filename = f"Graficos_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
        return (filename, zip_bytes)
    return None

def download_all_tables_excel():
    """
    Descarga todas las tablas en un archivo Excel con múltiples hojas.
    """
    if 'rsm' not in globals():
        return None
    excel_path = rsm.save_tables_to_excel()
    if excel_path:
        with open(excel_path, 'rb') as f:
            excel_bytes = f.read()
        filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
        return (filename, excel_bytes)
    return None

def exportar_word(tables_dict):
    """
    Función para exportar las tablas a un documento de Word.
    """
    if not tables_dict:
        return None
    word_path = rsm.export_tables_to_word(tables_dict)
    if word_path and os.path.exists(word_path):
        with open(word_path, 'rb') as f:
            word_bytes = f.read()
        filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
        return (filename, word_bytes)
    return None

# --- Crear la interfaz de Gradio ---

def create_gradio_interface():
    with gr.Blocks() as demo:
        gr.Markdown("# Optimización de la Producción de AIA usando RSM")

        with gr.Row():
            with gr.Column():
                gr.Markdown("## Configuración del Diseño")
                design_type_input = gr.Dropdown(
                    label="Tipo de Diseño",
                    choices=["Box-Behnken", "Central Compuesto"],
                    value="Box-Behnken"
                )
                factor_names_input = gr.Textbox(
                    label="Nombres de los Factores (separados por comas)",
                    value="Glucosa, Extracto_de_Levadura, Triptófano"
                )
                factor_levels_input = gr.Textbox(
                    label="Niveles de los Factores (cada conjunto separado por ';' y niveles separados por comas)",
                    value="1, 3.5, 5.5; 0.03, 0.2, 0.3; 0.4, 0.65, 0.9"
                )
                y_name_input = gr.Textbox(
                    label="Nombre de la Variable Dependiente (ej. AIA_ppm)",
                    value="AIA_ppm"
                )
                data_input = gr.Textbox(
                    label="Datos del Experimento (formato CSV)",
                    lines=10,
                    value="""1,-1,-1,0,166.594
2,1,-1,0,177.557
3,-1,1,0,127.261
4,1,1,0,147.573
5,-1,0,-1,188.883
6,1,0,-1,224.527
7,-1,0,1,190.238
8,1,0,1,226.483
9,0,-1,-1,195.550
10,0,1,-1,149.493
11,0,-1,1,187.683
12,0,1,1,148.621
13,0,0,0,278.951
14,0,0,0,297.238
15,0,0,0,280.896"""
                )
                load_button = gr.Button("Cargar Datos")

            with gr.Column():
                gr.Markdown("## Datos Cargados")
                data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)

        # Sección de análisis visible solo después de cargar los datos
        with gr.Row(visible=False) as analysis_row:
            with gr.Column():
                fit_button = gr.Button("Ajustar Modelo y Optimizar")
                gr.Markdown("**Modelo Completo**")
                model_completo_output = gr.HTML()
                pareto_completo_output = gr.Plot()
                gr.Markdown("**Modelo Simplificado**")
                model_simplificado_output = gr.HTML()
                pareto_simplificado_output = gr.Plot()
                gr.Markdown("**Ecuación del Modelo Simplificado**")
                equation_output = gr.HTML()
                gr.Markdown("**Tabla de Optimización**")
                optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
                gr.Markdown("**Tabla de Predicciones**")
                prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
                gr.Markdown("**Tabla de % de Contribución**")
                contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
                gr.Markdown("**Tabla ANOVA Detallada**")
                anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
                gr.Markdown("## Descargar Todas las Tablas")
                download_excel_button = gr.DownloadButton(label="Descargar Tablas en Excel")
                download_word_button = gr.DownloadButton(label="Descargar Tablas en Word")

            with gr.Column():
                gr.Markdown("## Selección de Factores para el Modelo Simplificado")
                selected_factors_input = gr.CheckboxGroup(
                    label="Selecciona los Factores a Incluir",
                    choices=[],  # Actualizar dinámicamente
                    value=[]
                )
                fit_button_2 = gr.Button("Aplicar Selección de Factores")
                gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
                plot_button = gr.Button("Generar Gráficos")
                with gr.Row():
                    left_button = gr.Button("<")
                    right_button = gr.Button(">")
                rsm_plot_output = gr.Plot()
                plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 0", interactive=False)
                with gr.Row():
                    download_plot_button = gr.DownloadButton(label="Descargar Gráfico Actual (PNG)")
                    download_all_plots_button = gr.DownloadButton(label="Descargar Todos los Gráficos (ZIP)")
                current_index_state = gr.State(0)  # Estado para el índice actual
                all_figures_state = gr.State([])  # Estado para todas las figuras

        # Funciones de carga y ajuste
        def load_data_interface(design_type, factor_names, factor_levels, y_name, data_str):
            data, analysis_visibility, factor_names_list = load_data(design_type, factor_names, factor_levels, y_name, data_str)
            if data is not None:
                # Actualizar las opciones de selección de factores
                selected_factors = factor_names_list
                return data, analysis_visibility, selected_factors
            else:
                return data, analysis_visibility, []

        load_button.click(
            load_data_interface,
            inputs=[design_type_input, factor_names_input, factor_levels_input, y_name_input, data_input],
            outputs=[data_output, analysis_row, selected_factors_input]
        )

        # Ajustar modelo y optimizar
        fit_button.click(
            fit_and_optimize_model,
            inputs=[selected_factors_input],
            outputs=[
                model_completo_output,
                pareto_completo_output,
                model_simplificado_output,
                pareto_simplificado_output,
                equation_output,
                optimization_table_output,
                prediction_table_output,
                contribution_table_output,
                anova_table_output,
                download_all_plots_button,
                download_excel_button
            ]
        )

        # Conectar los botones de descarga de tablas
        download_excel_button.click(
            fn=download_all_tables_excel,
            inputs=[],
            outputs=download_excel_button
        )

        download_word_button.click(
            fn=exportar_word,
            inputs=[gr.State()],
            outputs=download_word_button
        )

        # Generar y mostrar los gráficos
        def generate_plots():
            if 'rsm' not in globals() or not rsm.all_figures:
                return None, "No hay gráficos disponibles.", 0, []
            # Mostrar el primer gráfico
            return rsm.all_figures[0], f"Gráfico 1 de {len(rsm.all_figures)}", 0, rsm.all_figures

        plot_button.click(
            generate_plots,
            inputs=[],
            outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
        )

        # Navegación de gráficos
        def navigate(direction, current_index, all_figures):
            if not all_figures:
                return None, "No hay gráficos disponibles.", current_index
            if direction == 'left':
                new_index = (current_index - 1) % len(all_figures)
            elif direction == 'right':
                new_index = (current_index + 1) % len(all_figures)
            else:
                new_index = current_index
            selected_fig = all_figures[new_index]
            plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
            return selected_fig, plot_info_text, new_index

        left_button.click(
            navigate,
            inputs=[gr.Button("left"), current_index_state, all_figures_state],
            outputs=[rsm_plot_output, plot_info, current_index_state]
        )

        right_button.click(
            navigate,
            inputs=[gr.Button("right"), current_index_state, all_figures_state],
            outputs=[rsm_plot_output, plot_info, current_index_state]
        )

        # Descargar gráfico actual
        download_plot_button.click(
            download_current_plot,
            inputs=[all_figures_state, current_index_state],
            outputs=download_plot_button
        )

        # Descargar todos los gráficos en ZIP
        download_all_plots_button.click(
            download_all_plots_zip,
            inputs=[],
            outputs=download_all_plots_button
        )

        # Ejemplo de uso
        gr.Markdown("## Ejemplo de uso")
        gr.Markdown("""
        1. **Configura el Diseño:**
            - Selecciona el tipo de diseño (Box-Behnken o Central Compuesto).
            - Ingresa los nombres de los factores separados por comas.
            - Ingresa los niveles para cada factor separados por comas y cada conjunto de niveles por ';'.
            - Especifica el nombre de la variable dependiente.
            - Proporciona los datos del experimento en formato CSV.
        2. **Cargar Datos:**
            - Haz clic en 'Cargar Datos' para cargar y visualizar los datos.
        3. **Seleccionar Factores para el Modelo Simplificado:**
            - Marca los factores que deseas incluir en el modelo simplificado.
        4. **Ajustar Modelo y Optimizar:**
            - Haz clic en 'Ajustar Modelo y Optimizar' para ajustar los modelos y obtener los resultados.
        5. **Generar y Navegar Gráficos:**
            - Haz clic en 'Generar Gráficos' para crear las superficies de respuesta.
            - Navega entre los gráficos usando los botones '<' y '>'.
            - Descarga el gráfico actual en PNG o todos los gráficos en un archivo ZIP.
        6. **Descargar Tablas:**
            - Descarga todas las tablas generadas en un archivo Excel o Word.
        """)

    return demo

# --- Función Principal ---

def main():
    interface = create_gradio_interface()
    interface.launch(share=True)

if __name__ == "__main__":
    main()