Update app.py

app.py

@@ -17,11 +17,13 @@ from unittest.mock import MagicMock
 from dataclasses import dataclass
 from enum import Enum
 import json
+import base64
 
 from PIL import Image
 import gradio as gr
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
+import plotly.io as pio
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -68,7 +70,11 @@ TRANSLATIONS = {
         "language": "Idioma",
         "theory": "Teoría y Modelos",
         "guide": "Guía de Uso",
-        "api_docs": "Documentación API"
+        "api_docs": "Documentación API",
+        "individual": "Individual",
+        "average": "Promedio",
+        "combined": "Combinado",
+        "config": "Configuración"
     },
     Language.EN: {
         "title": "🔬 Bioprocess Kinetics Analyzer",
@@ -91,7 +97,11 @@ TRANSLATIONS = {
         "language": "Language",
         "theory": "Theory and Models",
         "guide": "User Guide",
-        "api_docs": "API Documentation"
+        "api_docs": "API Documentation",
+        "individual": "Individual",
+        "average": "Average",
+        "combined": "Combined",
+        "config": "Configuration"
     },
 }
 
@@ -100,9 +110,6 @@ C_TIME = 'tiempo'
 C_BIOMASS = 'biomass'
 C_SUBSTRATE = 'substrate'
 C_PRODUCT = 'product'
-C_OXYGEN = 'oxygen'
-C_CO2 = 'co2'
-C_PH = 'ph'
 COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
 
 # --- SISTEMA DE TEMAS ---
@@ -541,6 +548,7 @@ class BioprocessFitter:
         self.data_time: Optional[np.ndarray] = None
         self.data_means: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
         self.data_stds: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
+        self.raw_data: Dict[str, List[np.ndarray]] = {c: [] for c in COMPONENTS}  # Para análisis individual
 
     def _get_biomass_at_t(self, t: np.ndarray, p: List[float]) -> np.ndarray: 
         return self.model.model_function(t, *p)
@@ -579,20 +587,24 @@ class BioprocessFitter:
             self.data_time = df[time_col].dropna().to_numpy()
             min_len = len(self.data_time)
             
-            def extract(name: str) -> Tuple[np.ndarray, np.ndarray]:
+            def extract(name: str) -> Tuple[np.ndarray, np.ndarray, List[np.ndarray]]:
                 cols = [c for c in df.columns if c[1].strip().lower() == name.lower()]
-                if not cols: return np.array([]), np.array([])
+                if not cols: return np.array([]), np.array([]), []
                 reps = [df[c].dropna().values[:min_len] for c in cols]
                 reps = [r for r in reps if len(r) == min_len]
-                if not reps: return np.array([]), np.array([])
+                if not reps: return np.array([]), np.array([]), []
                 arr = np.array(reps)
                 mean = np.mean(arr, axis=0)
                 std = np.std(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
-                return mean, std
+                return mean, std, reps
             
-            self.data_means[C_BIOMASS], self.data_stds[C_BIOMASS] = extract('Biomasa')
-            self.data_means[C_SUBSTRATE], self.data_stds[C_SUBSTRATE] = extract('Sustrato')
-            self.data_means[C_PRODUCT], self.data_stds[C_PRODUCT] = extract('Producto')
+            # Extraer datos con réplicas individuales
+            for comp, name in [(C_BIOMASS, 'Biomasa'), (C_SUBSTRATE, 'Sustrato'), (C_PRODUCT, 'Producto')]:
+                mean, std, reps = extract(name)
+                self.data_means[comp] = mean
+                self.data_stds[comp] = std
+                self.raw_data[comp] = reps
+                
         except (IndexError, KeyError) as e:
             raise ValueError(f"Estructura de DataFrame inválida. Error: {e}")
         
@@ -745,6 +757,90 @@ class BioprocessFitter:
             if self.params[C_PRODUCT]:
                 P = self.product(t_fine, *list(self.params[C_PRODUCT].values()), bio_p)
         return X, S, P
+    
+    def plot_individual_or_combined(self, cfg, mode):
+        """Crea gráficos individuales o combinados con Matplotlib/Seaborn"""
+        t_exp, t_fine = cfg['time_exp'], self._generate_fine_time_grid(cfg['time_exp'])
+        X_m, S_m, P_m = self.get_model_curves_for_plot(t_fine, cfg.get('use_differential', False))
+        
+        sns.set_style(cfg.get('style', 'whitegrid'))
+        
+        if mode == 'average':
+            fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15), sharex=True)
+            fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
+            axes = [ax1, ax2, ax3]
+        else:
+            fig, ax1 = plt.subplots(figsize=(12, 8))
+            fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
+            ax2 = ax1.twinx()
+            ax3 = ax1.twinx()
+            ax3.spines["right"].set_position(("axes", 1.18))
+            axes = [ax1, ax2, ax3]
+        
+        data_map = {C_BIOMASS: X_m, C_SUBSTRATE: S_m, C_PRODUCT: P_m}
+        comb_styles = {
+            C_BIOMASS: {'c': '#0072B2', 'mc': '#56B4E9', 'm': 'o', 'ls': '-'},
+            C_SUBSTRATE: {'c': '#009E73', 'mc': '#34E499', 'm': 's', 'ls': '--'},
+            C_PRODUCT: {'c': '#D55E00', 'mc': '#F0E442', 'm': '^', 'ls': '-.'}
+        }
+        
+        for ax, comp in zip(axes, COMPONENTS):
+            ylabel = cfg.get('axis_labels', {}).get(f'{comp}_label', comp.capitalize())
+            data = cfg.get(f'{comp}_exp')
+            std = cfg.get(f'{comp}_std')
+            model_data = data_map.get(comp)
+            
+            if mode == 'combined':
+                s = comb_styles[comp]
+                pc, lc, ms, ls = s['c'], s['mc'], s['m'], s['ls']
+            else:
+                pc = cfg.get(f'{comp}_point_color')
+                lc = cfg.get(f'{comp}_line_color')
+                ms = cfg.get(f'{comp}_marker_style')
+                ls = cfg.get(f'{comp}_line_style')
+            
+            ax_c = pc if mode == 'combined' else 'black'
+            ax.set_ylabel(ylabel, color=ax_c)
+            ax.tick_params(axis='y', labelcolor=ax_c)
+            
+            if data is not None and len(data) > 0:
+                if cfg.get('show_error_bars') and std is not None and np.any(std > 0):
+                    ax.errorbar(t_exp, data, yerr=std, fmt=ms, color=pc, 
+                               label=f'{comp.capitalize()} (Datos)', 
+                               capsize=cfg.get('error_cap_size', 3),
+                               elinewidth=cfg.get('error_line_width', 1))
+                else:
+                    ax.plot(t_exp, data, ls='', marker=ms, color=pc, 
+                           label=f'{comp.capitalize()} (Datos)')
+            
+            if model_data is not None and len(model_data) > 0:
+                ax.plot(t_fine, model_data, ls=ls, color=lc, 
+                       label=f'{comp.capitalize()} (Modelo)')
+            
+            if mode == 'average' and cfg.get('show_legend', True):
+                ax.legend(loc=cfg.get('legend_pos', 'best'))
+            
+            if mode == 'average' and cfg.get('show_params', True) and self.params[comp]:
+                decs = cfg.get('decimal_places', 3)
+                p_txt = '\n'.join([f"{k}={format_number(v, decs)}" for k, v in self.params[comp].items()])
+                full_txt = f"{p_txt}\nR²={format_number(self.r2.get(comp, 0), 3)}, RMSE={format_number(self.rmse.get(comp, 0), 3)}"
+                pos_x, ha = (0.95, 'right') if 'right' in cfg.get('params_pos', 'upper right') else (0.05, 'left')
+                ax.text(pos_x, 0.95, full_txt, transform=ax.transAxes, va='top', ha=ha,
+                       bbox=dict(boxstyle='round,pad=0.4', fc='wheat', alpha=0.7))
+        
+        if mode == 'combined' and cfg.get('show_legend', True):
+            h1, l1 = axes[0].get_legend_handles_labels()
+            h2, l2 = axes[1].get_legend_handles_labels()
+            h3, l3 = axes[2].get_legend_handles_labels()
+            axes[0].legend(handles=h1+h2+h3, labels=l1+l2+l3, loc=cfg.get('legend_pos', 'best'))
+        
+        axes[-1].set_xlabel(cfg.get('axis_labels', {}).get('x_label', 'Tiempo'))
+        plt.tight_layout()
+        
+        if mode == 'combined':
+            fig.subplots_adjust(right=0.8)
+        
+        return fig
 
 # --- FUNCIONES AUXILIARES ---
 
