app.py

#import os

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
        self.model_type = model_type
        self.maxfev = maxfev
        self.time = None # Initialize time attribute

    @staticmethod
    def logistic(time, xo, xm, um):
        # Ensure xm is not zero and xo/xm is not 1 to avoid division by zero or log(0)
        if xm == 0 or (xo / xm == 1 and np.any(um * time > 0)): # Simplified check
            return np.full_like(time, np.nan) # or handle appropriately
        # Add a small epsilon to prevent division by zero in the denominator
        denominator = (1 - (xo / xm) * (1 - np.exp(um * time)))
        denominator = np.where(denominator == 0, 1e-9, denominator) # Replace 0 with small number
        return (xo * np.exp(um * time)) / denominator


    @staticmethod
    def gompertz(time, xm, um, lag):
        # Ensure xm is not zero
        if xm == 0:
            return np.full_like(time, np.nan)
        return xm * np.exp(-np.exp((um * np.e / xm) * (lag - time) + 1))

    @staticmethod
    def moser(time, Xm, um, Ks):
        return Xm * (1 - np.exp(-um * (time - Ks)))

    @staticmethod
    def logistic_diff(X, t, params):
        xo, xm, um = params
        if xm == 0: # Prevent division by zero
            return 0
        return um * X * (1 - X / xm)

    @staticmethod
    def gompertz_diff(X, t, params):
        xm, um, lag = params
        if xm == 0: # Prevent division by zero
            return 0
        return X * (um * np.e / xm) * np.exp((um * np.e / xm) * (lag - t) + 1)

    @staticmethod
    def moser_diff(X, t, params):
        Xm, um, Ks = params
        return um * (Xm - X)

    def substrate(self, time, so, p, q, biomass_params):
        if self.biomass_model is None or not biomass_params:
            return np.full_like(time, np.nan)
        X_t = self.biomass_model(time, *biomass_params)
        if np.any(np.isnan(X_t)): # If biomass model returned NaN
             return np.full_like(time, np.nan)
        # dXdt = np.gradient(X_t, time, edge_order=2) # Use edge_order=2 for better boundary derivatives
        # integral_X = np.cumsum(X_t) * np.gradient(time)
        # A more robust way to calculate integral, especially for non-uniform time
        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)) # Estimate dt
            integral_X = np.cumsum(X_t * dt)


        # Initial biomass value is the first element of biomass_params for logistic (xo)
        # For Gompertz and Moser, biomass_params[0] is Xm. We need X(t=0)
        if self.model_type == 'logistic':
            X0 = biomass_params[0]
        elif self.model_type == 'gompertz':
             # X(0) for Gompertz
            X0 = self.gompertz(0, *biomass_params)
        elif self.model_type == 'moser':
            # X(0) for Moser
            X0 = self.moser(0, *biomass_params)
        else:
            X0 = X_t[0] # Fallback

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


    def product(self, time, po, alpha, beta, biomass_params):
        if self.biomass_model is None or not biomass_params:
            return np.full_like(time, np.nan)
        X_t = self.biomass_model(time, *biomass_params)
        if np.any(np.isnan(X_t)): # If biomass model returned NaN
             return np.full_like(time, np.nan)
        # dXdt = np.gradient(X_t, time, edge_order=2)
        # integral_X = np.cumsum(X_t) * np.gradient(time)
        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)) # Estimate dt
            integral_X = np.cumsum(X_t * dt)

        if self.model_type == 'logistic':
            X0 = biomass_params[0]
        elif self.model_type == 'gompertz':
            X0 = self.gompertz(0, *biomass_params)
        elif self.model_type == 'moser':
            X0 = self.moser(0, *biomass_params)
        else:
            X0 = X_t[0]

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

    def process_data(self, df):
        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].values

        if len(biomass_cols) > 0:
            data_biomass = [df[col].values for col in biomass_cols]
            data_biomass = np.array(data_biomass)
            self.datax.append(data_biomass)
            self.dataxp.append(np.mean(data_biomass, axis=0))
            self.datax_std.append(np.std(data_biomass, axis=0, ddof=1))
        else: # Handle case where Biomass columns might be missing
            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].values for col in substrate_cols]
            data_substrate = np.array(data_substrate)
            self.datas.append(data_substrate)
            self.datasp.append(np.mean(data_substrate, axis=0))
            self.datas_std.append(np.std(data_substrate, axis=0, ddof=1))
        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].values for col in product_cols]
            data_product = np.array(data_product)
            self.datap.append(data_product)
            self.datapp.append(np.mean(data_product, axis=0))
            self.datap_std.append(np.std(data_product, axis=0, ddof=1))
        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

    def fit_biomass(self, time, biomass):
        try:
            # Ensure biomass has some variation, otherwise std dev can be 0
            if len(np.unique(biomass)) < 2 : # or np.std(biomass) == 0:
                print(f"Biomasa constante para {self.model_type}, no se puede ajustar el modelo.")
                return None

            if self.model_type == 'logistic':
                # Ensure initial xo is less than xm. Max biomass could be initial guess for xm.
                # xo guess: first non-zero biomass value or a small positive number
                xo_guess = biomass[biomass > 1e-6][0] if np.any(biomass > 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 # ensure xm > xo
                p0 = [xo_guess, xm_guess, 0.1]
                bounds = ([1e-9, 1e-9, 1e-9], [np.inf, np.inf, np.inf])
                popt, _ = curve_fit(self.logistic, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                # Check for xm > xo after fit
                if popt[1] <= popt[0]:
                     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.")
                     # Optionally, try to re-fit with constraints or return None
                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
                # Estimate lag phase: time until significant growth starts
                # This is a rough estimate, could be improved
                lag_guess = time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 and np.any(np.gradient(biomass) > 1e-6) else time[0]
                p0 = [xm_guess, um_guess, lag_guess]
                bounds = ([1e-9, 1e-9, 0], [np.inf, np.inf, max(time) if len(time)>0 else 100]) # Lag can't be negative
                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] # Ks is like a time shift
                p0 = [Xm_guess, um_guess, Ks_guess]
                # Ks could be negative if growth starts before t=0 effectively
                bounds = ([1e-9, 1e-9, -np.inf], [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)
            else:
                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

            # Ensure R2 calculation is robust against constant biomass data (already checked, but good practice)
            ss_res = np.sum((biomass - y_pred) ** 2)
            ss_tot = np.sum((biomass - np.mean(biomass)) ** 2)
            if ss_tot == 0: # Avoid division by zero if biomass is constant
                self.r2['biomass'] = 1.0 if ss_res == 0 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'] = {} # Clear params on failure
            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: # Check if biomass_params_dict is empty
            print(f"Error en fit_substrate_{self.model_type}: Parámetros de biomasa no disponibles.")
            return None
        try:
            # Extract parameters based on model type
            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']]
            else:
                return None

            so_guess = substrate[0] if len(substrate) > 0 else 1.0
            p_guess = 0.1 # Yxs inverse (biomass/substrate)
            q_guess = 0.01 # Maintenance
            p0 = [so_guess, p_guess, q_guess]
            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf]) # Parameters should be non-negative

            # Use a lambda that directly takes the parameter values list
            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 == 0 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} (probablemente no se pudo ajustar): {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']]
            else:
                return None

            po_guess = product[0] if len(product) > 0 else 0.0
            alpha_guess = 0.1 # Growth-associated
            beta_guess = 0.01 # Non-growth-associated
            p0 = [po_guess, alpha_guess, beta_guess]
            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf]) # Parameters should be non-negative

            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 == 0 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} (probablemente no se pudo ajustar): {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):
        if time is None or len(time) == 0:
             return np.array([0]) # Default if time is not set
        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):
        X, S, P = y # X, S, P current values

        # Biomass growth (dX/dt)
        if model_type == 'logistic':
            # biomass_params_list for logistic: [xo, xm, um]
            # logistic_diff expects X (current biomass), t, params=[xo, xm, um]
            # However, logistic_diff is defined as um * X * (1 - X / xm) using current X
            # For ODE integration, xo is part of initial conditions, not the rate params.
            # So, params for logistic_diff should be [xm, um] effectively, if xo is handled by y[0]
            # Let's assume biomass_params_list = [xo, xm, um] from fitted model
            # The differential equation for logistic growth does not directly use xo.
            # It's um * X * (1 - X / Xm). So params = [Xm, um]
            # For consistency, we pass all fitted params and let the diff eq select.
            dXdt = self.logistic_diff(X, t, biomass_params_list)
        elif model_type == 'gompertz':
            # biomass_params_list for gompertz: [xm, um, lag]
            dXdt = self.gompertz_diff(X, t, biomass_params_list)
        elif model_type == 'moser':
            # biomass_params_list for moser: [Xm, um, Ks]
            dXdt = self.moser_diff(X, t, biomass_params_list)
        else:
            dXdt = 0.0 # Should not happen if model_type is validated

        # Substrate consumption (dS/dt)
        # substrate_params_list: [so, p, q]
        # dS/dt = -p * dX/dt - q * X
        # so is initial substrate, not used in differential form directly
        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

        # Product formation (dP/dt)
        # product_params_list: [po, alpha, beta]
        # dP/dt = alpha * dX/dt + beta * X
        # po is initial product, not used in differential form directly
        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):
        # Use experimental data for initial conditions if params are not available or to be robust
        X0_exp = biomass[0] if len(biomass) > 0 else 0
        S0_exp = substrate[0] if len(substrate) > 0 else 0
        P0_exp = product[0] if len(product) > 0 else 0

        # Initial biomass (X0)
        if 'biomass' in self.params and self.params['biomass']:
            if self.model_type == 'logistic':
                # xo is the initial biomass in logistic model definition
                X0 = self.params['biomass'].get('xo', X0_exp)
            elif self.model_type == 'gompertz':
                # X(t=0) for Gompertz
                xm = self.params['biomass'].get('xm', 1)
                um = self.params['biomass'].get('um', 0.1)
                lag = self.params['biomass'].get('lag', 0)
                X0 = self.gompertz(0, xm, um, lag) # Calculate X at t=0
                if np.isnan(X0): X0 = X0_exp # Fallback if calculation fails
            elif self.model_type == 'moser':
                # X(t=0) for Moser
                Xm_param = self.params['biomass'].get('Xm', 1)
                um_param = self.params['biomass'].get('um', 0.1)
                Ks_param = self.params['biomass'].get('Ks', 0)
                X0 = self.moser(0, Xm_param, um_param, Ks_param) # Calculate X at t=0
                if np.isnan(X0): X0 = X0_exp # Fallback
            else:
                X0 = X0_exp # Fallback for unknown model type
        else:
            X0 = X0_exp

        # Initial substrate (S0)
        if 'substrate' in self.params and self.params['substrate']:
            # so is the initial substrate in the Luedeking-Piret substrate model
            S0 = self.params['substrate'].get('so', S0_exp)
        else:
            S0 = S0_exp

        # Initial product (P0)
        if 'product' in self.params and self.params['product']:
            # po is the initial product in the Luedeking-Piret product model
            P0 = self.params['product'].get('po', P0_exp)
        else:
            P0 = P0_exp
            
        # Ensure initial conditions are not NaN
        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 '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 : # Check if time is valid
            print("Tiempo no válido para resolver EDOs.")
            return None, None, None, np.array([])


        # Prepare biomass_params_list for ODE system
        # These are the parameters *of the differential equation itself*, not necessarily all fitted constants
        # For logistic_diff: expects [xm, um] effectively if xo is IC.
        # But our diff functions are written to take the full fitted set.
        if self.model_type == 'logistic':
            # self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
            biomass_params_list = [self.params['biomass']['xo'], self.params['biomass']['xm'], self.params['biomass']['um']]
        elif self.model_type == 'gompertz':
            # self.params['biomass'] = {'xm': popt[0], 'um': popt[1], 'lag': popt[2]}
            biomass_params_list = [self.params['biomass']['xm'], self.params['biomass']['um'], self.params['biomass']['lag']]
        elif self.model_type == 'moser':
            # self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'Ks': popt[2]}
            biomass_params_list = [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']]
        else:
            print(f"Tipo de modelo de biomasa desconocido: {self.model_type}")
            return None, None, None, time

        # Prepare substrate_params_list for ODE system
        # self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
        # The ODE system uses p and q. so is an initial condition.
        substrate_params_list = [
            self.params.get('substrate', {}).get('so', 0),
            self.params.get('substrate', {}).get('p', 0),
            self.params.get('substrate', {}).get('q', 0)
        ]

        # Prepare product_params_list for ODE system
        # self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
        # The ODE system uses alpha and beta. po is an initial condition.
        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, substrate_params_list, product_params_list, self.model_type),
                         rtol=1e-6, atol=1e-6) # Added tolerances
        except Exception as e:
            print(f"Error al resolver EDOs con odeint: {e}")
            # Try with lsoda if default fails (often more robust)
            try:
                print("Intentando con método 'lsoda'...")
                sol = odeint(self.system, initial_conditions, time_fine,
                             args=(biomass_params_list, 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, y_pred_substrate, y_pred_product,
                     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):

        if y_pred_biomass is None and not use_differential: # If using differential, biomass params might still be there
             print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} y no se usan EDO. Omitiendo figura.")
             return None
        if use_differential and ('biomass' not in self.params or not self.params['biomass']):
            print(f"Se solicitó usar EDO pero no hay parámetros de biomasa para {experiment_name}. Omitiendo EDO.")
            use_differential = False # Fallback to curve_fit results if any


        # Set axis labels with defaults
        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 # Default time grid

        if use_differential and 'biomass' in self.params and self.params['biomass']:
            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 # Use the fine time grid for ODE results
            else:
                print(f"Fallo al resolver EDOs para {experiment_name}, usando resultados de curve_fit si existen.")
                # Keep original y_pred_biomass etc. from curve_fit if ODE failed
                time_to_plot = time # Revert to original time if ODE failed
        else:
             # If not using differential or if biomass params are missing, use the curve_fit time
             # For curve_fit, the predictions are already on the original 'time' grid.
             # If we want smoother curve_fit lines, we need to evaluate them on a finer grid too.
            if not use_differential and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                time_fine_curvefit = self.generate_fine_time_grid(time)
                if time_fine_curvefit is not None and len(time_fine_curvefit)>0:
                    biomass_params_values = list(self.params['biomass'].values())
                    y_pred_biomass_fine = self.biomass_model(time_fine_curvefit, *biomass_params_values)

                    if 'substrate' in self.params and self.params['substrate']:
                        substrate_params_values = list(self.params['substrate'].values())
                        y_pred_substrate_fine = self.substrate(time_fine_curvefit, *substrate_params_values, biomass_params_values)
                    else:
                        y_pred_substrate_fine = np.full_like(time_fine_curvefit, np.nan)


                    if 'product' in self.params and self.params['product']:
                        product_params_values = list(self.params['product'].values())
                        y_pred_product_fine = self.product(time_fine_curvefit, *product_params_values, biomass_params_values)
                    else:
                        y_pred_product_fine = np.full_like(time_fine_curvefit, np.nan)

                    # Check if any fine predictions are all NaN
                    if not np.all(np.isnan(y_pred_biomass_fine)):
                        y_pred_biomass = y_pred_biomass_fine
                        time_to_plot = time_fine_curvefit # Update time_to_plot only if biomass_fine is valid
                    if not np.all(np.isnan(y_pred_substrate_fine)):
                        y_pred_substrate = y_pred_substrate_fine
                    if not np.all(np.isnan(y_pred_product_fine)):
                        y_pred_product = y_pred_product_fine


        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))
        ]

        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):
            # Plot experimental data if available and not all NaN
            if data_exp is not None and len(data_exp) > 0 and not np.all(np.isnan(data_exp)):
                if 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=5, elinewidth=1, 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')


            # Plot model prediction if available and not all NaN
            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)
            elif idx == 0 and y_pred_biomass is None: # Special message if biomass model failed
                 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 is None) or (idx == 2 and y_pred_product is None) :
                if 'biomass' not in self.params or not self.params['biomass']:
                     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:
                     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 all(isinstance(v, (int, float)) and np.isfinite(v) for v in params_dict.values()):
                param_text = '\n'.join([f"{k} = {v:.3g}" for k, v in params_dict.items()]) # Use .3g for general format
                # Ensure R2 and RMSE are finite for display
                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)
                    # Adjust x position to be truly outside
                    fig.subplots_adjust(right=0.75) # Make space for the annotation
                    ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
                                xytext=(10,0), textcoords='offset points', # Small offset for padding
                                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 and not params_dict :
                 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]) # Adjust rect to accommodate suptitle

        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, y_pred_substrate, y_pred_product,
                              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):

        # Similar checks as in plot_results
        if y_pred_biomass is None and not use_differential:
            print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} (combinado). Omitiendo figura.")
            return None
        if use_differential and ('biomass' not in self.params or not self.params['biomass']):
            print(f"Se solicitó usar EDO (combinado) pero no hay parámetros de biomasa para {experiment_name}. Omitiendo EDO.")
            use_differential = False


        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 # Default

        if use_differential and 'biomass' in self.params and self.params['biomass']:
            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 si existen.")
                time_to_plot = time # Revert
        else: # Smoother curve_fit lines if not using ODE
            if not use_differential and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                time_fine_curvefit = self.generate_fine_time_grid(time)
                if time_fine_curvefit is not None and len(time_fine_curvefit)>0:
                    biomass_params_values = list(self.params['biomass'].values())
                    y_pred_biomass_fine = self.biomass_model(time_fine_curvefit, *biomass_params_values)

                    if 'substrate' in self.params and self.params['substrate']:
                        substrate_params_values = list(self.params['substrate'].values())
                        y_pred_substrate_fine = self.substrate(time_fine_curvefit, *substrate_params_values, biomass_params_values)
                    else:
                        y_pred_substrate_fine = np.full_like(time_fine_curvefit, np.nan)

                    if 'product' in self.params and self.params['product']:
                        product_params_values = list(self.params['product'].values())
                        y_pred_product_fine = self.product(time_fine_curvefit, *product_params_values, biomass_params_values)
                    else:
                        y_pred_product_fine = np.full_like(time_fine_curvefit, np.nan)
                    
                    if not np.all(np.isnan(y_pred_biomass_fine)):
                        y_pred_biomass = y_pred_biomass_fine
                        time_to_plot = time_fine_curvefit
                    if not np.all(np.isnan(y_pred_substrate_fine)):
                        y_pred_substrate = y_pred_substrate_fine
                    if not np.all(np.isnan(y_pred_product_fine)):
                        y_pred_product = y_pred_product_fine


        fig, ax1 = plt.subplots(figsize=(12, 7)) # Increased width for params possibly outside
        fig.suptitle(f'{experiment_name} ({self.model_type.capitalize()})', fontsize=16)

        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 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=3, elinewidth=1, 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 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=3, elinewidth=1, 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)) # Adjusted position for third axis
        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 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=3, elinewidth=1, 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'])

        # Collect legends from all axes
        lines_labels_collect = []
        for ax_current in [ax1, ax2, ax3]:
            h, l = ax_current.get_legend_handles_labels()
            if h: # Only add if there are handles/labels
                 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])] # careful with empty h,l
            # Filter out duplicate labels for legend, keeping order
            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 all(isinstance(v, (int, float)) and np.isfinite(v) for v in params_dict.values()):
                    param_text = '\n'.join([f"  {k} = {v:.3g}" for k, v in params_dict.items()])
                    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: # Some params but maybe not all finite, or model failed
                     texts_to_display.append(f"{label}:\n  Parámetros no válidos o N/A")
                # else: No params for this category, skip.


            total_text = "\n\n".join(texts_to_display)

            if total_text: # Only display if there's something to show
                if params_position == 'outside right':
                    fig.subplots_adjust(right=0.70) # Make more space for text outside
                    bbox_props = dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.7)
                    # Annotate relative to the figure, not a specific axis, for true "outside"
                    fig.text(0.72, 0.5, total_text, transform=fig.transFigure,
                             verticalalignment='center', horizontalalignment='left',
                             bbox=bbox_props, 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={'boxstyle':'round,pad=0.3', 'facecolor':'wheat', 'alpha':0.7}, fontsize=8)

        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
        # For combined plot, ensure right spine of ax3 is visible if params are outside
        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, # These are not used in current model fit, but kept for future
                     mode, style, line_color, point_color, line_style, marker_style,
                     show_legend, show_params, use_differential, maxfev_val,
                     axis_labels_dict): # Added axis_labels_dict

    if file is None:
        return [], pd.DataFrame(), "Por favor, sube un archivo Excel."

    try:
        # Try reading with multi-index header first
        try:
            xls = pd.ExcelFile(file.name)
        except AttributeError: # If file is already a path (e.g. from tempfile)
            xls = pd.ExcelFile(file)

        sheet_names = xls.sheet_names
        if not sheet_names:
            return [], pd.DataFrame(), "El archivo Excel está vacío o no contiene hojas."

    except Exception as e:
        return [], pd.DataFrame(), f"Error al leer el archivo Excel: {e}"

    figures = []
    comparison_data = []
    experiment_counter = 0
    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}' está vacía.")
                continue
            # Basic validation of expected column structure (Tiempo, Biomasa, etc.)
            if not any(col_level2 == 'Tiempo' for _, col_level2 in df.columns):
                all_plot_messages.append(f"Hoja '{sheet_name}' no contiene la subcolumna 'Tiempo'. Saltando hoja.")
                continue

        except Exception as e:
            all_plot_messages.append(f"Error al leer la hoja '{sheet_name}': {e}. Saltando hoja.")
            continue

        # Create a dummy model instance to process data for this sheet
        model_dummy_for_sheet = BioprocessModel()
        try:
            model_dummy_for_sheet.process_data(df)
        except ValueError as e: # Catch specific errors from process_data
            all_plot_messages.append(f"Error procesando datos de la hoja '{sheet_name}': {e}. Saltando hoja.")
            continue

        time_exp_full = model_dummy_for_sheet.time # Time from the first experiment in the sheet usually

        # INDEPENDENT MODE: Iterate through top-level columns (experiments)
        if mode == 'independent':
            # df.columns.levels[0] gives unique top-level column names
            # However, direct iteration over df.columns.levels[0] might not align if some experiments are missing certain sub-columns.
            # A safer way is to group by the first level of the column index.
            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 = df[exp_col_name] # DataFrame for the current experiment

                try:
                    time_exp = exp_df['Tiempo'].dropna().values
                    # Ensure data is 1D array of numbers, handle potential errors
                    biomass_exp = exp_df['Biomasa'].dropna().astype(float).values if 'Biomasa' in exp_df else np.array([])
                    substrate_exp = exp_df['Sustrato'].dropna().astype(float).values if 'Sustrato' in exp_df else np.array([])
                    product_exp = exp_df['Producto'].dropna().astype(float).values if 'Producto' in exp_df else np.array([])

                    if len(time_exp) == 0:
                         all_plot_messages.append(f"No hay datos de tiempo para {current_experiment_name}. Saltando.")
                         continue
                    if len(biomass_exp) == 0 : # Biomass is essential for fitting other models
                         all_plot_messages.append(f"No hay datos de biomasa para {current_experiment_name}. Saltando modelos para este experimento.")
                         # Still add to comparison_data as NaN
                         for model_type_iter in model_types_selected:
                            comparison_data.append({
                                'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
                                **{f'R² {comp}': np.nan for comp in ['Biomasa', 'Sustrato', 'Producto']},
                                **{f'RMSE {comp}': np.nan for comp in ['Biomasa', 'Sustrato', 'Producto']}
                            })
                         continue


                except KeyError as e:
                    all_plot_messages.append(f"Faltan columnas (Tiempo, Biomasa, Sustrato, Producto) en '{current_experiment_name}': {e}. Saltando.")
                    continue
                except Exception as e_data:
                    all_plot_messages.append(f"Error extrayendo datos para '{current_experiment_name}': {e_data}. Saltando.")
                    continue


                # For independent mode, standard deviation is not applicable unless replicates are within this exp_df
                # Assuming exp_df contains single replicate data here. If it has sub-columns for replicates,
                # then mean/std should be calculated here. For now, pass None for std.
                biomass_std_exp, substrate_std_exp, product_std_exp = None, None, None

                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 and 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 de biomasa falló para {current_experiment_name} con modelo {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,
                        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 # Pass axis_labels_dict
                    )
                    if fig: figures.append(fig)
                experiment_counter +=1


        # AVERAGE or COMBINADO MODE: Use processed data (mean, std) from model_dummy_for_sheet
        elif mode in ['average', 'combinado']:
            current_experiment_name = f"{current_experiment_name_base} - Promedio"

            # Data from model_dummy_for_sheet (which processed the whole sheet)
            # These are lists, take the last appended (corresponds to current sheet)
            time_avg = model_dummy_for_sheet.time # Should be consistent across sheet
            biomass_avg = model_dummy_for_sheet.dataxp[-1] if model_dummy_for_sheet.dataxp else np.array([])
            substrate_avg = model_dummy_for_sheet.datasp[-1] if model_dummy_for_sheet.datasp else np.array([])
            product_avg = model_dummy_for_sheet.datapp[-1] if model_dummy_for_sheet.datapp 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 len(time_avg) == 0:
                all_plot_messages.append(f"No hay datos de tiempo para el promedio de '{sheet_name}'. Saltando.")
                continue
            if len(biomass_avg) == 0:
                all_plot_messages.append(f"No hay datos de biomasa promedio para '{sheet_name}'. Saltando modelos.")
                for model_type_iter in model_types_selected:
                    comparison_data.append({
                        'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
                        **{f'R² {comp}': np.nan for comp in ['Biomasa', 'Sustrato', 'Producto']},
                        **{f'RMSE {comp}': np.nan for comp in ['Biomasa', 'Sustrato', 'Producto']}
                    })
                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 de biomasa promedio falló para {current_experiment_name} con modelo {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,
                    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 # Pass axis_labels_dict
                )
                if fig: figures.append(fig)
            experiment_counter +=1


    comparison_df = pd.DataFrame(comparison_data)
    if not comparison_df.empty:
        # Ensure numeric columns for sorting, coerce errors to NaN
        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] # Sort R² descending, RMSE ascending
        ).reset_index(drop=True)
    else:
        comparison_df_sorted = pd.DataFrame(columns=[ # Ensure empty DF has correct 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


def create_interface():
    with gr.Blocks(theme=gr.themes.Soft()) as demo:
        gr.Markdown("# Modelos Cinéticos de Bioprocesos")
        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.

        **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.
        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.
        """)
        gr.Markdown(r"""
        ## Ecuaciones Diferenciales Utilizadas

        **Biomasa:**

        - Logístico:
        $$
        \frac{dX}{dt} = \mu_m X\left(1 - \frac{X}{X_m}\right)
        $$
        Solución integral: $X(t) = \frac{X_0 \exp(\mu_m t)}{1 - (X_0/X_m)(1 - \exp(\mu_m t))}$

        - Gompertz (Modificado):
        $$
        X(t) = X_m \exp\left(-\exp\left(\left(\frac{\mu_m e}{X_m}\right)(\text{lag}-t)+1\right)\right)
        $$
        Ecuación diferencial:
        $$
        \frac{dX}{dt} = X(t)\left(\frac{\mu_m e}{X_m}\right)\exp\left(\left(\frac{\mu_m e}{X_m}\right)(\text{lag}-t)+1\right)
        $$

        - Moser (simplificado, asumiendo $S \gg K_s$ o crecimiento no limitado por sustrato modelado explícitamente aquí):
        $$
        X(t)=X_m(1-e^{-\mu_m(t-K_s)})
        $$
        Ecuación diferencial (forma simplificada, no estándar de Moser que depende de S):
        $$
        \frac{dX}{dt}=\mu_m(X_m - X)
        $$

        **Sustrato y Producto (Luedeking-Piret):**
        $$
        \frac{dS}{dt} = -p \frac{dX}{dt} - q X \quad \Rightarrow \quad S(t) = S_0 - p(X(t)-X_0) - q \int_0^t X(\tau)d\tau
        $$

        $$
        \frac{dP}{dt} = \alpha \frac{dX}{dt} + \beta X \quad \Rightarrow \quad P(t) = P_0 + \alpha(X(t)-X_0) + \beta \int_0^t X(\tau)d\tau
        $$
        Donde $X_0, S_0, P_0$ son las concentraciones iniciales.
        Parámetros:
        - $X_m$: Máxima concentración de biomasa.
        - $\mu_m$: Máxima tasa de crecimiento específico.
        - $X_0$: Concentración inicial de biomasa.
        - $\text{lag}$: Duración de la fase de latencia.
        - $K_s$: Constante de afinidad (en el modelo de Moser simplificado, actúa como un tiempo de retardo).
        - $p$: Coeficiente de rendimiento de biomasa a partir de sustrato (asociado al crecimiento). $1/Y_{X/S}^{crecimiento}$.
        - $q$: Coeficiente de mantenimiento. $m_S$.
        - $\alpha$: Coeficiente de formación de producto asociado al crecimiento. $Y_{P/X}^{crecimiento}$.
        - $\beta$: Coeficiente de formación de producto no asociado al crecimiento. $m_P$.
        """)

        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=False):
            model_types_selected = gr.CheckboxGroup(
                choices=["logistic", "gompertz", "moser"],
                label="Tipo(s) de Modelo de Biomasa",
                value=["logistic"]
            )
            use_differential = gr.Checkbox(label="Usar Ecuaciones Diferenciales para Graficar (experimental)", value=False,
                                           info="Si se marca, las curvas se generan resolviendo las EDOs. Si no, por ajuste directo de las formas integradas.")
            maxfev_input = gr.Number(label="maxfev (Máx. evaluaciones para el ajuste)", value=50000, minimum=1000, step=1000)
            experiment_names_str = 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'."
            )
        with gr.Accordion("Configuración de Gráficos", open=False):
            with gr.Row():
                with gr.Column(scale=1):
                    legend_position = gr.Radio(
                        choices=["upper left", "upper right", "lower left", "lower right", "best"],
                        label="Posición de Leyenda", value="best"
                    )
                    show_legend = gr.Checkbox(label="Mostrar Leyenda", value=True)
                with gr.Column(scale=1):
                    params_position = gr.Radio(
                        choices=["upper left", "upper right", "lower left", "lower right", "outside right"],
                        label="Posición de Parámetros", value="upper right"
                    )
                    show_params = gr.Checkbox(label="Mostrar Parámetros", value=True)

            with gr.Row():
                style_dropdown = gr.Dropdown(choices=['white', 'dark', 'whitegrid', 'darkgrid', 'ticks'],
                                             label="Estilo de Gráfico (Seaborn)", value='whitegrid')
                line_color_picker = gr.ColorPicker(label="Color de Línea (Modelo)", value='#0072B2') # Seaborn blue
                point_color_picker = gr.ColorPicker(label="Color de Puntos (Datos)", value='#D55E00') # Seaborn orange

            with gr.Row():
                line_style_dropdown = gr.Dropdown(choices=['-', '--', '-.', ':'], label="Estilo de Línea", value='-')
                marker_style_dropdown = gr.Dropdown(choices=['o', 's', '^', 'v', 'D', 'x', '+', '*'],
                                                    label="Estilo de Marcador (Puntos)", value='o')
            with gr.Row():
                x_axis_label_input = gr.Textbox(label="Título Eje X", value="Tiempo (h)", placeholder="Tiempo (unidades)")
                biomass_axis_label_input = gr.Textbox(label="Título Eje Y (Biomasa)", value="Biomasa (g/L)", placeholder="Biomasa (unidades)")
            with gr.Row():
                substrate_axis_label_input = gr.Textbox(label="Título Eje Y (Sustrato)", value="Sustrato (g/L)", placeholder="Sustrato (unidades)")
                product_axis_label_input = gr.Textbox(label="Título Eje Y (Producto)", value="Producto (g/L)", placeholder="Producto (unidades)")


        # Lower/Upper bounds are not currently used by the curve_fit in BioprocessModel,
        # but kept here for potential future implementation.
        with gr.Accordion("Configuración Avanzada de Ajuste (No implementado aún)", open=False):
            with gr.Row():
                lower_bounds_str = gr.Textbox(label="Lower Bounds (no usado actualmente)", lines=3)
                upper_bounds_str = gr.Textbox(label="Upper Bounds (no usado actualmente)", lines=3)

        simulate_btn = gr.Button("Simular y Graficar", variant="primary")
        
        status_message = gr.Textbox(label="Estado del Procesamiento", interactive=False)

        output_gallery = gr.Gallery(label="Resultados Gráficos", columns=[2,1], height='auto', object_fit="contain")
        # Change the gr.Dataframe initialization
        output_table = gr.Dataframe(
            label="Tabla Comparativa de Modelos (Ordenada por R² Biomasa Descendente)",
            headers=["Experimento", "Modelo", "R² Biomasa", "RMSE Biomasa",
                    "R² Sustrato", "RMSE Sustrato", "R² Producto", "RMSE Producto"],
            interactive=False, wrap=True # Remove height=400
        )

        state_df = 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):
            if file is None:
                return [], pd.DataFrame(), "Error: Por favor, sube un archivo Excel."

            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: # Check if no models are selected
                 return [], pd.DataFrame(), "Error: Por favor, selecciona al menos un tipo de modelo de biomasa."


            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 # Pass the constructed dictionary
            )
            return figures, comparison_df, message, comparison_df # Pass df to state too

        simulate_btn.click(
            fn=run_simulation_interface,
            inputs=[
                file_input, legend_position, params_position, model_types_selected, mode, experiment_names_str,
                lower_bounds_str, upper_bounds_str, style_dropdown,
                line_color_picker, point_color_picker, line_style_dropdown, marker_style_dropdown,
                show_legend, show_params, use_differential, maxfev_input,
                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input # New axis label inputs
            ],
            outputs=[output_gallery, output_table, status_message, state_df]
        )

        def export_excel_interface(df_to_export):
            if df_to_export is None or df_to_export.empty:
                # Create a temporary empty file to satisfy Gradio's file output expectation
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
                     tmp.write(b"No hay datos para exportar.")
                     return tmp.name # Return path to this dummy file
                # Alternatively, raise an error or return a specific message if Gradio handles None better
                # For now, returning a dummy file path is safer.

            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:
                # print(f"Error al exportar a Excel: {e}")
                with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
                     tmp.write(f"Error al exportar a Excel: {e}".encode())
                     return tmp.name


        export_btn = gr.Button("Exportar Tabla a Excel")
        download_file_output = gr.File(label="Descargar archivo Excel", interactive=False)

        export_btn.click(
            fn=export_excel_interface,
            inputs=state_df, # Get the DataFrame from the state
            outputs=download_file_output
        )
        
        gr.Examples(
            examples=[
                [None, "best", "upper right", ["logistic"], "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)"]
            ],
            inputs=[
                file_input, legend_position, params_position, model_types_selected, mode, experiment_names_str,
                lower_bounds_str, upper_bounds_str, style_dropdown,
                line_color_picker, point_color_picker, line_style_dropdown, marker_style_dropdown,
                show_legend, show_params, use_differential, maxfev_input,
                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input
            ],
            label="Ejemplo de Configuración (subir archivo manualmente)"
        )


    return demo

if __name__ == '__main__':
    # For local execution without explicit share=True, Gradio might choose a local URL.
    # share=True is useful for Colab or when needing external access.
    # For robust execution, explicitly manage the server if needed.
    # Check if running in a Google Colab environment
    try:
        import google.colab
        IN_COLAB = True
    except:
        IN_COLAB = False

    demo_instance = create_interface()
    # demo_instance.launch(share=IN_COLAB) # Share only if in Colab, otherwise local
    demo_instance.launch(share=True) # Force share for testing purposes