app.py

import os

os.system("pip install --upgrade gradio")

from pydantic import BaseModel, ConfigDict
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.integrate import odeint
from scipy.optimize import curve_fit
from sklearn.metrics import mean_squared_error
import gradio as gr
import io
from PIL import Image
import tempfile

class YourModel(BaseModel):
    class Config:
        arbitrary_types_allowed = True

class BioprocessModel:
    def __init__(self, model_type='logistic', maxfev=50000):
        self.params = {}
        self.r2 = {}
        self.rmse = {}
        self.datax = []
        self.datas = []
        self.datap = []
        self.dataxp = []
        self.datasp = []
        self.datapp = []
        self.datax_std = []
        self.datas_std = []
        self.datap_std = []
        self.biomass_model = None
        self.biomass_diff = None # Store the differential equation function
        self.model_type = model_type
        self.maxfev = maxfev
        self.time = None

    @staticmethod
    def logistic(time, xo, xm, um):
        # xo: initial biomass, xm: max biomass, um: max specific growth rate
        if xm == 0 or (xo / xm == 1 and np.any(um * time > 0)):
            return np.full_like(time, np.nan)
        # Add a small epsilon to prevent division by zero or log of zero in edge cases
        term_exp = np.exp(um * time)
        denominator = (1 - (xo / xm) * (1 - term_exp))
        denominator = np.where(denominator == 0, 1e-9, denominator) # Avoid division by zero
        # Ensure xo/xm is not 1 if (1-exp(um*time)) is also 0 (i.e. um*time = 0)
        # This is usually handled by xo < xm constraint in fitting
        return (xo * term_exp) / denominator

    @staticmethod
    def gompertz(time, xm, um, lag):
        # xm: max biomass, um: max specific growth rate, lag: lag time
        if xm == 0:
            return np.full_like(time, np.nan)
        # Add small epsilon to prevent log(0) if exp_term becomes very large negative
        exp_term = (um * np.e / xm) * (lag - time) + 1
        # Clamp large negative values in exp_term to avoid overflow in np.exp(-np.exp(exp_term))
        exp_term_clipped = np.clip(exp_term, -np.inf, 700) # exp(709) is around max float
        return xm * np.exp(-np.exp(exp_term_clipped))

    @staticmethod
    def moser(time, Xm, um, Ks):
        # Xm: max biomass, um: max specific growth rate, Ks: Monod constant (here acting as time shift)
        # This is a simplified form, not the substrate-dependent Moser.
        return Xm * (1 - np.exp(-um * (time - Ks)))

    @staticmethod
    def baranyi(time, X0, Xm, um, lag):
        # X0: initial biomass, Xm: max biomass, um: max specific growth rate, lag: lag time
        # Ensure parameters are valid to prevent math errors
        if X0 <= 0 or Xm <= X0 or um <= 0: # lag can be 0
            return np.full_like(time, np.nan)

        # Adjustment function A(t)
        # Using h0 = um for simplicity in A(t) calculation
        # A_t = t + (1/um) * np.log(np.exp(-um*t) + np.exp(-um*lag) - np.exp(-um*(t+lag)))
        # Argument of log in A(t):
        log_arg_A = np.exp(-um * t) + np.exp(-um * lag) - np.exp(-um * (t + lag))
        log_arg_A = np.where(log_arg_A <= 1e-9, 1e-9, log_arg_A) # Prevent log(0 or negative)
        A_t = t + (1 / um) * np.log(log_arg_A)
        
        # Main Baranyi equation part
        exp_um_At = np.exp(um * A_t)
        # Clamp large values to prevent overflow if Xm/X0 is large
        exp_um_At_clipped = np.clip(exp_um_At, -np.inf, 700)

        numerator = (Xm / X0) * exp_um_At_clipped
        denominator = (Xm / X0 - 1) + exp_um_At_clipped
        denominator = np.where(denominator == 0, 1e-9, denominator) # Avoid division by zero

        return X0 * (numerator / denominator)


    @staticmethod
    def logistic_diff(X, t, params):
        # params for logistic_diff: [xo, xm, um] (xo is not used in diff eq, but passed for consistency)
        _, xm, um = params
        if xm == 0: return 0
        return um * X * (1 - X / xm)

    @staticmethod
    def gompertz_diff(X, t, params):
        # params for gompertz_diff: [xm, um, lag]
        xm, um, lag = params
        if xm == 0: return 0
        # This is d(Gompertz)/dt
        # Gompertz: xm * exp(-exp( (um*e/xm)*(lag-t)+1 ))
        # Let k = (um*e/xm)
        # Let u = (k*(lag-t)+1)
        # dX/dt = X * (-exp(u)) * k * (-1) = X * k * exp(u)
        k_val = um * np.e / xm
        u_val = k_val * (lag - t) + 1
        u_val_clipped = np.clip(u_val, -np.inf, 700)
        return X * k_val * np.exp(u_val_clipped)


    @staticmethod
    def moser_diff(X, t, params):
        # params for moser_diff: [Xm, um, Ks]
        Xm, um, _ = params # Ks is not directly in this simplified dX/dt
        return um * (Xm - X)
    
    # No differential form for Baranyi in this version due to complexity.

    def substrate(self, time, so, p, q, biomass_params_list):
        if self.biomass_model is None or not biomass_params_list:
            return np.full_like(time, np.nan)
        X_t = self.biomass_model(time, *biomass_params_list)
        if np.any(np.isnan(X_t)):
             return np.full_like(time, np.nan)
        
        integral_X = np.zeros_like(X_t)
        if len(time) > 1:
            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1))
            integral_X = np.cumsum(X_t * dt)

        # Determine X0 (initial biomass) from the fitted parameters
        if self.model_type == 'logistic' or self.model_type == 'baranyi':
            X0 = biomass_params_list[0] # xo or X0 is the first parameter
        elif self.model_type == 'gompertz':
            X0 = self.gompertz(0, *biomass_params_list)
        elif self.model_type == 'moser':
            X0 = self.moser(0, *biomass_params_list)
        else:
            X0 = X_t[0] # Fallback
        
        X0 = X0 if not np.isnan(X0) else (biomass_params_list[0] if biomass_params_list else 0)


        return so - p * (X_t - X0) - q * integral_X

    def product(self, time, po, alpha, beta, biomass_params_list):
        if self.biomass_model is None or not biomass_params_list:
            return np.full_like(time, np.nan)
        X_t = self.biomass_model(time, *biomass_params_list)
        if np.any(np.isnan(X_t)):
             return np.full_like(time, np.nan)

        integral_X = np.zeros_like(X_t)
        if len(time) > 1:
            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1))
            integral_X = np.cumsum(X_t * dt)

        if self.model_type == 'logistic' or self.model_type == 'baranyi':
            X0 = biomass_params_list[0]
        elif self.model_type == 'gompertz':
            X0 = self.gompertz(0, *biomass_params_list)
        elif self.model_type == 'moser':
            X0 = self.moser(0, *biomass_params_list)
        else:
            X0 = X_t[0]
            
        X0 = X0 if not np.isnan(X0) else (biomass_params_list[0] if biomass_params_list else 0)

        return po + alpha * (X_t - X0) + beta * integral_X

    def process_data(self, df):
        # ... (same as before)
        biomass_cols = [col for col in df.columns if col[1] == 'Biomasa']
        substrate_cols = [col for col in df.columns if col[1] == 'Sustrato']
        product_cols = [col for col in df.columns if col[1] == 'Producto']

        if not any(col[1] == 'Tiempo' for col in df.columns):
            raise ValueError("La columna 'Tiempo' no se encuentra en el DataFrame.")
        time_col = [col for col in df.columns if col[1] == 'Tiempo'][0]
        time = df[time_col].dropna().values # Ensure no NaNs in time

        if len(biomass_cols) > 0:
            data_biomass = [df[col].dropna().values for col in biomass_cols] # dropna for each replicate
            # Ensure all replicates have same length as time after dropna
            min_len = len(time)
            data_biomass_aligned = []
            for rep_data in data_biomass:
                if len(rep_data) == min_len:
                    data_biomass_aligned.append(rep_data)
                # else: print warning or handle misaligned data
            
            if data_biomass_aligned:
                data_biomass_np = np.array(data_biomass_aligned)
                self.datax.append(data_biomass_np)
                self.dataxp.append(np.mean(data_biomass_np, axis=0))
                self.datax_std.append(np.std(data_biomass_np, axis=0, ddof=1))
            else: # If no valid replicates after alignment
                self.datax.append(np.array([]))
                self.dataxp.append(np.array([]))
                self.datax_std.append(np.array([]))

        else: 
            self.datax.append(np.array([]))
            self.dataxp.append(np.array([]))
            self.datax_std.append(np.array([]))


        if len(substrate_cols) > 0:
            data_substrate = [df[col].dropna().values for col in substrate_cols]
            min_len = len(time)
            data_substrate_aligned = []
            for rep_data in data_substrate:
                if len(rep_data) == min_len:
                    data_substrate_aligned.append(rep_data)
            
            if data_substrate_aligned:
                data_substrate_np = np.array(data_substrate_aligned)
                self.datas.append(data_substrate_np)
                self.datasp.append(np.mean(data_substrate_np, axis=0))
                self.datas_std.append(np.std(data_substrate_np, axis=0, ddof=1))
            else:
                self.datas.append(np.array([]))
                self.datasp.append(np.array([]))
                self.datas_std.append(np.array([]))
        else:
            self.datas.append(np.array([]))
            self.datasp.append(np.array([]))
            self.datas_std.append(np.array([]))

        if len(product_cols) > 0:
            data_product = [df[col].dropna().values for col in product_cols]
            min_len = len(time)
            data_product_aligned = []
            for rep_data in data_product:
                if len(rep_data) == min_len:
                    data_product_aligned.append(rep_data)

            if data_product_aligned:
                data_product_np = np.array(data_product_aligned)
                self.datap.append(data_product_np)
                self.datapp.append(np.mean(data_product_np, axis=0))
                self.datap_std.append(np.std(data_product_np, axis=0, ddof=1))
            else:
                self.datap.append(np.array([]))
                self.datapp.append(np.array([]))
                self.datap_std.append(np.array([]))
        else:
            self.datap.append(np.array([]))
            self.datapp.append(np.array([]))
            self.datap_std.append(np.array([]))

        self.time = time


    def fit_model(self):
        if self.model_type == 'logistic':
            self.biomass_model = self.logistic
            self.biomass_diff = self.logistic_diff
        elif self.model_type == 'gompertz':
            self.biomass_model = self.gompertz
            self.biomass_diff = self.gompertz_diff
        elif self.model_type == 'moser':
            self.biomass_model = self.moser
            self.biomass_diff = self.moser_diff
        elif self.model_type == 'baranyi':
            self.biomass_model = self.baranyi
            self.biomass_diff = None # No ODE form for Baranyi in this version
        else:
            raise ValueError(f"Modelo de biomasa desconocido: {self.model_type}")


    def fit_biomass(self, time, biomass):
        # Ensure time and biomass are 1D arrays of the same length and numeric
        time = np.asarray(time, dtype=float)
        biomass = np.asarray(biomass, dtype=float)
        if len(time) != len(biomass):
            print("Error: Tiempo y biomasa deben tener la misma longitud.")
            return None
        if np.any(np.isnan(time)) or np.any(np.isnan(biomass)):
            print("Error: Tiempo o biomasa contienen NaNs.")
            # Attempt to remove NaNs consistently
            valid_indices = ~np.isnan(time) & ~np.isnan(biomass)
            time = time[valid_indices]
            biomass = biomass[valid_indices]
            if len(time) < 3: # Need at least 3 points for 3-param models
                print("No hay suficientes datos válidos después de remover NaNs.")
                return None
        
        try:
            if len(np.unique(biomass)) < 2 :
                print(f"Biomasa constante para {self.model_type}, no se puede ajustar el modelo.")
                self.r2['biomass'] = np.nan; self.rmse['biomass'] = np.nan
                return None

            popt = None # Initialize popt
            if self.model_type == 'logistic':
                xo_guess = biomass[0] if biomass[0] > 1e-6 else 1e-3
                xm_guess = max(biomass) * 1.1 if max(biomass) > xo_guess else xo_guess * 2
                if xm_guess <= xo_guess: xm_guess = xo_guess + 1e-3
                p0 = [xo_guess, xm_guess, 0.1]
                bounds = ([1e-9, biomass[0] if biomass[0]>1e-9 else 1e-9, 1e-9], [max(biomass)*0.99 if max(biomass)>0 else 1, np.inf, np.inf])
                # Ensure xo_guess is within bounds[0][0] and bounds[1][0]
                p0[0] = np.clip(p0[0], bounds[0][0], bounds[1][0])
                popt, _ = curve_fit(self.logistic, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                if popt[1] <= popt[0]: # xm <= xo
                     print(f"Advertencia: En modelo logístico, Xm ({popt[1]:.2f}) no es mayor que Xo ({popt[0]:.2f}). Ajuste puede no ser válido.")
                self.params['biomass'] = {'Xo': popt[0], 'Xm': popt[1], 'um': popt[2]}
                y_pred = self.logistic(time, *popt)

            elif self.model_type == 'gompertz':
                xm_guess = max(biomass) if max(biomass) > 0 else 1.0
                um_guess = 0.1
                # A simple lag estimate: time until biomass reaches, say, 10% of (max-min)
                min_bio = min(biomass)
                lag_thresh = min_bio + 0.1 * (max(biomass) - min_bio)
                lag_indices = np.where(biomass > lag_thresh)[0]
                lag_guess = time[lag_indices[0]] if len(lag_indices) > 0 else time[0]

                p0 = [xm_guess, um_guess, lag_guess]
                bounds = ([min(biomass) if min(biomass)>1e-9 else 1e-9, 1e-9, 0], 
                          [np.inf, np.inf, max(time) if len(time)>0 else 100])
                popt, _ = curve_fit(self.gompertz, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'lag': popt[2]}
                y_pred = self.gompertz(time, *popt)

            elif self.model_type == 'moser':
                Xm_guess = max(biomass) if max(biomass) > 0 else 1.0
                um_guess = 0.1
                Ks_guess = time[0]
                p0 = [Xm_guess, um_guess, Ks_guess]
                bounds = ([min(biomass) if min(biomass)>1e-9 else 1e-9, 1e-9, -max(time) if len(time)>0 else -100], # Ks can be negative
                          [np.inf, np.inf, max(time) if len(time)>0 else 100])
                popt, _ = curve_fit(self.moser, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'Ks': popt[2]}
                y_pred = self.moser(time, *popt)
            
            elif self.model_type == 'baranyi':
                X0_guess = biomass[0] if biomass[0] > 1e-6 else 1e-3
                Xm_guess = max(biomass) if max(biomass) > X0_guess else X0_guess * 2
                if Xm_guess <= X0_guess: Xm_guess = X0_guess + 1e-3 # Ensure Xm > X0
                um_guess = 0.1
                min_bio = X0_guess
                lag_thresh = min_bio + 0.1 * (Xm_guess - min_bio)
                lag_indices = np.where(biomass > lag_thresh)[0]
                lag_guess = time[lag_indices[0]] if len(lag_indices) > 0 and time[lag_indices[0]] > 0 else (time[0] if time[0] > 1e-9 else 1e-9) # lag must be >0 for some A(t) forms
                if lag_guess <= 0: lag_guess = 1e-9 # Ensure lag is positive for Baranyi A(t) log

                p0 = [X0_guess, Xm_guess, um_guess, lag_guess]
                bounds = (
                    [1e-9, biomass[0] if biomass[0]>1e-9 else 1e-9, 1e-9, 1e-9], # X0, Xm, um, lag > 0
                    [max(biomass)*0.99 if max(biomass)>0 else 1, np.inf, np.inf, max(time) if len(time)>0 else 100]
                )
                p0[0] = np.clip(p0[0], bounds[0][0], bounds[1][0]) # Clip X0_guess
                p0[3] = np.clip(p0[3], bounds[0][3], bounds[1][3]) # Clip lag_guess

                popt, _ = curve_fit(self.baranyi, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                if popt[1] <= popt[0]: # Xm <= X0
                     print(f"Advertencia: En modelo Baranyi, Xm ({popt[1]:.2f}) no es mayor que X0 ({popt[0]:.2f}). Ajuste puede no ser válido.")
                self.params['biomass'] = {'X0': popt[0], 'Xm': popt[1], 'um': popt[2], 'lag': popt[3]}
                y_pred = self.baranyi(time, *popt)

            else:
                print(f"Modelo {self.model_type} no implementado para ajuste de biomasa.")
                return None

            if np.any(np.isnan(y_pred)) or np.any(np.isinf(y_pred)):
                print(f"Predicción de biomasa contiene NaN/Inf para {self.model_type}. Ajuste fallido.")
                self.r2['biomass'] = np.nan; self.rmse['biomass'] = np.nan
                return None

            ss_res = np.sum((biomass - y_pred) ** 2)
            ss_tot = np.sum((biomass - np.mean(biomass)) ** 2)
            if ss_tot == 0:
                self.r2['biomass'] = 1.0 if ss_res < 1e-9 else 0.0 # Perfect fit if residuals are also ~0
            else:
                self.r2['biomass'] = 1 - (ss_res / ss_tot)
            self.rmse['biomass'] = np.sqrt(mean_squared_error(biomass, y_pred))
            return y_pred

        except RuntimeError as e:
            print(f"Error de Runtime en fit_biomass_{self.model_type} (probablemente no se pudo ajustar): {e}")
            self.params['biomass'] = {}
            self.r2['biomass'] = np.nan; self.rmse['biomass'] = np.nan
            return None
        except Exception as e:
            print(f"Error general en fit_biomass_{self.model_type}: {e}")
            self.params['biomass'] = {}
            self.r2['biomass'] = np.nan; self.rmse['biomass'] = np.nan
            return None

    def fit_substrate(self, time, substrate, biomass_params_dict):
        if not biomass_params_dict:
            print(f"Error en fit_substrate_{self.model_type}: Parámetros de biomasa no disponibles.")
            return None
        try:
            # Extract parameters based on model type into a list for self.substrate
            if self.model_type == 'logistic':
                # Expected by self.logistic: xo, xm, um
                biomass_params_values = [biomass_params_dict['Xo'], biomass_params_dict['Xm'], biomass_params_dict['um']]
            elif self.model_type == 'gompertz':
                # Expected by self.gompertz: xm, um, lag
                biomass_params_values = [biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['lag']]
            elif self.model_type == 'moser':
                # Expected by self.moser: Xm, um, Ks
                biomass_params_values = [biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['Ks']]
            elif self.model_type == 'baranyi':
                # Expected by self.baranyi: X0, Xm, um, lag
                biomass_params_values = [biomass_params_dict['X0'], biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['lag']]
            else:
                return None

            so_guess = substrate[0] if len(substrate) > 0 else 1.0
            p_guess = 0.1 
            q_guess = 0.01
            p0 = [so_guess, p_guess, q_guess]
            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf])

            popt, _ = curve_fit(
                lambda t, so, p, q: self.substrate(t, so, p, q, biomass_params_values),
                time, substrate, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9
            )
            self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
            y_pred = self.substrate(time, *popt, biomass_params_values)

            if np.any(np.isnan(y_pred)) or np.any(np.isinf(y_pred)):
                print(f"Predicción de sustrato contiene NaN/Inf para {self.model_type}. Ajuste fallido.")
                self.r2['substrate'] = np.nan; self.rmse['substrate'] = np.nan
                return None

            ss_res = np.sum((substrate - y_pred) ** 2)
            ss_tot = np.sum((substrate - np.mean(substrate)) ** 2)
            if ss_tot == 0: self.r2['substrate'] = 1.0 if ss_res < 1e-9 else 0.0
            else: self.r2['substrate'] = 1 - (ss_res / ss_tot)
            self.rmse['substrate'] = np.sqrt(mean_squared_error(substrate, y_pred))
            return y_pred
        except RuntimeError as e:
            print(f"Error de Runtime en fit_substrate_{self.model_type}: {e}")
            self.params['substrate'] = {}; self.r2['substrate'] = np.nan; self.rmse['substrate'] = np.nan
            return None
        except Exception as e:
            print(f"Error general en fit_substrate_{self.model_type}: {e}")
            self.params['substrate'] = {}; self.r2['substrate'] = np.nan; self.rmse['substrate'] = np.nan
            return None

    def fit_product(self, time, product, biomass_params_dict):
        if not biomass_params_dict:
            print(f"Error en fit_product_{self.model_type}: Parámetros de biomasa no disponibles.")
            return None
        try:
            if self.model_type == 'logistic':
                biomass_params_values = [biomass_params_dict['Xo'], biomass_params_dict['Xm'], biomass_params_dict['um']]
            elif self.model_type == 'gompertz':
                biomass_params_values = [biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['lag']]
            elif self.model_type == 'moser':
                biomass_params_values = [biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['Ks']]
            elif self.model_type == 'baranyi':
                biomass_params_values = [biomass_params_dict['X0'], biomass_params_dict['Xm'], biomass_params_dict['um'], biomass_params_dict['lag']]
            else:
                return None

            po_guess = product[0] if len(product) > 0 else 0.0
            alpha_guess = 0.1 
            beta_guess = 0.01
            p0 = [po_guess, alpha_guess, beta_guess]
            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf])

            popt, _ = curve_fit(
                lambda t, po, alpha, beta: self.product(t, po, alpha, beta, biomass_params_values),
                time, product, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9
            )
            self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
            y_pred = self.product(time, *popt, biomass_params_values)

            if np.any(np.isnan(y_pred)) or np.any(np.isinf(y_pred)):
                print(f"Predicción de producto contiene NaN/Inf para {self.model_type}. Ajuste fallido.")
                self.r2['product'] = np.nan; self.rmse['product'] = np.nan
                return None

            ss_res = np.sum((product - y_pred) ** 2)
            ss_tot = np.sum((product - np.mean(product)) ** 2)
            if ss_tot == 0: self.r2['product'] = 1.0 if ss_res < 1e-9 else 0.0
            else: self.r2['product'] = 1 - (ss_res / ss_tot)
            self.rmse['product'] = np.sqrt(mean_squared_error(product, y_pred))
            return y_pred
        except RuntimeError as e:
            print(f"Error de Runtime en fit_product_{self.model_type}: {e}")
            self.params['product'] = {}; self.r2['product'] = np.nan; self.rmse['product'] = np.nan
            return None
        except Exception as e:
            print(f"Error general en fit_product_{self.model_type}: {e}")
            self.params['product'] = {}; self.r2['product'] = np.nan; self.rmse['product'] = np.nan
            return None

    def generate_fine_time_grid(self, time):
        # ... (same as before)
        if time is None or len(time) < 2: # Need at least 2 points to define a range
             return np.array([0]) if (time is None or len(time)==0) else np.array(time)
        time_min, time_max = np.min(time), np.max(time)
        if time_min == time_max: # If all time points are the same
            return np.array([time_min])
        time_fine = np.linspace(time_min, time_max, 500)
        return time_fine


    def system(self, y, t, biomass_params_list, substrate_params_list, product_params_list, model_type_for_ode):
        # model_type_for_ode is passed to ensure we use the correct diff eq
        X, S, P = y
        dXdt = 0.0

        if model_type_for_ode == 'logistic':
            # biomass_params_list for logistic: [Xo, Xm, um]
            dXdt = self.logistic_diff(X, t, biomass_params_list)
        elif model_type_for_ode == 'gompertz':
            # biomass_params_list for gompertz: [Xm, um, lag]
            dXdt = self.gompertz_diff(X, t, biomass_params_list)
        elif model_type_for_ode == 'moser':
            # biomass_params_list for moser: [Xm, um, Ks]
            dXdt = self.moser_diff(X, t, biomass_params_list)
        # No ODE for Baranyi in this version
        else:
            # This case should ideally be prevented before calling system if model has no diff eq
            print(f"Advertencia: Ecuación diferencial no definida para el modelo {model_type_for_ode} en la función 'system'. dXdt=0.")
            dXdt = 0.0 

        p_val = substrate_params_list[1] if len(substrate_params_list) > 1 else 0
        q_val = substrate_params_list[2] if len(substrate_params_list) > 2 else 0
        dSdt = -p_val * dXdt - q_val * X

        alpha_val = product_params_list[1] if len(product_params_list) > 1 else 0
        beta_val = product_params_list[2] if len(product_params_list) > 2 else 0
        dPdt = alpha_val * dXdt + beta_val * X
        return [dXdt, dSdt, dPdt]

    def get_initial_conditions(self, time, biomass, substrate, product):
        X0_exp = biomass[0] if biomass is not None and len(biomass) > 0 else 0
        S0_exp = substrate[0] if substrate is not None and len(substrate) > 0 else 0
        P0_exp = product[0] if product is not None and len(product) > 0 else 0

        X0 = X0_exp
        if 'biomass' in self.params and self.params['biomass']:
            if self.model_type == 'logistic':
                X0 = self.params['biomass'].get('Xo', X0_exp)
            elif self.model_type == 'baranyi': # Baranyi also has X0 as a direct parameter
                X0 = self.params['biomass'].get('X0', X0_exp)
            elif self.model_type == 'gompertz' and self.biomass_model:
                # For Gompertz, X(t=0) needs to be calculated from its parameters
                # Parameters: Xm, um, lag
                params_list = [self.params['biomass'].get('Xm',1), self.params['biomass'].get('um',0.1), self.params['biomass'].get('lag',0)]
                X0_calc = self.biomass_model(0, *params_list)
                X0 = X0_calc if not np.isnan(X0_calc) else X0_exp
            elif self.model_type == 'moser' and self.biomass_model:
                # For Moser, X(t=0) needs to be calculated
                # Parameters: Xm, um, Ks
                params_list = [self.params['biomass'].get('Xm',1), self.params['biomass'].get('um',0.1), self.params['biomass'].get('Ks',0)]
                X0_calc = self.biomass_model(0, *params_list)
                X0 = X0_calc if not np.isnan(X0_calc) else X0_exp
        
        S0 = self.params.get('substrate', {}).get('so', S0_exp)
        P0 = self.params.get('product', {}).get('po', P0_exp)
            
        X0 = X0 if not np.isnan(X0) else 0.0
        S0 = S0 if not np.isnan(S0) else 0.0
        P0 = P0 if not np.isnan(P0) else 0.0
        return [X0, S0, P0]

    def solve_differential_equations(self, time, biomass, substrate, product):
        if self.biomass_diff is None: # Check if a differential equation is defined for this model
            print(f"ODE solving no está soportado para el modelo {self.model_type}. Se usarán resultados de curve_fit.")
            return None, None, None, time # Return None for solutions, original time

        if 'biomass' not in self.params or not self.params['biomass']:
            print("No hay parámetros de biomasa, no se pueden resolver las EDO.")
            return None, None, None, time
        if time is None or len(time) == 0 :
            print("Tiempo no válido para resolver EDOs.")
            return None, None, None, np.array([])

        # Prepare biomass_params_list for ODE system based on self.model_type
        # This list should match what the respective _diff function expects
        if self.model_type == 'logistic':
            biomass_params_list_ode = [self.params['biomass']['Xo'], self.params['biomass']['Xm'], self.params['biomass']['um']]
        elif self.model_type == 'gompertz':
            biomass_params_list_ode = [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['lag']]
        elif self.model_type == 'moser':
            biomass_params_list_ode = [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']]
        # Baranyi does not have biomass_diff implemented here, so it's caught by self.biomass_diff is None
        else:
            print(f"Tipo de modelo de biomasa desconocido para EDO: {self.model_type}")
            return None, None, None, time

        substrate_params_list = [
            self.params.get('substrate', {}).get('so', 0),
            self.params.get('substrate', {}).get('p', 0),
            self.params.get('substrate', {}).get('q', 0)
        ]
        product_params_list = [
            self.params.get('product', {}).get('po', 0),
            self.params.get('product', {}).get('alpha', 0),
            self.params.get('product', {}).get('beta', 0)
        ]

        initial_conditions = self.get_initial_conditions(time, biomass, substrate, product)
        time_fine = self.generate_fine_time_grid(time)
        if len(time_fine) == 0:
            print("No se pudo generar la malla de tiempo fina.")
            return None, None, None, time

        try:
            sol = odeint(self.system, initial_conditions, time_fine,
                         args=(biomass_params_list_ode, substrate_params_list, product_params_list, self.model_type), # Pass self.model_type for routing in self.system
                         rtol=1e-6, atol=1e-6)
        except Exception as e:
            print(f"Error al resolver EDOs con odeint: {e}")
            try:
                print("Intentando con método 'lsoda'...")
                sol = odeint(self.system, initial_conditions, time_fine,
                             args=(biomass_params_list_ode, substrate_params_list, product_params_list, self.model_type),
                             rtol=1e-6, atol=1e-6, method='lsoda')
            except Exception as e_lsoda:
                print(f"Error al resolver EDOs con odeint (método lsoda): {e_lsoda}")
                return None, None, None, time_fine

        X = sol[:, 0]
        S = sol[:, 1]
        P = sol[:, 2]
        return X, S, P, time_fine

    def plot_results(self, time, biomass, substrate, product,
                     y_pred_biomass_fit, y_pred_substrate_fit, y_pred_product_fit, # Renamed to avoid confusion
                     biomass_std=None, substrate_std=None, product_std=None,
                     experiment_name='', legend_position='best', params_position='upper right',
                     show_legend=True, show_params=True,
                     style='whitegrid',
                     line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
                     use_differential=False, axis_labels=None,
                     show_error_bars=True, error_cap_size=3, error_line_width=1):

        # Initialize predictions with curve_fit results
        y_pred_biomass, y_pred_substrate, y_pred_product = y_pred_biomass_fit, y_pred_substrate_fit, y_pred_product_fit

        if y_pred_biomass is None and not (use_differential and self.biomass_diff is not None):
             print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} y no se usan EDO. Omitiendo figura.")
             return None
        
        # Check if ODE should be used and is supported
        can_use_ode = use_differential and self.biomass_diff is not None and 'biomass' in self.params and self.params['biomass']
        if use_differential and self.biomass_diff is None:
            print(f"Modelo {self.model_type} no soporta EDOs. Usando ajuste directo.")
        
        if axis_labels is None: axis_labels = {'x_label': 'Tiempo', 'biomass_label': 'Biomasa', 'substrate_label': 'Sustrato', 'product_label': 'Producto'}
        sns.set_style(style)
        time_to_plot = time 

        if can_use_ode:
            X_ode, S_ode, P_ode, time_fine_ode = self.solve_differential_equations(time, biomass, substrate, product)
            if X_ode is not None:
                y_pred_biomass, y_pred_substrate, y_pred_product = X_ode, S_ode, P_ode
                time_to_plot = time_fine_ode
            else:
                print(f"Fallo al resolver EDOs para {experiment_name}, usando resultados de curve_fit si existen.")
                time_to_plot = self.generate_fine_time_grid(time) # Use fine grid for curve_fit if ODE fails
                # Re-evaluate curve_fit results on fine grid if they exist
                if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                    biomass_params_values = list(self.params['biomass'].values())
                    y_pred_biomass = self.biomass_model(time_to_plot, *biomass_params_values)
                    if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params['substrate']:
                         substrate_params_values = list(self.params['substrate'].values())
                         y_pred_substrate = self.substrate(time_to_plot, *substrate_params_values, biomass_params_values)
                    if y_pred_product_fit is not None and 'product' in self.params and self.params['product']:
                         product_params_values = list(self.params['product'].values())
                         y_pred_product = self.product(time_to_plot, *product_params_values, biomass_params_values)

        else: # Not using ODE or ODE not supported, use curve_fit results on a fine grid
            time_to_plot = self.generate_fine_time_grid(time)
            if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                biomass_params_values = list(self.params['biomass'].values()) # Get latest params
                y_pred_biomass = self.biomass_model(time_to_plot, *biomass_params_values)
                if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params['substrate']:
                     substrate_params_values = list(self.params['substrate'].values())
                     y_pred_substrate = self.substrate(time_to_plot, *substrate_params_values, biomass_params_values)
                else: # If substrate fit failed or no data, plot NaNs
                     y_pred_substrate = np.full_like(time_to_plot, np.nan)
                if y_pred_product_fit is not None and 'product' in self.params and self.params['product']:
                     product_params_values = list(self.params['product'].values())
                     y_pred_product = self.product(time_to_plot, *product_params_values, biomass_params_values)
                else: # If product fit failed or no data, plot NaNs
                     y_pred_product = np.full_like(time_to_plot, np.nan)
            else: # Biomass fit failed
                y_pred_biomass = np.full_like(time_to_plot, np.nan)
                y_pred_substrate = np.full_like(time_to_plot, np.nan)
                y_pred_product = np.full_like(time_to_plot, np.nan)


        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15))
        fig.suptitle(f'{experiment_name} ({self.model_type.capitalize()})', fontsize=16)

        plots_config = [
            (ax1, biomass, y_pred_biomass, biomass_std, axis_labels['biomass_label'], 'Modelo', self.params.get('biomass', {}),
             self.r2.get('biomass', np.nan), self.rmse.get('biomass', np.nan)),
            (ax2, substrate, y_pred_substrate, substrate_std, axis_labels['substrate_label'], 'Modelo', self.params.get('substrate', {}),
             self.r2.get('substrate', np.nan), self.rmse.get('substrate', np.nan)),
            (ax3, product, y_pred_product, product_std, axis_labels['product_label'], 'Modelo', self.params.get('product', {}),
             self.r2.get('product', np.nan), self.rmse.get('product', np.nan))
        ]
        # ... (rest of plot_results is the same as your provided code, using the new y_pred variables)
        for idx, (ax, data_exp, y_pred_model, data_std_exp, ylabel, model_name_legend, params_dict, r2_val, rmse_val) in enumerate(plots_config):
            if data_exp is not None and len(data_exp) > 0 and not np.all(np.isnan(data_exp)):
                if show_error_bars and data_std_exp is not None and len(data_std_exp) == len(data_exp) and not np.all(np.isnan(data_std_exp)):
                    ax.errorbar(
                        time, data_exp, yerr=data_std_exp, 
                        fmt=marker_style, color=point_color,
                        label='Datos experimentales', 
                        capsize=error_cap_size,
                        elinewidth=error_line_width,
                        markeredgewidth=1
                    )
                else:
                    ax.plot(time, data_exp, marker=marker_style, linestyle='', color=point_color,
                            label='Datos experimentales')
            else:
                ax.text(0.5, 0.5, 'No hay datos experimentales para mostrar.',
                        horizontalalignment='center', verticalalignment='center',
                        transform=ax.transAxes, fontsize=10, color='gray')

            if y_pred_model is not None and len(y_pred_model) > 0 and not np.all(np.isnan(y_pred_model)):
                ax.plot(time_to_plot, y_pred_model, linestyle=line_style, color=line_color, label=model_name_legend)
            # ... (rest of messages for failed fits)
            elif idx == 0 and (y_pred_biomass_fit is None and not can_use_ode): # If biomass fit failed and ODE not possible
                 ax.text(0.5, 0.6, 'Modelo de biomasa no ajustado.',
                        horizontalalignment='center', verticalalignment='center',
                        transform=ax.transAxes, fontsize=10, color='red')
            elif (idx == 1 and y_pred_substrate_fit is None and not can_use_ode) or \
                 (idx == 2 and y_pred_product_fit is None and not can_use_ode) :
                if not ('biomass' in self.params and self.params['biomass']): # If biomass params are missing
                     ax.text(0.5, 0.4, 'Modelo no ajustado (depende de biomasa).',
                        horizontalalignment='center', verticalalignment='center',
                        transform=ax.transAxes, fontsize=10, color='orange')
                elif y_pred_model is None or np.all(np.isnan(y_pred_model)): # If this specific model (S or P) failed
                     ax.text(0.5, 0.4, 'Modelo no ajustado.',
                        horizontalalignment='center', verticalalignment='center',
                        transform=ax.transAxes, fontsize=10, color='orange')


            ax.set_xlabel(axis_labels['x_label'])
            ax.set_ylabel(ylabel)
            if show_legend:
                ax.legend(loc=legend_position)
            ax.set_title(f'{ylabel}')

            if show_params and params_dict and any(np.isfinite(v) for v in params_dict.values()): # Show if any param is finite
                param_text_list = []
                for k, v_param in params_dict.items():
                    param_text_list.append(f"{k} = {v_param:.3g}" if np.isfinite(v_param) else f"{k} = N/A")
                param_text = '\n'.join(param_text_list)
                
                r2_display = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
                rmse_display = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
                text = f"{param_text}\nR² = {r2_display}\nRMSE = {rmse_display}"

                if params_position == 'outside right':
                    bbox_props = dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.5)
                    fig.subplots_adjust(right=0.75)
                    ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
                                xytext=(10,0), textcoords='offset points',
                                verticalalignment='center', horizontalalignment='left',
                                bbox=bbox_props)
                else:
                    text_x, ha = (0.95, 'right') if 'right' in params_position else (0.05, 'left')
                    text_y, va = (0.95, 'top') if 'upper' in params_position else (0.05, 'bottom')
                    ax.text(text_x, text_y, text, transform=ax.transAxes,
                            verticalalignment=va, horizontalalignment=ha,
                            bbox={'boxstyle': 'round,pad=0.3', 'facecolor':'wheat', 'alpha':0.5})
            elif show_params : # No params or all NaN
                 ax.text(0.5, 0.3, 'Parámetros no disponibles.',
                        horizontalalignment='center', verticalalignment='center',
                        transform=ax.transAxes, fontsize=9, color='grey')


        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
        buf = io.BytesIO()
        fig.savefig(buf, format='png', bbox_inches='tight')
        buf.seek(0)
        image = Image.open(buf).convert("RGB")
        plt.close(fig)
        return image

    def plot_combined_results(self, time, biomass, substrate, product,
                              y_pred_biomass_fit, y_pred_substrate_fit, y_pred_product_fit, # Renamed
                              biomass_std=None, substrate_std=None, product_std=None,
                              experiment_name='', legend_position='best', params_position='upper right',
                              show_legend=True, show_params=True,
                              style='whitegrid',
                              line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
                              use_differential=False, axis_labels=None,
                              show_error_bars=True, error_cap_size=3, error_line_width=1):
        
        y_pred_biomass, y_pred_substrate, y_pred_product = y_pred_biomass_fit, y_pred_substrate_fit, y_pred_product_fit

        if y_pred_biomass is None and not (use_differential and self.biomass_diff is not None):
            print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} (combinado). Omitiendo figura.")
            return None
        
        can_use_ode = use_differential and self.biomass_diff is not None and 'biomass' in self.params and self.params['biomass']
        if use_differential and self.biomass_diff is None:
            print(f"Modelo {self.model_type} no soporta EDOs (combinado). Usando ajuste directo.")

        if axis_labels is None: axis_labels = {'x_label': 'Tiempo', 'biomass_label': 'Biomasa', 'substrate_label': 'Sustrato', 'product_label': 'Producto'}
        sns.set_style(style)
        time_to_plot = time

        if can_use_ode:
            X_ode, S_ode, P_ode, time_fine_ode = self.solve_differential_equations(time, biomass, substrate, product)
            if X_ode is not None:
                y_pred_biomass, y_pred_substrate, y_pred_product = X_ode, S_ode, P_ode
                time_to_plot = time_fine_ode
            else:
                print(f"Fallo al resolver EDOs para {experiment_name} (combinado), usando resultados de curve_fit.")
                time_to_plot = self.generate_fine_time_grid(time)
                if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                    biomass_params_values = list(self.params['biomass'].values())
                    y_pred_biomass = self.biomass_model(time_to_plot, *biomass_params_values)
                    if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params['substrate']:
                         substrate_params_values = list(self.params['substrate'].values())
                         y_pred_substrate = self.substrate(time_to_plot, *substrate_params_values, biomass_params_values)
                    if y_pred_product_fit is not None and 'product' in self.params and self.params['product']:
                         product_params_values = list(self.params['product'].values())
                         y_pred_product = self.product(time_to_plot, *product_params_values, biomass_params_values)
        else: # Not using ODE or ODE not supported
            time_to_plot = self.generate_fine_time_grid(time)
            if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                biomass_params_values = list(self.params['biomass'].values())
                y_pred_biomass = self.biomass_model(time_to_plot, *biomass_params_values)
                if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params['substrate']:
                     substrate_params_values = list(self.params['substrate'].values())
                     y_pred_substrate = self.substrate(time_to_plot, *substrate_params_values, biomass_params_values)
                else: y_pred_substrate = np.full_like(time_to_plot, np.nan)
                if y_pred_product_fit is not None and 'product' in self.params and self.params['product']:
                     product_params_values = list(self.params['product'].values())
                     y_pred_product = self.product(time_to_plot, *product_params_values, biomass_params_values)
                else: y_pred_product = np.full_like(time_to_plot, np.nan)
            else:
                y_pred_biomass = np.full_like(time_to_plot, np.nan)
                y_pred_substrate = np.full_like(time_to_plot, np.nan)
                y_pred_product = np.full_like(time_to_plot, np.nan)

        fig, ax1 = plt.subplots(figsize=(12, 7))
        fig.suptitle(f'{experiment_name} ({self.model_type.capitalize()})', fontsize=16)

        # ... (rest of plot_combined_results is the same, using new y_pred variables and error bar params)
        colors = {'Biomasa': 'blue', 'Sustrato': 'green', 'Producto': 'red'}
        data_colors = {'Biomasa': 'darkblue', 'Sustrato': 'darkgreen', 'Producto': 'darkred'}
        model_colors = {'Biomasa': 'cornflowerblue', 'Sustrato': 'limegreen', 'Producto': 'salmon'}

        ax1.set_xlabel(axis_labels['x_label'])
        ax1.set_ylabel(axis_labels['biomass_label'], color=colors['Biomasa'])
        if biomass is not None and len(biomass) > 0 and not np.all(np.isnan(biomass)):
            if show_error_bars and biomass_std is not None and len(biomass_std) == len(biomass) and not np.all(np.isnan(biomass_std)):
                ax1.errorbar(
                    time, biomass, yerr=biomass_std, 
                    fmt=marker_style, color=data_colors['Biomasa'],
                    label=f'{axis_labels["biomass_label"]} (Datos)', 
                    capsize=error_cap_size, elinewidth=error_line_width, markersize=5
                )
            else:
                ax1.plot(time, biomass, marker=marker_style, linestyle='', color=data_colors['Biomasa'],
                         label=f'{axis_labels["biomass_label"]} (Datos)', markersize=5)
        if y_pred_biomass is not None and len(y_pred_biomass) > 0 and not np.all(np.isnan(y_pred_biomass)):
            ax1.plot(time_to_plot, y_pred_biomass, linestyle=line_style, color=model_colors['Biomasa'],
                     label=f'{axis_labels["biomass_label"]} (Modelo)')
        ax1.tick_params(axis='y', labelcolor=colors['Biomasa'])

        ax2 = ax1.twinx()
        ax2.set_ylabel(axis_labels['substrate_label'], color=colors['Sustrato'])
        if substrate is not None and len(substrate) > 0 and not np.all(np.isnan(substrate)):
            if show_error_bars and substrate_std is not None and len(substrate_std) == len(substrate) and not np.all(np.isnan(substrate_std)):
                ax2.errorbar(
                    time, substrate, yerr=substrate_std, 
                    fmt=marker_style, color=data_colors['Sustrato'],
                    label=f'{axis_labels["substrate_label"]} (Datos)', 
                    capsize=error_cap_size, elinewidth=error_line_width, markersize=5
                )
            else:
                ax2.plot(time, substrate, marker=marker_style, linestyle='', color=data_colors['Sustrato'],
                         label=f'{axis_labels["substrate_label"]} (Datos)', markersize=5)
        if y_pred_substrate is not None and len(y_pred_substrate) > 0 and not np.all(np.isnan(y_pred_substrate)):
            ax2.plot(time_to_plot, y_pred_substrate, linestyle=line_style, color=model_colors['Sustrato'],
                     label=f'{axis_labels["substrate_label"]} (Modelo)')
        ax2.tick_params(axis='y', labelcolor=colors['Sustrato'])

        ax3 = ax1.twinx()
        ax3.spines["right"].set_position(("axes", 1.15))
        ax3.set_frame_on(True); ax3.patch.set_visible(False)
        ax3.set_ylabel(axis_labels['product_label'], color=colors['Producto'])
        if product is not None and len(product) > 0 and not np.all(np.isnan(product)):
            if show_error_bars and product_std is not None and len(product_std) == len(product) and not np.all(np.isnan(product_std)):
                ax3.errorbar(
                    time, product, yerr=product_std, 
                    fmt=marker_style, color=data_colors['Producto'],
                    label=f'{axis_labels["product_label"]} (Datos)', 
                    capsize=error_cap_size, elinewidth=error_line_width, markersize=5
                )
            else:
                ax3.plot(time, product, marker=marker_style, linestyle='', color=data_colors['Producto'],
                         label=f'{axis_labels["product_label"]} (Datos)', markersize=5)
        if y_pred_product is not None and len(y_pred_product) > 0 and not np.all(np.isnan(y_pred_product)):
            ax3.plot(time_to_plot, y_pred_product, linestyle=line_style, color=model_colors['Producto'],
                     label=f'{axis_labels["product_label"]} (Modelo)')
        ax3.tick_params(axis='y', labelcolor=colors['Producto'])

        lines_labels_collect = []
        for ax_current in [ax1, ax2, ax3]:
            h, l = ax_current.get_legend_handles_labels()
            if h: lines_labels_collect.append((h,l))
        
        if lines_labels_collect:
            lines, labels = [sum(lol, []) for lol in zip(*[(h,l) for h,l in lines_labels_collect])]
            unique_labels_dict = dict(zip(labels, lines))
            if show_legend: ax1.legend(unique_labels_dict.values(), unique_labels_dict.keys(), loc=legend_position)

        if show_params:
            texts_to_display = []
            param_categories = [
                (axis_labels['biomass_label'], self.params.get('biomass', {}), self.r2.get('biomass', np.nan), self.rmse.get('biomass', np.nan)),
                (axis_labels['substrate_label'], self.params.get('substrate', {}), self.r2.get('substrate', np.nan), self.rmse.get('substrate', np.nan)),
                (axis_labels['product_label'], self.params.get('product', {}), self.r2.get('product', np.nan), self.rmse.get('product', np.nan))
            ]
            for label, params_dict, r2_val, rmse_val in param_categories:
                if params_dict and any(np.isfinite(v) for v in params_dict.values()):
                    param_text_list = [f"  {k} = {v_par:.3g}" if np.isfinite(v_par) else f"  {k} = N/A" for k,v_par in params_dict.items()]
                    param_text = '\n'.join(param_text_list)
                    r2_display = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
                    rmse_display = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
                    texts_to_display.append(f"{label}:\n{param_text}\n  R² = {r2_display}\n  RMSE = {rmse_display}")
                elif params_dict: texts_to_display.append(f"{label}:\n  Parámetros no válidos o N/A")
            total_text = "\n\n".join(texts_to_display)
            if total_text:
                if params_position == 'outside right':
                    fig.subplots_adjust(right=0.70)
                    fig.text(0.72, 0.5, total_text, transform=fig.transFigure,
                             verticalalignment='center', horizontalalignment='left',
                             bbox=dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.7), fontsize=8)
                else:
                    text_x, ha = (0.95, 'right') if 'right' in params_position else (0.05, 'left')
                    text_y, va = (0.95, 'top') if 'upper' in params_position else (0.05, 'bottom')
                    ax1.text(text_x, text_y, total_text, transform=ax1.transAxes,
                             verticalalignment=va, horizontalalignment=ha,
                             bbox=dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.7), fontsize=8)

        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
        if params_position == 'outside right': fig.subplots_adjust(right=0.70)
        buf = io.BytesIO(); fig.savefig(buf, format='png', bbox_inches='tight'); buf.seek(0)
        image = Image.open(buf).convert("RGB"); plt.close(fig)
        return image