@@ -763,235 +859,456 @@ def format_number(value: Any, decimals: int) -> str:
             
     return str(round(value, decimals))
 
-# --- FUNCIONES DE PLOTEO MEJORADAS CON PLOTLY ---
+# --- FUNCIONES DE PLOTEO MEJORADAS ---
 
-def create_interactive_plot(plot_config: Dict, models_results: List[Dict], 
-                          selected_component: str = "all") -> go.Figure:
-    """Crea un gráfico interactivo mejorado con Plotly"""
+def plot_model_comparison_matplotlib(plot_config: Dict, models_results: List[Dict]) -> plt.Figure:
+    """Crea un gráfico de comparación de modelos estático usando Matplotlib/Seaborn"""
     time_exp = plot_config['time_exp']
-    time_fine = np.linspace(min(time_exp), max(time_exp), 500)
-    
-    # Configuración de subplots si se muestran todos los componentes
-    if selected_component == "all":
-        fig = make_subplots(
-            rows=3, cols=1,
-            subplot_titles=('Biomasa', 'Sustrato', 'Producto'),
-            vertical_spacing=0.08,
-            shared_xaxes=True
-        )
-        components_to_plot = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
-        rows = [1, 2, 3]
-    else:
-        fig = go.Figure()
-        components_to_plot = [selected_component]
-        rows = [None]
-    
-    # Colores para diferentes modelos
-    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', 
-              '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
-    
-    # Agregar datos experimentales
-    for comp, row in zip(components_to_plot, rows):
-        data_exp = plot_config.get(f'{comp}_exp')
-        data_std = plot_config.get(f'{comp}_std')
-        
+    time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
+    num_models = len(models_results)
+    
+    palettes = {
+        C_BIOMASS: sns.color_palette("Blues", num_models),
+        C_SUBSTRATE: sns.color_palette("Greens", num_models),
+        C_PRODUCT: sns.color_palette("Reds", num_models)
+    }
+    line_styles = ['-', '--', '-.', ':']
+
+    sns.set_style(plot_config.get('style', 'whitegrid'))
+    fig, ax1 = plt.subplots(figsize=(12, 8))
+
+    # Configuración de los 3 ejes Y
+    ax1.set_xlabel(plot_config['axis_labels']['x_label'])
+    ax1.set_ylabel(plot_config['axis_labels']['biomass_label'], color="navy", fontsize=12)
+    ax1.tick_params(axis='y', labelcolor="navy")
+    ax2 = ax1.twinx()
+    ax3 = ax1.twinx()
+    ax3.spines["right"].set_position(("axes", 1.22))
+    ax2.set_ylabel(plot_config['axis_labels']['substrate_label'], color="darkgreen", fontsize=12)
+    ax2.tick_params(axis='y', labelcolor="darkgreen")
+    ax3.set_ylabel(plot_config['axis_labels']['product_label'], color="darkred", fontsize=12)
+    ax3.tick_params(axis='y', labelcolor="darkred")
+
+    # Dibujar datos experimentales
+    data_markers = {C_BIOMASS: 'o', C_SUBSTRATE: 's', C_PRODUCT: '^'}
+    for ax, key, color, face in [(ax1, C_BIOMASS, 'navy', 'skyblue'), 
+                                  (ax2, C_SUBSTRATE, 'darkgreen', 'lightgreen'), 
+                                  (ax3, C_PRODUCT, 'darkred', 'lightcoral')]:
+        data_exp = plot_config.get(f'{key}_exp')
+        data_std = plot_config.get(f'{key}_std')
         if data_exp is not None:
-            error_y = dict(
-                type='data',
-                array=data_std,
-                visible=True
-            ) if data_std is not None and np.any(data_std > 0) else None
-            
-            trace = go.Scatter(
-                x=time_exp,
-                y=data_exp,
-                mode='markers',
-                name=f'{comp.capitalize()} (Experimental)',
-                marker=dict(size=10, symbol='circle'),
-                error_y=error_y,
-                legendgroup=comp,
-                showlegend=True
-            )
-            
-            if selected_component == "all":
-                fig.add_trace(trace, row=row, col=1)
+            if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0):
+                ax.errorbar(time_exp, data_exp, yerr=data_std, fmt=data_markers[key], 
+                           color=color, label=f'{key.capitalize()} (Datos)', zorder=10, 
+                           markersize=8, markerfacecolor=face, markeredgecolor=color, 
+                           capsize=plot_config.get('error_cap_size', 3), 
+                           elinewidth=plot_config.get('error_line_width', 1))
             else:
-                fig.add_trace(trace)
-    
-    # Agregar curvas de modelos
+                ax.plot(time_exp, data_exp, ls='', marker=data_markers[key], 
+                       label=f'{key.capitalize()} (Datos)', zorder=10, ms=8, 
+                       mfc=face, mec=color, mew=1.5)
+
+    # Dibujar curvas de los modelos
     for i, res in enumerate(models_results):
-        color = colors[i % len(colors)]
-        model_name = AVAILABLE_MODELS[res["name"]].display_name
-        
-        for comp, row, key in zip(components_to_plot, rows, ['X', 'S', 'P']):
-            if res.get(key) is not None:
-                trace = go.Scatter(
-                    x=time_fine,
-                    y=res[key],
-                    mode='lines',
-                    name=f'{model_name} - {comp.capitalize()}',
-                    line=dict(color=color, width=2),
-                    legendgroup=f'{res["name"]}_{comp}',
-                    showlegend=True
-                )
-                
-                if selected_component == "all":
-                    fig.add_trace(trace, row=row, col=1)
-                else:
-                    fig.add_trace(trace)
-    
-    # Actualizar diseño
-    theme = plot_config.get('theme', 'light')
-    template = "plotly_white" if theme == 'light' else "plotly_dark"
-    
-    fig.update_layout(
-        title=f"Análisis de Cinéticas: {plot_config.get('exp_name', '')}",
-        template=template,
-        hovermode='x unified',
-        legend=dict(
-            orientation="v",
-            yanchor="middle",
-            y=0.5,
-            xanchor="left",
-            x=1.02
-        ),
-        margin=dict(l=80, r=250, t=100, b=80)
-    )
-    
-    # Actualizar ejes
-    if selected_component == "all":
-        fig.update_xaxes(title_text="Tiempo", row=3, col=1)
-        fig.update_yaxes(title_text="Biomasa (g/L)", row=1, col=1)
-        fig.update_yaxes(title_text="Sustrato (g/L)", row=2, col=1)
-        fig.update_yaxes(title_text="Producto (g/L)", row=3, col=1)
-    else:
-        fig.update_xaxes(title_text="Tiempo")
-        labels = {
-            C_BIOMASS: "Biomasa (g/L)",
-            C_SUBSTRATE: "Sustrato (g/L)",
-            C_PRODUCT: "Producto (g/L)"
-        }
-        fig.update_yaxes(title_text=labels.get(selected_component, "Valor"))
-    
-    # Agregar botones para cambiar entre modos de visualización
+        ls = line_styles[i % len(line_styles)]
+        model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
+        model_display_name = model_info.display_name
+        for key_short, ax, name_long in [('X', ax1, C_BIOMASS), ('S', ax2, C_SUBSTRATE), ('P', ax3, C_PRODUCT)]:
+            if res.get(key_short) is not None:
+                ax.plot(time_fine, res[key_short], color=palettes[name_long][i], ls=ls, 
+                       label=f'{name_long.capitalize()} ({model_display_name})', alpha=0.9)
+
+    fig.subplots_adjust(left=0.3, right=0.78, top=0.92, 
+                        bottom=0.35 if plot_config.get('show_params') else 0.1)
+
+    if plot_config.get('show_legend'):
+        h1, l1 = ax1.get_legend_handles_labels()
+        h2, l2 = ax2.get_legend_handles_labels()
+        h3, l3 = ax3.get_legend_handles_labels()
+        fig.legend(h1 + h2 + h3, l1 + l2 + l3, loc='center left', 
+                  bbox_to_anchor=(0.0, 0.5), fancybox=True, shadow=True, fontsize='small')
+
+    if plot_config.get('show_params'):
+        total_width = 0.95
+        box_width = total_width / num_models
+        start_pos = (1.0 - total_width) / 2
+        for i, res in enumerate(models_results):
+            model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
+            text = f"**{model_info.display_name}**\n" + _generate_model_param_text(res, plot_config.get('decimal_places', 3))
+            fig.text(start_pos + i * box_width, 0.01, text, transform=fig.transFigure, 
+                    fontsize=7.5, va='bottom', ha='left', 
+                    bbox=dict(boxstyle='round,pad=0.4', fc='ivory', ec='gray', alpha=0.9))
+
+    fig.suptitle(f"Comparación de Modelos: {plot_config.get('exp_name', '')}", fontsize=16)
+    return fig
+
+def plot_model_comparison_plotly(plot_config: Dict, models_results: List[Dict]) -> go.Figure:
+    """Crea un gráfico de comparación de modelos interactivo usando Plotly"""
+    fig = go.Figure()
+    time_exp = plot_config['time_exp']
+    time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
+    num_models = len(models_results)
+    
+    palettes = {
+        C_BIOMASS: sns.color_palette("Blues", n_colors=num_models).as_hex(),
+        C_SUBSTRATE: sns.color_palette("Greens", n_colors=num_models).as_hex(),
+        C_PRODUCT: sns.color_palette("Reds", n_colors=num_models).as_hex()
+    }
+    line_styles = ['solid', 'dash', 'dot', 'dashdot']
+    data_markers = {C_BIOMASS: 'circle-open', C_SUBSTRATE: 'square-open', C_PRODUCT: 'diamond-open'}
+
+    for key, y_axis, color in [(C_BIOMASS, 'y1', 'navy'), 
+                                (C_SUBSTRATE, 'y2', 'darkgreen'), 
+                                (C_PRODUCT, 'y3', 'darkred')]:
+        data_exp = plot_config.get(f'{key}_exp')
+        data_std = plot_config.get(f'{key}_std')
+        if data_exp is not None:
+            error_y_config = dict(type='data', array=data_std, visible=True) if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0) else None
+            fig.add_trace(go.Scatter(
+                x=time_exp, y=data_exp, mode='markers', 
+                name=f'{key.capitalize()} (Datos)', 
+                marker=dict(color=color, size=10, symbol=data_markers[key], line=dict(width=2)), 
+                error_y=error_y_config, yaxis=y_axis, legendgroup="data"))
+
+    for i, res in enumerate(models_results):
+        ls = line_styles[i % len(line_styles)]
+        model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
+        if res.get('X') is not None: 
+            fig.add_trace(go.Scatter(x=time_fine, y=res['X'], mode='lines', 
+                                    name=f'Biomasa ({model_display_name})', 
+                                    line=dict(color=palettes[C_BIOMASS][i], dash=ls), 
+                                    legendgroup=res["name"]))
+        if res.get('S') is not None: 
+            fig.add_trace(go.Scatter(x=time_fine, y=res['S'], mode='lines', 
+                                    name=f'Sustrato ({model_display_name})', 
+                                    line=dict(color=palettes[C_SUBSTRATE][i], dash=ls), 
+                                    yaxis='y2', legendgroup=res["name"]))
+        if res.get('P') is not None: 
+            fig.add_trace(go.Scatter(x=time_fine, y=res['P'], mode='lines', 
+                                    name=f'Producto ({model_display_name})', 
+                                    line=dict(color=palettes[C_PRODUCT][i], dash=ls), 
+                                    yaxis='y3', legendgroup=res["name"]))
+
+    if plot_config.get('show_params'):
+        x_positions = np.linspace(0, 1, num_models * 2 + 1)[1::2]
+        for i, res in enumerate(models_results):
+            model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
+            text = f"<b>{model_display_name}</b><br>" + _generate_model_param_text(res, plot_config.get('decimal_places', 3)).replace('\n', '<br>')
+            fig.add_annotation(text=text, align='left', showarrow=False, xref='paper', 
+                             yref='paper', x=x_positions[i], y=-0.35, bordercolor='gray', 
+                             borderwidth=1, bgcolor='ivory', opacity=0.9)
+
     fig.update_layout(
-        updatemenus=[
-            dict(
-                type="dropdown",
-                showactive=True,
-                buttons=[
-                    dict(label="Todos los componentes",
-                         method="update",
-                         args=[{"visible": [True] * len(fig.data)}]),
-                    dict(label="Solo Biomasa",
-                         method="update",
-                         args=[{"visible": [i < len(fig.data)//3 for i in range(len(fig.data))]}]),
-                    dict(label="Solo Sustrato",
-                         method="update",
-                         args=[{"visible": [len(fig.data)//3 <= i < 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
-                    dict(label="Solo Producto",
-                         method="update",
-                         args=[{"visible": [i >= 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
-                ],
-                x=0.1,
-                y=1.15,
-                xanchor="left",
-                yanchor="top"
-            )
-        ]
+        title=f"Comparación de Modelos (Interactivo): {plot_config.get('exp_name', '')}",
+        xaxis=dict(domain=[0.18, 0.82]),
+        yaxis=dict(title=plot_config['axis_labels']['biomass_label'], titlefont=dict(color='navy'), 
+                   tickfont=dict(color='navy')),
+        yaxis2=dict(title=plot_config['axis_labels']['substrate_label'], titlefont=dict(color='darkgreen'), 
+                    tickfont=dict(color='darkgreen'), overlaying='y', side='right'),
+        yaxis3=dict(title=plot_config['axis_labels']['product_label'], titlefont=dict(color='darkred'), 
+                    tickfont=dict(color='darkred'), overlaying='y', side='right', position=0.85),
+        legend=dict(traceorder="grouped", yanchor="middle", y=0.5, xanchor="right", x=-0.15),
+        margin=dict(l=200, r=150, b=250 if plot_config.get('show_params') else 80, t=80),
+        template="plotly_white" if plot_config.get('theme', 'light') == 'light' else "plotly_dark",
+        showlegend=plot_config.get('show_legend', True)
     )
-    
     return fig
 
+def _generate_model_param_text(result: Dict, decimals: int) -> str:
+    """Genera el texto formateado de los parámetros para las cajas de anotación"""
+    text = ""
+    for comp in COMPONENTS:
+        if params := result.get('params', {}).get(comp):
+            p_str = ', '.join([f"{k}={format_number(v, decimals)}" for k, v in params.items()])
+            r2 = result.get('r2', {}).get(comp, 0)
+            rmse = result.get('rmse', {}).get(comp, 0)
+            text += f"{comp[:4].capitalize()}: {p_str}\n(R²={format_number(r2, 3)}, RMSE={format_number(rmse, 3)})\n"
+    return text.strip()
+
+# --- FUNCIONES DE DESCARGA Y REPORTES ---
+
+def create_zip_file(image_list: List[Any]) -> Optional[str]:
+    """Crea un archivo ZIP con todas las imágenes"""
+    if not image_list:
+        gr.Warning("No hay gráficos para descargar.")
+        return None
+    try:
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+            for i, fig in enumerate(image_list):
+                buf = io.BytesIO()
+                if isinstance(fig, go.Figure):
+                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
+                elif isinstance(fig, plt.Figure):
+                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
+                    plt.close(fig)
+                elif isinstance(fig, Image.Image):
+                    fig.save(buf, 'PNG')
+                else:
+                    continue
+                buf.seek(0)
+                zf.writestr(f"grafico_{i+1}.png", buf.read())
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp:
+            tmp.write(zip_buffer.getvalue())
+            return tmp.name
+    except Exception as e:
+        traceback.print_exc()
+        gr.Error(f"Error al crear el archivo ZIP: {e}")
+        return None
+
+def create_word_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
+    """Crea un reporte en Word con imágenes y tablas"""
+    if not image_list and (table_df is None or table_df.empty):
+        gr.Warning("No hay datos ni gráficos para crear el reporte.")
+        return None
+    try:
+        doc = Document()
+        doc.add_heading('Reporte de Análisis de Cinéticas', 0)
+        
+        # Resumen ejecutivo
+        doc.add_heading('Resumen Ejecutivo', level=1)
+        doc.add_paragraph(f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}')
+        doc.add_paragraph(f'Total de experimentos analizados: {len(table_df["Experimento"].unique()) if table_df is not None and not table_df.empty else 0}')
+        doc.add_paragraph(f'Modelos utilizados: {", ".join(table_df["Modelo"].unique()) if table_df is not None and not table_df.empty else "N/A"}')
+        
+        if table_df is not None and not table_df.empty:
+            doc.add_heading('Tabla de Resultados', level=1)
+            table = doc.add_table(rows=1, cols=len(table_df.columns), style='Table Grid')
+            for i, col in enumerate(table_df.columns):
+                table.cell(0, i).text = str(col)
+            for _, row in table_df.iterrows():
+                cells = table.add_row().cells
+                for i, val in enumerate(row):
+                    cells[i].text = str(format_number(val, decimals))
+        
+        if image_list:
+            doc.add_page_break()
+            doc.add_heading('Gráficos Generados', level=1)
+            for i, fig in enumerate(image_list):
+                buf = io.BytesIO()
+                if isinstance(fig, go.Figure):
+                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
+                elif isinstance(fig, plt.Figure):
+                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
+                    plt.close(fig)
+                elif isinstance(fig, Image.Image):
+                    fig.save(buf, 'PNG')
+                else:
+                    continue
+                buf.seek(0)
+                doc.add_paragraph(f'Gráfico {i+1}', style='Heading 3')
+                doc.add_picture(buf, width=Inches(6.0))
+                doc.add_paragraph('')  # Espacio entre imágenes
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
+            doc.save(tmp.name)
+            return tmp.name
+    except Exception as e:
+        traceback.print_exc()
+        gr.Error(f"Error al crear el reporte de Word: {e}")
+        return None
+
+def create_pdf_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
+    """Crea un reporte en PDF con imágenes y tablas"""
+    if not image_list and (table_df is None or table_df.empty):
+        gr.Warning("No hay datos ni gráficos para crear el reporte.")
+        return None
+    try:
+        pdf = FPDF()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        pdf.add_page()
+        pdf.set_font("Helvetica", 'B', 16)
+        pdf.cell(0, 10, 'Reporte de Análisis de Cinéticas', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
+        
+        # Resumen ejecutivo
+        pdf.ln(10)
+        pdf.set_font("Helvetica", '', 10)
+        pdf.cell(0, 10, f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}', 
+                new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        
+        if table_df is not None and not table_df.empty:
+            pdf.ln(10)
+            pdf.set_font("Helvetica", 'B', 12)
+            pdf.cell(0, 10, 'Tabla de Resultados', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+            pdf.set_font("Helvetica", 'B', 8)
+            
+            effective_page_width = pdf.w - 2 * pdf.l_margin
+            num_cols = len(table_df.columns)
+            col_width = effective_page_width / num_cols if num_cols > 0 else 0
+            
+            if num_cols > 15:
+                pdf.set_font_size(6)
+            elif num_cols > 10:
+                pdf.set_font_size(7)
+                
+            for col in table_df.columns:
+                pdf.cell(col_width, 10, str(col), border=1, align='C')
+            pdf.ln()
+            
+            pdf.set_font("Helvetica", '', 7)
+            if num_cols > 15:
+                pdf.set_font_size(5)
+            elif num_cols > 10:
+                pdf.set_font_size(6)
+                
+            for _, row in table_df.iterrows():
+                for val in row:
+                    pdf.cell(col_width, 10, str(format_number(val, decimals)), border=1, align='R')
+                pdf.ln()
+        
+        if image_list:
+            for i, fig in enumerate(image_list):
+                pdf.add_page()
+                pdf.set_font("Helvetica", 'B', 12)
+                pdf.cell(0, 10, f'Gráfico {i+1}', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                pdf.ln(5)
+                
+                buf = io.BytesIO()
+                if isinstance(fig, go.Figure):
+                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
+                elif isinstance(fig, plt.Figure):
+                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
+                    plt.close(fig)
+                elif isinstance(fig, Image.Image):
+                    fig.save(buf, 'PNG')
+                else:
+                    continue
+                    
+                buf.seek(0)
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
+                    tmp_img.write(buf.read())
+                    pdf.image(tmp_img.name, x=None, y=None, w=pdf.w - 20)
+                os.remove(tmp_img.name)
+        
+        pdf_bytes = pdf.output()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(pdf_bytes)
+            return tmp.name
+    except Exception as e:
+        traceback.print_exc()
+        gr.Error(f"Error al crear el reporte PDF: {e}")
+        return None
+
 # --- FUNCIÓN PRINCIPAL DE ANÁLISIS ---
-def run_analysis(file, model_names, component, use_de, maxfev, exp_names, theme='light'):
-    if not file: return None, pd.DataFrame(), "Error: Sube un archivo Excel."
-    if not model_names: return None, pd.DataFrame(), "Error: Selecciona un modelo."
+
+def run_analysis(file, model_names, mode, engine, exp_names, settings):
+    """Ejecuta el análisis completo con todos los modos"""
+    if not file:
+        return [], pd.DataFrame(), "Error: Sube un archivo Excel.", pd.DataFrame()
+    if not model_names:
+        return [], pd.DataFrame(), "Error: Selecciona un modelo.", pd.DataFrame()
     
-    try: 
+    try:
         xls = pd.ExcelFile(file.name)
-    except Exception as e: 
-        return None, pd.DataFrame(), f"Error al leer archivo: {e}"
+    except Exception as e:
+        return [], pd.DataFrame(), f"Error al leer archivo: {e}", pd.DataFrame()
     
-    results_data, msgs = [], []
-    models_results = []
+    figs = []
+    results_data = []
+    msgs = []
     
-    exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()] if exp_names else []
+    exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()]
     
     for i, sheet in enumerate(xls.sheet_names):
         exp_name = exp_list[i] if i < len(exp_list) else f"Hoja '{sheet}'"
+        
         try:
             df = pd.read_excel(xls, sheet_name=sheet, header=[0,1])
             reader = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])
             reader.process_data_from_df(df)
             
-            if reader.data_time is None: 
+            if reader.data_time is None:
                 msgs.append(f"WARN: Sin datos de tiempo en '{sheet}'.")
                 continue
+                
+            cfg = settings.copy()
+            cfg.update({'exp_name': exp_name, 'time_exp': reader.data_time})
             
-            plot_config = {
-                'exp_name': exp_name, 
-                'time_exp': reader.data_time,
-                'theme': theme
-            }
-            
-            for c in COMPONENTS: 
-                plot_config[f'{c}_exp'] = reader.data_means[c]
-                plot_config[f'{c}_std'] = reader.data_stds[c]
+            for c in COMPONENTS:
+                cfg[f'{c}_exp'] = reader.data_means[c]
+                cfg[f'{c}_std'] = reader.data_stds[c]
             
             t_fine = reader._generate_fine_time_grid(reader.data_time)
+            plot_results = []
             
             for m_name in model_names:
-                if m_name not in AVAILABLE_MODELS: 
+                if m_name not in AVAILABLE_MODELS:
                     msgs.append(f"WARN: Modelo '{m_name}' no disponible.")
                     continue
                     
-                fitter = BioprocessFitter(
-                    AVAILABLE_MODELS[m_name], 
-                    maxfev=int(maxfev),
-                    use_differential_evolution=use_de
-                )
+                fitter = BioprocessFitter(AVAILABLE_MODELS[m_name], maxfev=int(settings.get('maxfev', 50000)))
                 fitter.data_time = reader.data_time
                 fitter.data_means = reader.data_means
                 fitter.data_stds = reader.data_stds
+                fitter.raw_data = reader.raw_data
                 fitter.fit_all_models()
                 
+                # Guardar resultados numéricos
                 row = {'Experimento': exp_name, 'Modelo': fitter.model.display_name}
                 for c in COMPONENTS:
-                    if fitter.params[c]: 
+                    if fitter.params[c]:
                         row.update({f'{c.capitalize()}_{k}': v for k, v in fitter.params[c].items()})
                     row[f'R2_{c.capitalize()}'] = fitter.r2.get(c)
                     row[f'RMSE_{c.capitalize()}'] = fitter.rmse.get(c)
                     row[f'MAE_{c.capitalize()}'] = fitter.mae.get(c)
                     row[f'AIC_{c.capitalize()}'] = fitter.aic.get(c)
                     row[f'BIC_{c.capitalize()}'] = fitter.bic.get(c)
-                
                 results_data.append(row)
                 
-                X, S, P = fitter.get_model_curves_for_plot(t_fine, False)
-                models_results.append({
-                    'name': m_name, 
-                    'X': X, 
-                    'S': S, 
-                    'P': P, 
-                    'params': fitter.params, 
-                    'r2': fitter.r2, 
-                    'rmse': fitter.rmse
-                })
+                # Generar gráficos según el modo
+                if mode in ["average", "combined"]:
+                    if hasattr(fitter, 'plot_individual_or_combined'):
+                        figs.append(fitter.plot_individual_or_combined(cfg, mode))
+                elif mode == "individual":
+                    # Crear gráficos para cada réplica
+                    for rep_idx, rep_data in enumerate(fitter.raw_data[C_BIOMASS]):
+                        cfg_rep = cfg.copy()
+                        cfg_rep['exp_name'] = f"{exp_name} - Réplica {rep_idx + 1}"
+                        for c in COMPONENTS:
+                            if len(fitter.raw_data[c]) > rep_idx:
+                                cfg_rep[f'{c}_exp'] = fitter.raw_data[c][rep_idx]
+                                cfg_rep[f'{c}_std'] = None  # No hay std para réplicas individuales
+                        figs.append(fitter.plot_individual_or_combined(cfg_rep, "average"))
+                else:
+                    # Modo comparación de modelos
+                    X, S, P = fitter.get_model_curves_for_plot(t_fine, settings.get('use_differential', False))
+                    plot_results.append({
+                        'name': m_name,
+                        'X': X,
+                        'S': S,
+                        'P': P,
+                        'params': fitter.params,
+                        'r2': fitter.r2,
+                        'rmse': fitter.rmse
+                    })
+            
+            if mode == "model_comparison" and plot_results:
+                plot_func = plot_model_comparison_plotly if engine == 'Plotly (Interactivo)' else plot_model_comparison_matplotlib
+                figs.append(plot_func(cfg, plot_results))
                 
-        except Exception as e: 
+        except Exception as e:
             msgs.append(f"ERROR en '{sheet}': {e}")
             traceback.print_exc()
     
     msg = "Análisis completado." + ("\n" + "\n".join(msgs) if msgs else "")
     df_res = pd.DataFrame(results_data).dropna(axis=1, how='all')
     
-    # Crear gráfico interactivo
-    fig = None
-    if models_results and reader.data_time is not None:
-        fig = create_interactive_plot(plot_config, models_results, component)
+    if not df_res.empty:
+        # Ordenar columnas
+        id_c = ['Experimento', 'Modelo']
+        p_c = sorted([c for c in df_res.columns if '_' in c and not any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
+        m_c = sorted([c for c in df_res.columns if any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
+        df_res = df_res[[c for c in id_c + p_c + m_c if c in df_res.columns]]
+        
+        # Crear DataFrame formateado para UI
+        df_ui = df_res.copy()
+        for c in df_ui.select_dtypes(include=np.number).columns:
+            df_ui[c] = df_ui[c].apply(lambda x: format_number(x, settings.get('decimal_places', 3)) if pd.notna(x) else '')
+    else:
+        df_ui = pd.DataFrame()
     
-    return fig, df_res, msg
+    return figs, df_ui, msg, df_res
 
 # --- API ENDPOINTS PARA AGENTES DE IA ---
 
@@ -1083,16 +1400,15 @@ async def predict_kinetics(
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
-# --- INTERFAZ GRADIO MEJORADA ---
+# --- INTERFAZ GRADIO COMPLETA ---
 
 def create_gradio_interface() -> gr.Blocks:
-    """Crea la interfaz mejorada con soporte multiidioma y tema"""
+    """Crea la interfaz completa con todas las funcionalidades"""
     
     def change_language(lang_key: str) -> Dict:
         """Cambia el idioma de la interfaz"""
         lang = Language[lang_key]
         trans = TRANSLATIONS.get(lang, TRANSLATIONS[Language.ES])
-        
         return trans["title"], trans["subtitle"]
     
     # Obtener opciones de modelo
@@ -1126,196 +1442,304 @@ def create_gradio_interface() -> gr.Blocks:
                     )
         
         with gr.Tabs() as tabs:
-            # --- TAB 1: TEORÍA Y MODELOS ---
-            with gr.TabItem("📚 Teoría y Modelos"):
-                gr.Markdown("""
-                ## Introducción a los Modelos Cinéticos
-                
-                Los modelos cinéticos en biotecnología describen el comportamiento dinámico
-                de los microorganismos durante su crecimiento. Estos modelos son fundamentales
-                para:
-                
-                - **Optimización de procesos**: Determinar condiciones óptimas de operación
-                - **Escalamiento**: Predecir comportamiento a escala industrial
-                - **Control de procesos**: Diseñar estrategias de control efectivas
-                - **Análisis económico**: Evaluar viabilidad de procesos
-                """)
-                
-                # Cards para cada modelo
-                for model_name, model in AVAILABLE_MODELS.items():
-                    with gr.Accordion(f"📊 {model.display_name}", open=False):
-                        with gr.Row():
-                            with gr.Column(scale=3):
-                                gr.Markdown(f"""
-                                **Descripción**: {model.description}
-                                
-                                **Ecuación**: ${model.equation}$
-                                
-                                **Parámetros**: {', '.join(model.param_names)}
-                                
-                                **Referencia**: {model.reference}
-                                """)
-                            with gr.Column(scale=1):
-                                gr.Markdown(f"""
-                                **Características**:
-                                - Parámetros: {model.num_params}
-                                - Complejidad: {'⭐' * min(model.num_params, 5)}
-                                """)
+            # --- TAB 1: GUÍA Y FORMATO ---
+            with gr.TabItem("1. Guía y Formato de Datos"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        gr.Markdown("""
+                        ### Bienvenido al Analizador de Cinéticas
+                        Esta herramienta te permite ajustar modelos matemáticos a tus datos de crecimiento microbiano.
+                        
+                        **Pasos a seguir:**
+                        1. Prepara tu archivo Excel según el formato especificado a la derecha.
+                        2. Ve a la pestaña **"2. Configuración y Ejecución"**.
+                        3. Sube tu archivo y selecciona los modelos cinéticos que deseas probar.
+                        4. Ajusta las opciones de visualización y análisis según tus preferencias.
+                        5. Haz clic en **"Analizar y Graficar"**.
+                        6. Explora los resultados en la pestaña **"3. Resultados"**.
+
+                        ### Modos de Análisis
+                        - **Individual**: Un gráfico por cada réplica
+                        - **Promedio**: Promedio de réplicas con barras de error
+                        - **Combinado**: Todos los componentes en un solo gráfico
+                        - **Comparación**: Comparación de múltiples modelos
+                        """)
+                    with gr.Column(scale=3):
+                        gr.Markdown("### Formato del Archivo Excel")
+                        gr.Markdown("Usa una **cabecera de dos niveles** para tus datos.")
+                        df_ejemplo = pd.DataFrame({
+                            ('Rep1', 'Tiempo'): [0, 2, 4, 6],
+                            ('Rep1', 'Biomasa'): [0.1, 0.5, 2.5, 5.0],
+                            ('Rep1', 'Sustrato'): [10.0, 9.5, 7.0, 2.0],
+                            ('Rep1', 'Producto'): [0.0, 0.1, 0.5, 1.2],
+                            ('Rep2', 'Tiempo'): [0, 2, 4, 6],
+                            ('Rep2', 'Biomasa'): [0.12, 0.48, 2.6, 5.2],
+                            ('Rep2', 'Sustrato'): [10.2, 9.6, 7.1, 2.1],
+                            ('Rep2', 'Producto'): [0.0, 0.12, 0.48, 1.1],
+                        })
+                        gr.DataFrame(df_ejemplo, interactive=False, label="Ejemplo de Formato")
             
-            # --- TAB 2: ANÁLISIS ---
-            with gr.TabItem("🔬 Análisis"):
+            # --- TAB 2: CONFIGURACIÓN Y EJECUCIÓN ---
+            with gr.TabItem("2. Configuración y Ejecución"):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        file_input = gr.File(
-                            label="📁 Sube tu archivo Excel (.xlsx)",
-                            file_types=['.xlsx']
-                        )
-                        
+                        file_input = gr.File(label="Sube tu archivo Excel (.xlsx)", file_types=['.xlsx'])
                         exp_names_input = gr.Textbox(
-                            label="🏷️ Nombres de Experimentos",
-                            placeholder="Experimento 1\nExperimento 2\n...",
-                            lines=3
+                            label="Nombres de Experimentos (opcional)",
+                            placeholder="Nombre Hoja 1\nNombre Hoja 2\n...",
+                            lines=3,
+                            info="Un nombre por línea, en el mismo orden que las hojas del Excel."
                         )
-                        
                         model_selection_input = gr.CheckboxGroup(
                             choices=MODEL_CHOICES,
-                            label="📊 Modelos a Probar",
+                            label="Modelos a Probar",
                             value=DEFAULT_MODELS
                         )
-                        
-                        with gr.Accordion("⚙️ Opciones Avanzadas", open=False):
-                            use_de_input = gr.Checkbox(
-                                label="Usar Evolución Diferencial",
-                                value=False,
-                                info="Optimización global más robusta pero más lenta"
-                            )
-                            
-                            maxfev_input = gr.Number(
-                                label="Iteraciones máximas",
-                                value=50000
-                            )
+                        analysis_mode_input = gr.Radio(
+                            ["individual", "average", "combined", "model_comparison"],
+                            label="Modo de Análisis",
+                            value="average",
+                            info="Individual: por réplica. Average: promedio. Combined: 3 ejes. Comparación: todos los modelos."
+                        )
+                        plotting_engine_input = gr.Radio(
+                            ["Seaborn (Estático)", "Plotly (Interactivo)"],
+                            label="Motor Gráfico (en modo Comparación)",
+                            value="Plotly (Interactivo)"
+                        )
                     
                     with gr.Column(scale=2):
-                        # Selector de componente para visualización
-                        component_selector = gr.Dropdown(
-                            choices=[
-                                ("Todos los componentes", "all"),
-                                ("Solo Biomasa", C_BIOMASS),
-                                ("Solo Sustrato", C_SUBSTRATE),
-                                ("Solo Producto", C_PRODUCT)
-                            ],
-                            value="all",
-                            label="📈 Componente a visualizar"
-                        )
+                        with gr.Accordion("Opciones Generales de Análisis", open=True):
+                            decimal_places_input = gr.Slider(0, 10, value=3, step=1, label="Precisión Decimal")
+                            show_params_input = gr.Checkbox(label="Mostrar Parámetros en Gráfico", value=True)
+                            show_legend_input = gr.Checkbox(label="Mostrar Leyenda en Gráfico", value=True)
+                            use_differential_input = gr.Checkbox(label="Usar EDO para graficar", value=False)
+                            maxfev_input = gr.Number(label="Iteraciones Máximas de Ajuste", value=50000)
+
+                        with gr.Accordion("Etiquetas de los Ejes", open=True):
+                            with gr.Row():
+                                xlabel_input = gr.Textbox(label="Etiqueta Eje X", value="Tiempo (h)")
+                            with gr.Row():
+                                ylabel_biomass_input = gr.Textbox(label="Etiqueta Biomasa", value="Biomasa (g/L)")
+                                ylabel_substrate_input = gr.Textbox(label="Etiqueta Sustrato", value="Sustrato (g/L)")
+                                ylabel_product_input = gr.Textbox(label="Etiqueta Producto", value="Producto (g/L)")
                         
-                        plot_output = gr.Plot(label="Visualización Interactiva")
+                        with gr.Accordion("Opciones de Estilo", open=False):
+                            style_input = gr.Dropdown(
+                                ['whitegrid', 'darkgrid', 'white', 'dark', 'ticks'],
+                                label="Estilo General (Matplotlib)",
+                                value='whitegrid'
+                            )
+                            with gr.Row():
+                                with gr.Column():
+                                    gr.Markdown("**Biomasa**")
+                                    biomass_point_color_input = gr.ColorPicker(label="Color Puntos", value='#0072B2')
+                                    biomass_line_color_input = gr.ColorPicker(label="Color Línea", value='#56B4E9')
+                                    biomass_marker_style_input = gr.Dropdown(
+                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
+                                        label="Marcador",
+                                        value='o'
+                                    )
+                                    biomass_line_style_input = gr.Dropdown(
+                                        ['-', '--', '-.', ':'],
+                                        label="Estilo Línea",
+                                        value='-'
+                                    )
+                                with gr.Column():
+                                    gr.Markdown("**Sustrato**")
+                                    substrate_point_color_input = gr.ColorPicker(label="Color Puntos", value='#009E73')
+                                    substrate_line_color_input = gr.ColorPicker(label="Color Línea", value='#34E499')
+                                    substrate_marker_style_input = gr.Dropdown(
+                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
+                                        label="Marcador",
+                                        value='s'
+                                    )
+                                    substrate_line_style_input = gr.Dropdown(
+                                        ['-', '--', '-.', ':'],
+                                        label="Estilo Línea",
+                                        value='--'
+                                    )
+                                with gr.Column():
+                                    gr.Markdown("**Producto**")
+                                    product_point_color_input = gr.ColorPicker(label="Color Puntos", value='#D55E00')
+                                    product_line_color_input = gr.ColorPicker(label="Color Línea", value='#F0E442')
+                                    product_marker_style_input = gr.Dropdown(
+                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
+                                        label="Marcador",
+                                        value='^'
+                                    )
+                                    product_line_style_input = gr.Dropdown(
+                                        ['-', '--', '-.', ':'],
+                                        label="Estilo Línea",
+                                        value='-.'
+                                    )
+                            
+                            with gr.Row():
+                                legend_pos_input = gr.Radio(
+                                    ["best", "upper right", "upper left", "lower left", "lower right", "center"],
+                                    label="Posición Leyenda",
+                                    value="best"
+                                )
+                                params_pos_input = gr.Radio(
+                                    ["upper right", "upper left", "lower right", "lower left"],
+                                    label="Posición Parámetros",
+                                    value="upper right"
+                                )
                         
-                analyze_button = gr.Button("🚀 Analizar y Graficar", variant="primary")
-            
+                        with gr.Accordion("Opciones de Barra de Error", open=False):
+                            show_error_bars_input = gr.Checkbox(label="Mostrar barras de error", value=True)
+                            error_cap_size_input = gr.Slider(1, 10, 3, step=1, label="Tamaño Tapa Error")
+                            error_line_width_input = gr.Slider(0.5, 5, 1.0, step=0.5, label="Grosor Línea Error")
+
+                simulate_btn = gr.Button("Analizar y Graficar", variant="primary")
+
             # --- TAB 3: RESULTADOS ---
-            with gr.TabItem("📊 Resultados"):
-                status_output = gr.Textbox(
-                    label="Estado del Análisis",
-                    interactive=False
-                )
-                
-                results_table = gr.DataFrame(
-                    label="Tabla de Resultados",
-                    wrap=True
+            with gr.TabItem("3. Resultados"):
+                status_output = gr.Textbox(label="Estado del Análisis", interactive=False, lines=2)
+                gallery_output = gr.Gallery(
+                    label="Gráficos Generados",
+                    columns=2,
+                    height=600,
+                    object_fit="contain",
+                    preview=True
                 )
                 
-                with gr.Row():
-                    download_excel = gr.Button("📥 Descargar Excel")
-                    download_json = gr.Button("📥 Descargar JSON")
-                    api_docs_button = gr.Button("📖 Ver Documentación API")
-                
-                download_file = gr.File(label="Archivo descargado")
-            
-            # --- TAB 4: API ---
-            with gr.TabItem("🔌 API"):
-                gr.Markdown("""
-                ## Documentación de la API
-                
-                La API REST permite integrar el análisis de cinéticas en aplicaciones externas
-                y agentes de IA.
-                
-                ### Endpoints disponibles:
-                
-                #### 1. `GET /api/models`
-                Retorna la lista de modelos disponibles con su información.
+                with gr.Accordion("Descargar Reportes y Gráficos", open=True):
+                    with gr.Row():
+                        zip_btn = gr.Button("📦 Descargar Gráficos (.zip)")
+                        word_btn = gr.Button("📄 Descargar Reporte (.docx)")
+                        pdf_btn = gr.Button("📄 Descargar Reporte (.pdf)")
+                    download_output = gr.File(label="Archivo de Descarga", interactive=False)
                 
-                ```python
-                import requests
-                response = requests.get("http://localhost:8000/api/models")
-                models = response.json()
-                ```
+                gr.Markdown("### Tabla de Resultados Numéricos")
+                table_output = gr.DataFrame(wrap=True)
                 
-                #### 2. `POST /api/analyze`
-                Analiza datos con los modelos especificados.
+                with gr.Row():
+                    excel_btn = gr.Button("📊 Descargar Tabla (.xlsx)")
+                    csv_btn = gr.Button("📊 Descargar Tabla (.csv)")
+                download_table_output = gr.File(label="Descargar Tabla", interactive=False)
                 
-                ```python
-                data = {
-                    "data": {
-                        "time": [0, 1, 2, 3, 4],
-                        "biomass": [0.1, 0.3, 0.8, 1.5, 2.0],
-                        "substrate": [10, 8, 5, 2, 0.5]
+                # Estados para almacenar datos
+                df_for_export = gr.State(pd.DataFrame())
+                figures_for_export = gr.State([])
+        
+        # --- EVENTOS ---
+        
+        def simulation_wrapper(file, models, mode, engine, names, use_diff, s_par, s_leg, maxfev, 
+                             decimals, x_label, bio_label, sub_label, prod_label, style, s_err, 
+                             cap, lw, l_pos, p_pos, bio_pc, bio_lc, bio_ms, bio_ls, sub_pc, 
+                             sub_lc, sub_ms, sub_ls, prod_pc, prod_lc, prod_ms, prod_ls):
+            try:
+                def rgba_to_hex(rgba_string: str) -> str:
+                    if not isinstance(rgba_string, str) or rgba_string.startswith('#'):
+                        return rgba_string
+                    try:
+                        parts = rgba_string.lower().replace('rgba', '').replace('rgb', '').replace('(', '').replace(')', '')
+                        r, g, b, *_ = map(float, parts.split(','))
+                        return f'#{int(r):02x}{int(g):02x}{int(b):02x}'
+                    except (ValueError, TypeError):
+                        return "#000000"
+
+                plot_settings = {
+                    'decimal_places': int(decimals),
+                    'use_differential': use_diff,
+                    'style': style,
+                    'show_legend': s_leg,
+                    'show_params': s_par,
+                    'maxfev': int(maxfev),
+                    'axis_labels': {
+                        'x_label': x_label,
+                        'biomass_label': bio_label,
+                        'substrate_label': sub_label,
+                        'product_label': prod_label
                     },
-                    "models": ["logistic", "gompertz"],
-                    "options": {"maxfev": 50000}
+                    'legend_pos': l_pos,
+                    'params_pos': p_pos,
+                    'show_error_bars': s_err,
+                    'error_cap_size': cap,
+                    'error_line_width': lw,
+                    f'{C_BIOMASS}_point_color': rgba_to_hex(bio_pc),
+                    f'{C_BIOMASS}_line_color': rgba_to_hex(bio_lc),
+                    f'{C_BIOMASS}_marker_style': bio_ms,
+                    f'{C_BIOMASS}_line_style': bio_ls,
+                    f'{C_SUBSTRATE}_point_color': rgba_to_hex(sub_pc),
+                    f'{C_SUBSTRATE}_line_color': rgba_to_hex(sub_lc),
+                    f'{C_SUBSTRATE}_marker_style': sub_ms,
+                    f'{C_SUBSTRATE}_line_style': sub_ls,
+                    f'{C_PRODUCT}_point_color': rgba_to_hex(prod_pc),
+                    f'{C_PRODUCT}_line_color': rgba_to_hex(prod_lc),
+                    f'{C_PRODUCT}_marker_style': prod_ms,
+                    f'{C_PRODUCT}_line_style': prod_ls,
                 }
-                response = requests.post("http://localhost:8000/api/analyze", json=data)
-                results = response.json()
-                ```
                 
-                #### 3. `POST /api/predict`
-                Predice valores usando un modelo y parámetros específicos.
+                figures, df_ui, msg, df_export = run_analysis(file, models, mode, engine, names, plot_settings)
                 
-                ```python
-                data = {
-                    "model_name": "logistic",
-                    "parameters": {"X0": 0.1, "Xm": 10.0, "μm": 0.5},
-                    "time_points": [0, 1, 2, 3, 4, 5]
-                }
-                response = requests.post("http://localhost:8000/api/predict", json=data)
-                predictions = response.json()
-                ```
+                # Convertir figuras a imágenes para galería
+                image_list = []
+                for fig in figures:
+                    buf = io.BytesIO()
+                    if isinstance(fig, go.Figure):
+                        buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
+                    elif isinstance(fig, plt.Figure):
+                        fig.savefig(buf, format='png', bbox_inches='tight', dpi=150)
+                        plt.close(fig)
+                    buf.seek(0)
+                    image_list.append(Image.open(buf).convert("RGB"))
                 
-                ### Iniciar servidor API:
-                ```bash
-                uvicorn script_name:app --reload --port 8000
-                ```
-                """)
+                return image_list, df_ui, msg, df_export, figures
                 
-                # Botón para copiar comando
-                gr.Textbox(
-                    value="uvicorn bioprocess_analyzer:app --reload --port 8000",
-                    label="Comando para iniciar API",
-                    interactive=False
-                )
+            except Exception as e:
+                print(f"--- ERROR CAPTURADO EN WRAPPER ---\n{traceback.format_exc()}")
+                return [], pd.DataFrame(), f"Error Crítico: {e}", pd.DataFrame(), []
+
+        all_inputs = [
+            file_input, model_selection_input, analysis_mode_input, plotting_engine_input, exp_names_input,
+            use_differential_input, show_params_input, show_legend_input, maxfev_input, decimal_places_input,
+            xlabel_input, ylabel_biomass_input, ylabel_substrate_input, ylabel_product_input,
+            style_input, show_error_bars_input, error_cap_size_input, error_line_width_input,
+            legend_pos_input, params_pos_input,
+            biomass_point_color_input, biomass_line_color_input, biomass_marker_style_input, biomass_line_style_input,
+            substrate_point_color_input, substrate_line_color_input, substrate_marker_style_input, substrate_line_style_input,
+            product_point_color_input, product_line_color_input, product_marker_style_input, product_line_style_input
+        ]
         
-        # --- EVENTOS ---
+        all_outputs = [gallery_output, table_output, status_output, df_for_export, figures_for_export]
         
-        def run_analysis_wrapper(file, models, component, use_de, maxfev, exp_names, theme):
-            """Wrapper para ejecutar el análisis"""
-            try:
-                return run_analysis(file, models, component, use_de, maxfev, exp_names, 
-                                  'dark' if theme else 'light')
-            except Exception as e:
-                print(f"--- ERROR EN ANÁLISIS ---\n{traceback.format_exc()}")
-                return None, pd.DataFrame(), f"Error: {str(e)}"
+        simulate_btn.click(fn=simulation_wrapper, inputs=all_inputs, outputs=all_outputs)
         
-        analyze_button.click(
-            fn=run_analysis_wrapper,
-            inputs=[
-                file_input,
-                model_selection_input,
-                component_selector,
-                use_de_input,
-                maxfev_input,
-                exp_names_input,
-                theme_toggle
-            ],
-            outputs=[plot_output, results_table, status_output]
+        # Funciones de descarga
+        zip_btn.click(fn=create_zip_file, inputs=[figures_for_export], outputs=[download_output])
+        word_btn.click(
+            fn=create_word_report,
+            inputs=[figures_for_export, df_for_export, decimal_places_input],
+            outputs=[download_output]
+        )
+        pdf_btn.click(
+            fn=create_pdf_report,
+            inputs=[figures_for_export, df_for_export, decimal_places_input],
+            outputs=[download_output]
+        )
+        
+        def export_table_to_file(df: pd.DataFrame, file_format: str) -> Optional[str]:
+            if df is None or df.empty:
+                gr.Warning("No hay datos para exportar.")
+                return None
+            suffix = ".xlsx" if file_format == "excel" else ".csv"
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                if file_format == "excel":
+                    df.to_excel(tmp.name, index=False)
+                else:
+                    df.to_csv(tmp.name, index=False, encoding='utf-8-sig')
+                return tmp.name
+        
+        excel_btn.click(
+            fn=lambda df: export_table_to_file(df, "excel"),
+            inputs=[df_for_export],
+            outputs=[download_table_output]
+        )
+        csv_btn.click(
+            fn=lambda df: export_table_to_file(df, "csv"),
+            inputs=[df_for_export],
+            outputs=[download_table_output]
         )
         
         # Cambio de idioma
@@ -1327,46 +1751,17 @@ def create_gradio_interface() -> gr.Blocks:
         
         # Cambio de tema
         def apply_theme(is_dark):
-            return gr.Info("Tema cambiado. Los gráficos nuevos usarán el tema seleccionado.")
+            return gr.Info("Tema cambiado. Los nuevos gráficos usarán el tema seleccionado.")
         
         theme_toggle.change(
             fn=apply_theme,
             inputs=[theme_toggle],
             outputs=[]
         )
-        
-        # Funciones de descarga
-        def download_results_excel(df):
-            if df is None or df.empty:
-                gr.Warning("No hay datos para descargar")
-                return None
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
-                df.to_excel(tmp.name, index=False)
-                return tmp.name
-        
-        def download_results_json(df):
-            if df is None or df.empty:
-                gr.Warning("No hay datos para descargar")
-                return None
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tmp:
-                df.to_json(tmp.name, orient='records', indent=2)
-                return tmp.name
-        
-        download_excel.click(
-            fn=download_results_excel,
-            inputs=[results_table],
-            outputs=[download_file]
-        )
-        
-        download_json.click(
-            fn=download_results_json,
-            inputs=[results_table],
-            outputs=[download_file]
-        )
     
     return demo
 
-# --- PUNTO DE ENTRADA ---
+# --- PUNTO DE ENTRADA PRINCIPAL ---
 
 if __name__ == '__main__':
     # Lanzar aplicación Gradio