def process_all_data(file, legend_position, params_position, model_types_selected, experiment_names_str,
                     lower_bounds_str, upper_bounds_str,
                     mode, style, line_color, point_color, line_style, marker_style,
                     show_legend, show_params, use_differential, maxfev_val,
                     axis_labels_dict,
                     show_error_bars, error_cap_size, error_line_width):

    # ... (Excel reading and sheet iteration logic remains the same)
    if file is None: return [], pd.DataFrame(), "Por favor, sube un archivo Excel."
    try:
        xls = pd.ExcelFile(file.name if hasattr(file, 'name') else file)
        sheet_names = xls.sheet_names
        if not sheet_names: return [], pd.DataFrame(), "El archivo Excel está vacío."
    except Exception as e: return [], pd.DataFrame(), f"Error al leer el archivo Excel: {e}"

    figures = []
    comparison_data = []
    experiment_names_list = experiment_names_str.strip().split('\n') if experiment_names_str.strip() else []
    all_plot_messages = []

    for sheet_name_idx, sheet_name in enumerate(sheet_names):
        current_experiment_name_base = (experiment_names_list[sheet_name_idx]
                                    if sheet_name_idx < len(experiment_names_list) and experiment_names_list[sheet_name_idx]
                                    else f"Hoja '{sheet_name}'")
        try:
            df = pd.read_excel(xls, sheet_name=sheet_name, header=[0, 1])
            if df.empty: all_plot_messages.append(f"Hoja '{sheet_name}' vacía."); continue
            if not any(col_level2 == 'Tiempo' for _, col_level2 in df.columns):
                all_plot_messages.append(f"Hoja '{sheet_name}' sin 'Tiempo'."); continue
        except Exception as e:
            all_plot_messages.append(f"Error leyendo hoja '{sheet_name}': {e}."); continue

        model_dummy_for_sheet = BioprocessModel() # To process sheet data once
        try:
            model_dummy_for_sheet.process_data(df)
        except ValueError as e:
            all_plot_messages.append(f"Error procesando datos de '{sheet_name}': {e}."); continue
        
        # Ensure dataxp, datasp, datapp are populated for average/combinado modes
        # These should be populated by model_dummy_for_sheet.process_data()
        # If they are empty lists, it means no valid data was found for that component.

        if mode == 'independent':
            # ... (independent mode logic remains largely the same)
            # Ensure time_exp, biomass_exp etc. are correctly extracted and validated
            grouped_cols = df.columns.get_level_values(0).unique()
            for exp_idx, exp_col_name in enumerate(grouped_cols):
                current_experiment_name = f"{current_experiment_name_base} - Exp {exp_idx + 1} ({exp_col_name})"
                exp_df_slice = df[exp_col_name]
                
                try:
                    time_exp = exp_df_slice['Tiempo'].dropna().astype(float).values
                    biomass_exp = exp_df_slice['Biomasa'].dropna().astype(float).values if 'Biomasa' in exp_df_slice else np.array([])
                    substrate_exp = exp_df_slice['Sustrato'].dropna().astype(float).values if 'Sustrato' in exp_df_slice else np.array([])
                    product_exp = exp_df_slice['Producto'].dropna().astype(float).values if 'Producto' in exp_df_slice else np.array([])

                    if len(time_exp) == 0: all_plot_messages.append(f"Sin datos de tiempo para {current_experiment_name}."); continue
                    if len(biomass_exp) == 0: 
                        all_plot_messages.append(f"Sin datos de biomasa para {current_experiment_name}.")
                        for mt in model_types_selected: comparison_data.append({'Experimento': current_experiment_name, 'Modelo': mt.capitalize(), 'R² Biomasa': np.nan, 'RMSE Biomasa': np.nan})
                        continue
                    # Align data if lengths differ due to NaNs (simple truncation to min length)
                    min_len = min(len(time_exp), len(biomass_exp) if len(biomass_exp)>0 else len(time_exp), 
                                  len(substrate_exp) if len(substrate_exp)>0 else len(time_exp), 
                                  len(product_exp) if len(product_exp)>0 else len(time_exp))
                    time_exp = time_exp[:min_len]
                    if len(biomass_exp)>0: biomass_exp = biomass_exp[:min_len]
                    if len(substrate_exp)>0: substrate_exp = substrate_exp[:min_len]
                    if len(product_exp)>0: product_exp = product_exp[:min_len]


                except KeyError as e: all_plot_messages.append(f"Faltan columnas en '{current_experiment_name}': {e}."); continue
                except Exception as e_data: all_plot_messages.append(f"Error extrayendo datos para '{current_experiment_name}': {e_data}."); continue

                biomass_std_exp, substrate_std_exp, product_std_exp = None, None, None # No std for independent mode here

                for model_type_iter in model_types_selected:
                    model_instance = BioprocessModel(model_type=model_type_iter, maxfev=maxfev_val)
                    model_instance.fit_model() # Sets self.biomass_model, self.biomass_diff
                    y_pred_biomass = model_instance.fit_biomass(time_exp, biomass_exp)
                    y_pred_substrate, y_pred_product = None, None
                    if y_pred_biomass is not None and model_instance.params.get('biomass'):
                        if len(substrate_exp) > 0: y_pred_substrate = model_instance.fit_substrate(time_exp, substrate_exp, model_instance.params['biomass'])
                        if len(product_exp) > 0: y_pred_product = model_instance.fit_product(time_exp, product_exp, model_instance.params['biomass'])
                    else: all_plot_messages.append(f"Ajuste biomasa falló: {current_experiment_name}, {model_type_iter}.")
                    
                    comparison_data.append({
                        'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
                        'R² Biomasa': model_instance.r2.get('biomass', np.nan), 'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
                        'R² Sustrato': model_instance.r2.get('substrate', np.nan), 'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
                        'R² Producto': model_instance.r2.get('product', np.nan), 'RMSE Producto': model_instance.rmse.get('product', np.nan)
                    })
                    fig = model_instance.plot_results(
                        time_exp, biomass_exp, substrate_exp, product_exp,
                        y_pred_biomass, y_pred_substrate, y_pred_product, # Pass curve_fit results
                        biomass_std_exp, substrate_std_exp, product_std_exp,
                        current_experiment_name, legend_position, params_position,
                        show_legend, show_params, style, line_color, point_color, line_style, marker_style,
                        use_differential, axis_labels_dict,
                        show_error_bars, error_cap_size, error_line_width
                    )
                    if fig: figures.append(fig)

        elif mode in ['average', 'combinado']:
            # ... (average/combinado mode logic remains largely the same)
            current_experiment_name = f"{current_experiment_name_base} - Promedio"
            time_avg = model_dummy_for_sheet.time
            
            # Check if dataxp, datasp, datapp are available from process_data
            biomass_avg = model_dummy_for_sheet.dataxp[-1] if model_dummy_for_sheet.dataxp and len(model_dummy_for_sheet.dataxp[-1]) > 0 else np.array([])
            substrate_avg = model_dummy_for_sheet.datasp[-1] if model_dummy_for_sheet.datasp and len(model_dummy_for_sheet.datasp[-1]) > 0 else np.array([])
            product_avg = model_dummy_for_sheet.datapp[-1] if model_dummy_for_sheet.datapp and len(model_dummy_for_sheet.datapp[-1]) > 0 else np.array([])

            biomass_std_avg = model_dummy_for_sheet.datax_std[-1] if model_dummy_for_sheet.datax_std and len(model_dummy_for_sheet.datax_std[-1]) == len(biomass_avg) else None
            substrate_std_avg = model_dummy_for_sheet.datas_std[-1] if model_dummy_for_sheet.datas_std and len(model_dummy_for_sheet.datas_std[-1]) == len(substrate_avg) else None
            product_std_avg = model_dummy_for_sheet.datap_std[-1] if model_dummy_for_sheet.datap_std and len(model_dummy_for_sheet.datap_std[-1]) == len(product_avg) else None

            if time_avg is None or len(time_avg) == 0: all_plot_messages.append(f"Sin datos de tiempo promedio para '{sheet_name}'."); continue
            if len(biomass_avg) == 0:
                all_plot_messages.append(f"Sin datos de biomasa promedio para '{sheet_name}'.")
                for mt in model_types_selected: comparison_data.append({'Experimento': current_experiment_name, 'Modelo': mt.capitalize(), 'R² Biomasa': np.nan, 'RMSE Biomasa': np.nan})
                continue
            
            for model_type_iter in model_types_selected:
                model_instance = BioprocessModel(model_type=model_type_iter, maxfev=maxfev_val)
                model_instance.fit_model()
                y_pred_biomass = model_instance.fit_biomass(time_avg, biomass_avg)
                y_pred_substrate, y_pred_product = None, None
                if y_pred_biomass is not None and model_instance.params.get('biomass'):
                    if len(substrate_avg) > 0: y_pred_substrate = model_instance.fit_substrate(time_avg, substrate_avg, model_instance.params['biomass'])
                    if len(product_avg) > 0: y_pred_product = model_instance.fit_product(time_avg, product_avg, model_instance.params['biomass'])
                else: all_plot_messages.append(f"Ajuste biomasa promedio falló: {current_experiment_name}, {model_type_iter}.")

                comparison_data.append({
                    'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
                    'R² Biomasa': model_instance.r2.get('biomass', np.nan), 'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
                    'R² Sustrato': model_instance.r2.get('substrate', np.nan), 'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
                    'R² Producto': model_instance.r2.get('product', np.nan), 'RMSE Producto': model_instance.rmse.get('product', np.nan)
                })
                plot_func = model_instance.plot_combined_results if mode == 'combinado' else model_instance.plot_results
                fig = plot_func(
                    time_avg, biomass_avg, substrate_avg, product_avg,
                    y_pred_biomass, y_pred_substrate, y_pred_product, # Pass curve_fit results
                    biomass_std_avg, substrate_std_avg, product_std_avg,
                    current_experiment_name, legend_position, params_position,
                    show_legend, show_params, style, line_color, point_color, line_style, marker_style,
                    use_differential, axis_labels_dict,
                    show_error_bars, error_cap_size, error_line_width
                )
                if fig: figures.append(fig)

    comparison_df = pd.DataFrame(comparison_data)
    if not comparison_df.empty:
        for col in ['R² Biomasa', 'RMSE Biomasa', 'R² Sustrato', 'RMSE Sustrato', 'R² Producto', 'RMSE Producto']:
            if col in comparison_df.columns: comparison_df[col] = pd.to_numeric(comparison_df[col], errors='coerce')
        comparison_df_sorted = comparison_df.sort_values(
            by=['Experimento', 'Modelo', 'R² Biomasa', 'R² Sustrato', 'R² Producto', 'RMSE Biomasa', 'RMSE Sustrato', 'RMSE Producto'],
            ascending=[True, True, False, False, False, True, True, True]
        ).reset_index(drop=True)
    else:
        comparison_df_sorted = pd.DataFrame(columns=[
            'Experimento', 'Modelo', 'R² Biomasa', 'RMSE Biomasa',
            'R² Sustrato', 'RMSE Sustrato', 'R² Producto', 'RMSE Producto'
        ])

    final_message = "Procesamiento completado."
    if all_plot_messages: final_message += " Mensajes:\n" + "\n".join(all_plot_messages)
    if not figures and not comparison_df_sorted.empty: final_message += "\nNo se generaron gráficos, pero hay datos en la tabla."
    elif not figures and comparison_df_sorted.empty: final_message += "\nNo se generaron gráficos ni datos para la tabla."
    return figures, comparison_df_sorted, final_message


MODEL_CHOICES = [
    ("Logistic (3-parám)", "logistic"),
    ("Gompertz (3-parám)", "gompertz"),
    ("Moser (3-parám)", "moser"),
    ("Baranyi (4-parám)", "baranyi")
    # Add more models here as ("Display Name (X-param)", "internal_model_name")
]

def create_interface():
    with gr.Blocks(theme=gr.themes.Soft()) as demo:
        gr.Markdown("# Modelos Cinéticos de Bioprocesos")
        # ... (Markdown descriptions remain the same)
        gr.Markdown(r"""
        Análisis y visualización de datos de bioprocesos utilizando modelos cinéticos como Logístico, Gompertz y Moser para el crecimiento de biomasa,
        y el modelo de Luedeking-Piret para el consumo de sustrato y la formación de producto.
        Nuevos modelos como Baranyi (4 parámetros) han sido añadidos.

        **Instrucciones:**
        1.  Sube un archivo Excel. El archivo debe tener una estructura de MultiIndex en las columnas:
            - Nivel 0: Nombre del experimento/tratamiento (ej: "Control", "Tratamiento A")
            - Nivel 1: Tipo de dato ("Tiempo", "Biomasa", "Sustrato", "Producto")
            - Si hay réplicas, deben estar como columnas separadas bajo el mismo nombre de experimento (Nivel 0) y tipo de dato (Nivel 1).
              Ejemplo: (Control, Biomasa, Rep1), (Control, Biomasa, Rep2). El código promediará estas réplicas para los modos "average" y "combinado".
              Para el modo "independent", se asume una sola serie de datos por (Experimento, TipoDato).
        2.  Selecciona el/los tipo(s) de modelo(s) de biomasa a ajustar. Los modelos están agrupados por el número de parámetros.
        3.  Elige el modo de análisis:
            - `independent`: Analiza cada experimento (columna de Nivel 0) individualmente.
            - `average`: Promedia los datos de todos los experimentos dentro de una hoja y ajusta los modelos a estos promedios. Se grafica en subplots separados.
            - `combinado`: Similar a `average`, pero grafica Biomasa, Sustrato y Producto en un solo gráfico con múltiples ejes Y.
        4.  Configura las opciones de graficación (leyenda, parámetros, estilos, colores, etc.).
        5.  (Opcional) Personaliza los nombres de los experimentos y los títulos de los ejes.
        6.  Haz clic en "Simular" para generar los gráficos y la tabla comparativa.
        7.  Puedes exportar la tabla de resultados a Excel o CSV.
        """)
        gr.Markdown(r"""
        ## Ecuaciones Diferenciales Utilizadas (Simplificado)

        **Biomasa:**

        - Logístico (3p: $X_0, X_m, \mu_m$):
        $$ X(t) = \frac{X_0 X_m e^{\mu_m t}}{X_m - X_0 + X_0 e^{\mu_m t}} \quad \text{o} \quad \frac{dX}{dt} = \mu_m X\left(1 - \frac{X}{X_m}\right) $$

        - Gompertz (3p: $X_m, \mu_m, \lambda$):
        $$ X(t) = X_m \exp\left(-\exp\left(\frac{\mu_m e}{X_m}(\lambda-t)+1\right)\right) \quad \text{o} \quad \frac{dX}{dt} = \mu_m X \ln\left(\frac{X_m}{X}\right) \text{ (forma alternativa)} $$
        
        - Moser (3p: $X_m, \mu_m, K_s$ - forma simplificada):
        $$ X(t)=X_m(1-e^{-\mu_m(t-K_s)}) \quad \text{o} \quad \frac{dX}{dt}=\mu_m(X_m - X) $$

        - Baranyi (4p: $X_0, X_m, \mu_m, \lambda$):
        $$ \ln X(t) = \ln X_0 + \mu_m A(t) - \ln\left(1 + \frac{e^{\mu_m A(t)}-1}{X_m/X_0}\right) $$
        $$ A(t) = t + \frac{1}{\mu_m} \ln(e^{-\mu_m t} + e^{-\mu_m \lambda} - e^{-\mu_m(t+\lambda)}) $$
        (Ecuación diferencial compleja, no usada para ODE en esta versión)

        **Sustrato y Producto (Luedeking-Piret):**
        $$ \frac{dS}{dt} = -p \frac{dX}{dt} - q X \quad ; \quad \frac{dP}{dt} = \alpha \frac{dX}{dt} + \beta X $$
        Parámetros: $X_m, \mu_m, X_0, \lambda (\text{lag}), K_s, p, q, \alpha, \beta$.
        """)


        with gr.Row():
            file_input = gr.File(label="Subir archivo Excel (.xlsx)", file_types=['.xlsx'])
            mode = gr.Radio(["independent", "average", "combinado"], label="Modo de Análisis", value="independent",
                            info="Independent: cada experimento. Average/Combinado: promedio de la hoja.")

        with gr.Accordion("Configuración de Modelos y Simulación", open=True): # Open by default
            model_types_selected_ui = gr.CheckboxGroup(
                choices=MODEL_CHOICES, # Use the global list of (DisplayName, value)
                label="Tipo(s) de Modelo de Biomasa",
                value=["logistic"] # Default selected internal value
            )
            use_differential_ui = gr.Checkbox(label="Usar Ecuaciones Diferenciales para Graficar (experimental)", value=False,
                                           info="Si se marca, las curvas se generan resolviendo las EDOs (si el modelo lo soporta). Si no, por ajuste directo.")
            maxfev_input_ui = gr.Number(label="maxfev (Máx. evaluaciones para el ajuste)", value=50000, minimum=1000, step=1000)
            experiment_names_str_ui = gr.Textbox(
                label="Nombres de los experimentos/hojas (uno por línea, opcional)",
                placeholder="Nombre para Hoja 1\nNombre para Hoja 2\n...",
                lines=3,
                info="Si se deja vacío, se usarán los nombres de las hojas o 'Exp X'."
            )
        # ... (rest of the UI for graph settings, axis labels, error bars remains the same)
        with gr.Accordion("Configuración de Gráficos", open=False):
            with gr.Row():
                with gr.Column(scale=1):
                    legend_position_ui = gr.Radio(choices=["upper left", "upper right", "lower left", "lower right", "best"], label="Posición de Leyenda", value="best")
                    show_legend_ui = gr.Checkbox(label="Mostrar Leyenda", value=True)
                with gr.Column(scale=1):
                    params_position_ui = gr.Radio(choices=["upper left", "upper right", "lower left", "lower right", "outside right"], label="Posición de Parámetros", value="upper right")
                    show_params_ui = gr.Checkbox(label="Mostrar Parámetros", value=True)
            with gr.Row():
                style_dropdown_ui = gr.Dropdown(choices=['white', 'dark', 'whitegrid', 'darkgrid', 'ticks'], label="Estilo de Gráfico (Seaborn)", value='whitegrid')
                line_color_picker_ui = gr.ColorPicker(label="Color de Línea (Modelo)", value='#0072B2')
                point_color_picker_ui = gr.ColorPicker(label="Color de Puntos (Datos)", value='#D55E00')
            with gr.Row():
                line_style_dropdown_ui = gr.Dropdown(choices=['-', '--', '-.', ':'], label="Estilo de Línea", value='-')
                marker_style_dropdown_ui = gr.Dropdown(choices=['o', 's', '^', 'v', 'D', 'x', '+', '*'], label="Estilo de Marcador (Puntos)", value='o')
            with gr.Row():
                x_axis_label_input_ui = gr.Textbox(label="Título Eje X", value="Tiempo (h)", placeholder="Tiempo (unidades)")
                biomass_axis_label_input_ui = gr.Textbox(label="Título Eje Y (Biomasa)", value="Biomasa (g/L)", placeholder="Biomasa (unidades)")
            with gr.Row():
                substrate_axis_label_input_ui = gr.Textbox(label="Título Eje Y (Sustrato)", value="Sustrato (g/L)", placeholder="Sustrato (unidades)")
                product_axis_label_input_ui = gr.Textbox(label="Título Eje Y (Producto)", value="Producto (g/L)", placeholder="Producto (unidades)")
            with gr.Row():
                show_error_bars_ui = gr.Checkbox(label="Mostrar barras de error", value=True)
                error_cap_size_ui = gr.Slider(label="Tamaño de tapa de barras de error", minimum=1, maximum=10, step=1, value=3)
                error_line_width_ui = gr.Slider(label="Grosor de línea de error", minimum=0.5, maximum=5, step=0.5, value=1.0)

        with gr.Accordion("Configuración Avanzada de Ajuste (No implementado aún)", open=False):
            with gr.Row():
                lower_bounds_str_ui = gr.Textbox(label="Lower Bounds (no usado actualmente)", lines=3)
                upper_bounds_str_ui = gr.Textbox(label="Upper Bounds (no usado actualmente)", lines=3)

        simulate_btn = gr.Button("Simular y Graficar", variant="primary")
        status_message_ui = gr.Textbox(label="Estado del Procesamiento", interactive=False)
        output_gallery_ui = gr.Gallery(label="Resultados Gráficos", columns=[2,1], height='auto', object_fit="contain")
        output_table_ui = gr.Dataframe(
            label="Tabla Comparativa de Modelos",
            headers=["Experimento", "Modelo", "R² Biomasa", "RMSE Biomasa",
                    "R² Sustrato", "RMSE Sustrato", "R² Producto", "RMSE Producto"],
            interactive=False, wrap=True
        )
        state_df_ui = gr.State(pd.DataFrame()) # To store the dataframe for export

        def run_simulation_interface(file, legend_pos, params_pos, models_sel, analysis_mode, exp_names,
                                     low_bounds, up_bounds, plot_style,
                                     line_col, point_col, line_sty, marker_sty,
                                     show_leg, show_par, use_diff, maxfev,
                                     x_label, biomass_label, substrate_label, product_label,
                                     show_error_bars_arg, error_cap_size_arg, error_line_width_arg):
            if file is None: return [], pd.DataFrame(), "Error: Por favor, sube un archivo Excel.", pd.DataFrame()
            axis_labels = {
                'x_label': x_label if x_label else 'Tiempo',
                'biomass_label': biomass_label if biomass_label else 'Biomasa',
                'substrate_label': substrate_label if substrate_label else 'Sustrato',
                'product_label': product_label if product_label else 'Producto'
            }
            if not models_sel: return [], pd.DataFrame(), "Error: Por favor, selecciona al menos un modelo.", pd.DataFrame()

            figures, comparison_df, message = process_all_data(
                file, legend_pos, params_pos, models_sel, exp_names,
                low_bounds, up_bounds, analysis_mode, plot_style,
                line_col, point_col, line_sty, marker_sty,
                show_leg, show_par, use_diff, int(maxfev),
                axis_labels, show_error_bars_arg, error_cap_size_arg, error_line_width_arg
            )
            return figures, comparison_df, message, comparison_df

        simulate_btn.click(
            fn=run_simulation_interface,
            inputs=[
                file_input, legend_position_ui, params_position_ui, model_types_selected_ui, mode, experiment_names_str_ui,
                lower_bounds_str_ui, upper_bounds_str_ui, style_dropdown_ui,
                line_color_picker_ui, point_color_picker_ui, line_style_dropdown_ui, marker_style_dropdown_ui,
                show_legend_ui, show_params_ui, use_differential_ui, maxfev_input_ui,
                x_axis_label_input_ui, biomass_axis_label_input_ui, substrate_axis_label_input_ui, product_axis_label_input_ui,
                show_error_bars_ui, error_cap_size_ui, error_line_width_ui
            ],
            outputs=[output_gallery_ui, output_table_ui, status_message_ui, state_df_ui]
        )

        with gr.Row():
            export_excel_btn = gr.Button("Exportar Tabla a Excel")
            export_csv_btn = gr.Button("Exportar Tabla a CSV")
        
        download_file_output_ui = gr.File(label="Descargar archivo", interactive=False)

        def export_excel_interface(df_to_export):
            if df_to_export is None or df_to_export.empty:
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp: tmp.write(b"No hay datos para exportar."); return tmp.name
            try:
                with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False, mode='w+b') as tmp:
                    df_to_export.to_excel(tmp.name, index=False); return tmp.name
            except Exception as e:
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp: tmp.write(f"Error al exportar a Excel: {e}".encode()); return tmp.name
        
        export_excel_btn.click(fn=export_excel_interface, inputs=state_df_ui, outputs=download_file_output_ui)

        def export_csv_interface(df_to_export):
            if df_to_export is None or df_to_export.empty:
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp: tmp.write(b"No hay datos para exportar."); return tmp.name
            try:
                with tempfile.NamedTemporaryFile(suffix=".csv", delete=False, mode='w', encoding='utf-8') as tmp: # CSV is text
                    df_to_export.to_csv(tmp.name, index=False); return tmp.name
            except Exception as e:
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp: tmp.write(f"Error al exportar a CSV: {e}".encode()); return tmp.name

        export_csv_btn.click(fn=export_csv_interface, inputs=state_df_ui, outputs=download_file_output_ui)
        
        gr.Examples(
            examples=[
                [None, "best", "upper right", ["logistic", "baranyi"], "independent", "Exp A\nExp B", "", "", "whitegrid", "#0072B2", "#D55E00", "-", "o", True, True, False, 50000, "Tiempo (días)", "Células (millones/mL)", "Glucosa (mM)", "Anticuerpo (mg/L)", True, 3, 1.0]
            ],
            inputs=[
                file_input, legend_position_ui, params_position_ui, model_types_selected_ui, mode, experiment_names_str_ui,
                lower_bounds_str_ui, upper_bounds_str_ui, style_dropdown_ui,
                line_color_picker_ui, point_color_picker_ui, line_style_dropdown_ui, marker_style_dropdown_ui,
                show_legend_ui, show_params_ui, use_differential_ui, maxfev_input_ui,
                x_axis_label_input_ui, biomass_axis_label_input_ui, substrate_axis_label_input_ui, product_axis_label_input_ui,
                show_error_bars_ui, error_cap_size_ui, error_line_width_ui
            ],
            label="Ejemplo de Configuración (subir archivo manualmente)"
        )
    return demo

if __name__ == '__main__':
    demo_instance = create_interface()
    demo_instance.launch(share=True)