package com.borjabolufer.elevate.ui.fragments;

import android.animation.ObjectAnimator;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.navigation.NavController;
import androidx.navigation.Navigation;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import com.borjabolufer.elevate.LoginActivity;
import com.borjabolufer.elevate.MainActivity;
import com.borjabolufer.elevate.PreguntasActivity;
import com.borjabolufer.elevate.R;
import com.borjabolufer.elevate.model.Usuario;
import com.borjabolufer.elevate.model.UsuarioDbHelper;
import com.borjabolufer.elevate.model.UsuarioEntity;
import com.borjabolufer.elevate.utils.ChatGptApi;
import com.borjabolufer.elevate.utils.PasswordUtils;
import com.borjabolufer.elevate.utils.PlanActualizadoDialog;

import org.json.JSONException;

import java.util.ArrayList;
import java.util.List;

public class LoadingPlanFragment extends Fragment {

    private static final String ARG_USUARIO = "usuario";
    private static final String ARG_NOMBRE_USUARIO = "nombre_usuario";
    private static final String ARG_CONTRASENA_USUARIO = "contrasena_usuario";
    private static final String ARG_ES_REGENERACION = "es_regeneracion";
    private static final String TAG = "LoadingPlanFragment";

      
    private ImageView loadingIcon;
    private ProgressBar progressBar;
    private TextView progressText;
    private TextView statusText;
    private RecyclerView logRecyclerView;
    private LogAdapter logAdapter;

      
    private Usuario usuario;
    private String nombreUsuario;
    private String contrasenaUsuario;
    private boolean esRegeneracion = false;
    private List<LogItem> logItems;
    private Handler handler;
    private int currentProgress = 0;
    private int currentLogStep = 0;

      
    private final String[] logMessages = {
            "🔍 Analizando tu perfil fitness...",
            "📊 Calculando tu tasa metabólica basal (TMB)...",
            "🎯 Definiendo objetivos personalizados...",
            "💪 Seleccionando ejercicios para tu nivel...",
            "🏋️ Creando rutina de calentamiento dinámico...",
            "⚡ Diseñando ejercicios principales...",
            "🧘 Configurando rutina de enfriamiento...",
            "🥗 Planificando tu menú nutricional...",
            "🍎 Calculando macronutrientes necesarios...",
            "📱 Seleccionando recetas saludables...",
            "⏰ Optimizando horarios de comida...",
            "💧 Configurando hidratación diaria...",
            "😴 Estableciendo recomendaciones de descanso...",
            "📦 Evaluando compatibilidad de alimentos...",
            "🔄 Ajustando proporciones de entrenamiento...",
            "📆 Distribuyendo días de ejercicio y descanso...",
            "🧠 Analizando patrones de comportamiento previos...",
            "📈 Comparando métricas con otros usuarios similares...",
            "📚 Revisando literatura científica reciente...",
            "🧮 Recalculando parámetros por coherencia...",
            "⚙️ Verificando integridad del plan...",
            "💡 Incorporando sugerencias inteligentes...",
            "🎯 Refinando los objetivos establecidos...",
            "🔗 Integrando plan de ejercicios y nutrición...",
            "✨ Aplicando algoritmos de personalización avanzada...",
            "🔐 Encriptando tus datos de forma segura...",
            "📤 Subiendo tu configuración a la nube...",
            "📥 Sincronizando con tu perfil...",
            "📂 Generando informe detallado...",
            "✅ Finalizando y guardando tu plan personalizado..."
    };

    private final int[] logDurations = {
            1500, 2000, 1800, 2200, 1600, 2500, 1400, 2000,
            1700, 1900, 1300, 1200, 1400, 1800, 1600, 2100,
            1900, 2300, 1800, 1400, 1500, 1700, 1600, 2400,
            1100, 1200, 1400, 1300, 2000, 1800
    };

      
    public static LoadingPlanFragment newInstance(Usuario usuario, String nombreUsuario, String contrasenaUsuario) {
        LoadingPlanFragment fragment = new LoadingPlanFragment();
        Bundle args = new Bundle();
        args.putSerializable(ARG_USUARIO, usuario);
        args.putString(ARG_NOMBRE_USUARIO, nombreUsuario);
        args.putString(ARG_CONTRASENA_USUARIO, contrasenaUsuario);
        args.putBoolean(ARG_ES_REGENERACION, false);
        fragment.setArguments(args);
        return fragment;
    }

      
    public static LoadingPlanFragment newInstanceRegeneration(Usuario usuario, String nombreUsuario) {
        LoadingPlanFragment fragment = new LoadingPlanFragment();
        Bundle args = new Bundle();
        args.putSerializable(ARG_USUARIO, usuario);
        args.putString(ARG_NOMBRE_USUARIO, nombreUsuario);
        args.putString(ARG_CONTRASENA_USUARIO, "regeneration");
        args.putBoolean(ARG_ES_REGENERACION, true);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            usuario = (Usuario) getArguments().getSerializable(ARG_USUARIO);
            nombreUsuario = getArguments().getString(ARG_NOMBRE_USUARIO);
            contrasenaUsuario = getArguments().getString(ARG_CONTRASENA_USUARIO);
            esRegeneracion = getArguments().getBoolean(ARG_ES_REGENERACION, false);
        }

        handler = new Handler();
        logItems = new ArrayList<>();

        Log.d(TAG, "LoadingPlanFragment creado - Es regeneración: " + esRegeneracion);
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_loading_plan, container, false);
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

          
        try {
            FragmentManager fm = requireActivity().getSupportFragmentManager();

              
            for (int i = 0; i < fm.getBackStackEntryCount(); i++) {
                FragmentManager.BackStackEntry entry = fm.getBackStackEntryAt(i);
                if (entry.getName() != null && entry.getName().contains("loading")) {
                      
                    fm.popBackStackImmediate(entry.getId(), FragmentManager.POP_BACK_STACK_INCLUSIVE);
                    break;
                }
            }
        } catch (Exception e) {
            Log.w(TAG, "Error limpiando back stack en onViewCreated", e);
        }

        initViews(view);
        setupRecyclerView();
        startLoadingAnimation();
        startLogSimulation();
        generatePlan();
    }

    private void autodestruirse() {
        try {
            if (isAdded() && getActivity() != null) {
                getActivity().runOnUiThread(() -> {
                    try {
                          
                        FragmentManager fm = requireActivity().getSupportFragmentManager();
                        fm.beginTransaction()
                                .remove(LoadingPlanFragment.this)
                                .commitNowAllowingStateLoss();

                    } catch (Exception e) {
                        Log.e(TAG, "Error en autodestrucción", e);
                    }
                });
            }
        } catch (Exception e) {
            Log.e(TAG, "Error general en autodestruirse", e);
        }
    }
    private void initViews(View view) {
        loadingIcon = view.findViewById(R.id.loadingIcon);
        progressBar = view.findViewById(R.id.progressBar);
        progressText = view.findViewById(R.id.progressText);
        statusText = view.findViewById(R.id.statusText);
        logRecyclerView = view.findViewById(R.id.logRecyclerView);
    }

    private void setupRecyclerView() {
        logAdapter = new LogAdapter(logItems);
        logRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        logRecyclerView.setAdapter(logAdapter);
    }

    private void startLoadingAnimation() {
          
        RotateAnimation rotateAnimation = new RotateAnimation(
                0f, 360f,
                Animation.RELATIVE_TO_SELF, 0.5f,
                Animation.RELATIVE_TO_SELF, 0.5f
        );
        rotateAnimation.setDuration(2000);
        rotateAnimation.setRepeatCount(Animation.INFINITE);
        rotateAnimation.setInterpolator(new LinearInterpolator());
        loadingIcon.startAnimation(rotateAnimation);

          
        if (esRegeneracion) {
            statusText.setText("Regenerando tu plan personalizado...");
        } else {
            statusText.setText("Creando tu plan personalizado...");
        }
    }

    private void startLogSimulation() {
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                if (currentLogStep < logMessages.length && isAdded()) {
                    addLogMessage(logMessages[currentLogStep]);
                    updateProgress();

                    currentLogStep++;

                    if (currentLogStep < logMessages.length) {
                          
                        int delay = logDurations[currentLogStep - 1];
                        handler.postDelayed(this, delay);
                    }
                }
            }
        }, 1000);   
    }

    private void addLogMessage(String message) {
          
        if (Looper.myLooper() == Looper.getMainLooper()) {
              
            addLogMessageInternal(message);
        } else {
              
            runOnUiThreadSafe(() -> addLogMessageInternal(message));
        }
    }

    private void addLogMessageInternal(String message) {
        if (!isAdded() || getContext() == null) {
            Log.w(TAG, "Fragment no está adjunto, no se puede actualizar UI");
            return;
        }

        try {
            LogItem logItem = new LogItem(message, System.currentTimeMillis());
            logItems.add(logItem);

            if (logAdapter != null) {
                logAdapter.notifyItemInserted(logItems.size() - 1);

                if (logRecyclerView != null) {
                    logRecyclerView.scrollToPosition(logItems.size() - 1);
                }
            }
        } catch (Exception e) {
            Log.e(TAG, "Error al actualizar log: " + e.getMessage());
        }
    }

    private void updateProgress() {
        runOnUiThreadSafe(() -> {
            currentProgress = (currentLogStep * 100) / logMessages.length;

            if (progressBar != null && progressText != null && statusText != null) {
                  
                ObjectAnimator progressAnimator = ObjectAnimator.ofInt(progressBar, "progress", progressBar.getProgress(), currentProgress);
                progressAnimator.setDuration(500);
                progressAnimator.start();

                progressText.setText(currentProgress + "%");

                  
                if (currentProgress < 30) {
                    statusText.setText(esRegeneracion ? "Reanalyzando tu perfil..." : "Analizando tu perfil...");
                } else if (currentProgress < 60) {
                    statusText.setText(esRegeneracion ? "Actualizando rutinas..." : "Creando rutinas personalizadas...");
                } else if (currentProgress < 90) {
                    statusText.setText(esRegeneracion ? "Rediseñando plan nutricional..." : "Diseñando plan nutricional...");
                } else {
                    statusText.setText(esRegeneracion ? "Finalizando actualización..." : "Finalizando personalización...");
                }
            }
        });
    }

    private void generatePlan() {
        if (usuario == null || nombreUsuario == null) {
            showError("Datos de usuario incompletos");
            return;
        }

          
        String prompt = buildPrompt();

          
        if (!esRegeneracion && contrasenaUsuario != null && !contrasenaUsuario.equals("regeneration")) {
            Log.d(TAG, "Creando nuevo usuario en BD");
            crearUsuarioEnBD();
        } else {
            Log.d(TAG, "Regenerando plan para usuario existente");
        }

          
        try {
            ChatGptApi.enviarPrompt(prompt, new ChatGptApi.ChatGptCallback() {
                @Override
                public void onSuccess(String jsonResponse) {
                    if (getActivity() != null) {
                        getActivity().runOnUiThread(() -> {
                              
                            new Thread(() -> {
                                UsuarioDbHelper dbHelper = new UsuarioDbHelper(requireContext());
                                int updated = dbHelper.updatePlanJson(nombreUsuario, jsonResponse);
                                Log.d(TAG, "Filas actualizadas: " + updated);

                                if (updated > 0) {
                                    boolean saved = dbHelper.guardarPlanJsonEnArchivo(getContext(), nombreUsuario);
                                    Log.d(TAG, "Plan guardado en archivo: " + saved);
                                }

                                if (getActivity() != null) {
                                    getActivity().runOnUiThread(() -> {
                                          
                                        handler.postDelayed(() -> {
                                            if (isAdded()) {
                                                addLogMessage(esRegeneracion ? "🎉 ¡Tu plan ha sido actualizado!" : "🎉 ¡Tu plan está listo!");
                                                finishLoading();
                                            }
                                        }, 2000);
                                    });
                                }
                            }).start();
                        });
                    }
                }

                @Override
                public void onFailure(String error) {
                    if (getActivity() != null) {
                        getActivity().runOnUiThread(() -> {
                            if (isAdded()) {
                                addLogMessage("❌ Error: " + error);
                                showError("Error al generar el plan: " + error);
                            }
                        });
                    }
                }
            });
        } catch (JSONException e) {
            if (isAdded()) {
                showError("Error en configuración: " + e.getMessage());
            }
        }
    }

    private void runOnUiThreadSafe(Runnable action) {
        if (getActivity() != null) {
            getActivity().runOnUiThread(() -> {
                if (isAdded() && getContext() != null) {
                    action.run();
                }
            });
        }
    }

    private void crearUsuarioEnBD() {
        new Thread(() -> {
            UsuarioDbHelper dbHelper = new UsuarioDbHelper(requireContext());
            if (!dbHelper.checkUserEmailExists(nombreUsuario)) {
                  
                UsuarioEntity usuarioEntity = new UsuarioEntity();
                usuarioEntity.setEmail(nombreUsuario);   

                  
                String nombreCompleto = nombreUsuario;   
                if (getActivity() instanceof PreguntasActivity) {
                    PreguntasActivity preguntasActivity = (PreguntasActivity) getActivity();
                    String nombre = preguntasActivity.getNombreCompleto();
                    if (nombre != null && !nombre.trim().isEmpty()) {
                        nombreCompleto = nombre;
                    }
                }

                usuarioEntity.setNombreCompleto(nombreCompleto);
                usuarioEntity.setPasswordHash(PasswordUtils.hashPassword(contrasenaUsuario));
                usuarioEntity.setSexo(usuario.getSexo() != null ? usuario.getSexo().getSexo() : "");
                usuarioEntity.setEdad(usuario.getEdad() != null ? usuario.getEdad().getEdad() : 0);
                usuarioEntity.setObjetivo(usuario.getObjetivo() != null ? usuario.getObjetivo().getObjetivo() : "");
                usuarioEntity.setDiasEntrenamiento(usuario.getDias() != null ? usuario.getDias().getCantidad() : 0);
                usuarioEntity.setIntentensidad(usuario.getIntensidad() != null ? usuario.getIntensidad().getIntensidad() : "");
                usuarioEntity.setPeso(usuario.getPeso() != null ? usuario.getPeso().getPeso() : 0.0);
                usuarioEntity.setAltura(usuario.getAltura() != null ? usuario.getAltura().getAltura() : 0.0);

                  
                long result = dbHelper.insertarUsuarioCompleto(usuarioEntity);
                Log.d(TAG, "Usuario insertado con ID: " + result + ", Nombre: " + nombreCompleto + ", Email: " + nombreUsuario);
            } else {
                Log.d(TAG, "Usuario ya existe: " + nombreUsuario);
            }
        }).start();
    }

    @NonNull
    private String buildPrompt() {
        String tipoOperacion = esRegeneracion ? "REGENERA y ACTUALIZA" : "Genera";

          
        int diasEntrenamiento = usuario.getDias().getCantidad();
        String distribucionDias = generarDistribucionDias(diasEntrenamiento);
        String explicacionDias = generarExplicacionDias(diasEntrenamiento);

        return "Actúa como un entrenador personal certificado y nutricionista experto. " + tipoOperacion + " un plan semanal personalizado en formato JSON ESTRICTO y FUNCIONAL a partir de los siguientes datos personales:" +

                "\n\n👤 DATOS DEL USUARIO:" +
                "\n- Edad: " + usuario.getEdad().getEdad() + " años" +
                "\n- Sexo: " + usuario.getSexo().getSexo() +
                "\n- Altura: " + usuario.getAltura().getAltura() + " cm" +
                "\n- Peso: " + usuario.getPeso().getPeso() + " kg" +
                "\n- Objetivo: " + usuario.getObjetivo().getObjetivo() +
                "\n- Intensidad: " + usuario.getIntensidad().getIntensidad() +
                "\n- Días de entrenamiento por semana: " + diasEntrenamiento +

                "\n\n🗓️ DISTRIBUCIÓN OBLIGATORIA DE ENTRENAMIENTOS:" +
                explicacionDias +
                "\n" + distribucionDias +

                "\n\n📌 FORMATO DE RESPUESTA:" +
                "\n- SOLO un JSON válido, funcional y parseable" +
                "\n- SIN explicaciones, comentarios ni formato markdown" +
                "\n- Claves en minúsculas, sin tildes ni espacios" +
                "\n- Estructura JSON igual a la del siguiente ejemplo (entrenamiento y dieta separados por día):" +

                "\n\n🎯 ESTRUCTURA ESPERADA:" +
                "\n{" +
                "\n  \"semana\": [" +
                "\n    {" +
                "\n      \"dia\": \"Lunes\"," +
                "\n      \"entrenamiento\": {" +
                "\n        \"calentamiento\": [    ]," +
                "\n        \"ejercicios_principales\": [    ]," +
                "\n        \"enfriamiento\": [    ]" +
                "\n      }," +
                "\n      \"dieta\": {" +
                "\n        \"desayuno\": {    }," +
                "\n        \"comida\": {    }," +
                "\n        \"cena\": {    }," +
                "\n        \"snack\": {    }" +
                "\n      }" +
                "\n    }," +
                "\n    {" +
                "\n      \"dia\": \"Martes\"," +
                "\n      \"entrenamiento\": null," +
                "\n      \"dieta\": {" +
                "\n        \"desayuno\": {    }," +
                "\n        \"comida\": {    }," +
                "\n        \"cena\": {    }," +
                "\n        \"snack\": {    }" +
                "\n      }" +
                "\n    }," +
                "\n      " +
                "\n  ]" +
                "\n}" +

                "\n\n🧠 DETALLES OBLIGATORIOS EN CADA SECCIÓN:" +

                "\n\n📍 ENTRENAMIENTO:" +
                "\n- EXACTAMENTE " + diasEntrenamiento + " días con entrenamiento según la distribución especificada" +
                "\n- Los días SIN entrenamiento deben tener 'entrenamiento': null" +
                "\n- calentamiento, ejercicios_principales y enfriamiento por día de entrenamiento" +
                "\n- en los descansos msotrar valores como estos 90s no 90 segundos" +
                "\n- los videos en los calentamientos y enfriamientos seran link a yotube donde busce en el buscador el nombre del ejercicio. En los ejercicios_principales si que tendras que buscar directamente un video de ese ejercicio" +
                "\n- Campos por ejercicio: nombre, descripcion, series, repeticiones, descanso, video_url" +
                "\n- ejercicios_principales tendrá entre 8 a 12, calentamiento de 2 a 4 y de enfriamiento de 2 a 4" +
                "\n  La descripcion que sea mas detallada sobre todo en calentamiento y enfriamientos"+


                "\n\n📍 DIETA (obligatoria todos los días):" +
                "\n- TODOS los 7 días deben tener dieta completa" +
                "\n- Cada día: desayuno, comida, cena, snack" +
                "\n- Campos por comida: nombre_del_plato, ingredientes (array), receta, valor_nutricional (con calorias, proteinas, carbohidratos, grasas), video_url" +

                "\n\n⚠️ CRÍTICO - DISTRIBUCIÓN DE DÍAS:" +
                "\n- RESPETAR EXACTAMENTE la distribución especificada" +
                "\n- NO crear más días de entrenamiento de los indicados" +
                "\n- Los días de descanso son parte fundamental del plan" +

                "\n\n⚠️ IMPORTANTE:" +
                "\n- Usa YouTube en español para los video_url" +
                "\n- No repitas ejercicios ni platos durante la semana" +
                "\n- Adecúa calorías y tipos de ejercicios al objetivo e intensidad" +
                (esRegeneracion ? "\n- Este es un plan ACTUALIZADO, asegúrate de que sea diferente al anterior" : "") +

                "\n\n🚫 NO INCLUYAS ningún texto adicional. Solo responde con un JSON válido exactamente con la estructura descrita.";
    }

      
    private String generarDistribucionDias(int diasEntrenamiento) {
        StringBuilder distribucion = new StringBuilder();

        switch (diasEntrenamiento) {
            case 1:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: DESCANSO\n");
                distribucion.append("- Miércoles: DESCANSO\n");
                distribucion.append("- Jueves: DESCANSO\n");
                distribucion.append("- Viernes: DESCANSO\n");
                distribucion.append("- Sábado: DESCANSO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 2:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: DESCANSO\n");
                distribucion.append("- Miércoles: DESCANSO\n");
                distribucion.append("- Jueves: ENTRENAMIENTO\n");
                distribucion.append("- Viernes: DESCANSO\n");
                distribucion.append("- Sábado: DESCANSO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 3:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: DESCANSO\n");
                distribucion.append("- Miércoles: ENTRENAMIENTO\n");
                distribucion.append("- Jueves: DESCANSO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: DESCANSO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 4:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: ENTRENAMIENTO\n");
                distribucion.append("- Miércoles: DESCANSO\n");
                distribucion.append("- Jueves: ENTRENAMIENTO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: DESCANSO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 5:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: ENTRENAMIENTO\n");
                distribucion.append("- Miércoles: ENTRENAMIENTO\n");
                distribucion.append("- Jueves: DESCANSO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: ENTRENAMIENTO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 6:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: ENTRENAMIENTO\n");
                distribucion.append("- Miércoles: ENTRENAMIENTO\n");
                distribucion.append("- Jueves: ENTRENAMIENTO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: ENTRENAMIENTO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;

            case 7:
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: ENTRENAMIENTO\n");
                distribucion.append("- Miércoles: ENTRENAMIENTO\n");
                distribucion.append("- Jueves: ENTRENAMIENTO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: ENTRENAMIENTO\n");
                distribucion.append("- Domingo: ENTRENAMIENTO");
                break;

            default:
                  
                distribucion.append("- Lunes: ENTRENAMIENTO\n");
                distribucion.append("- Martes: DESCANSO\n");
                distribucion.append("- Miércoles: ENTRENAMIENTO\n");
                distribucion.append("- Jueves: DESCANSO\n");
                distribucion.append("- Viernes: ENTRENAMIENTO\n");
                distribucion.append("- Sábado: DESCANSO\n");
                distribucion.append("- Domingo: DESCANSO");
                break;
        }

        return distribucion.toString();
    }

      
    private String generarExplicacionDias(int diasEntrenamiento) {
        switch (diasEntrenamiento) {
            case 1:
                return "\n- SOLO 1 día de entrenamiento (recomendado para principiantes absolutos)";
            case 2:
                return "\n- SOLO 2 días de entrenamiento con descanso intermedio (principiantes)";
            case 3:
                return "\n- SOLO 3 días de entrenamiento con descanso intermedio (nivel básico)";
            case 4:
                return "\n- SOLO 4 días de entrenamiento con 2 días consecutivos y descanso de fin de semana";
            case 5:
                return "\n- SOLO 5 días de entrenamiento con 1 día de descanso intermedio y domingo libre";
            case 6:
                return "\n- SOLO 6 días de entrenamiento con domingo de descanso completo";
            case 7:
                return "\n- 7 días de entrenamiento (atletas avanzados con variación de intensidad)";
            default:
                return "\n- SOLO 3 días de entrenamiento con descanso intermedio (configuración por defecto)";
        }
    }

      
    private void finishLoading() {
          
        progressBar.setProgress(100);
        progressText.setText("100%");
        statusText.setText(esRegeneracion ? "¡Plan actualizado exitosamente!" : "¡Plan generado exitosamente!");

          
        loadingIcon.clearAnimation();

          
        handler.postDelayed(() -> {
            if (isAdded()) {
                if (esRegeneracion) {
                      
                    volverAlHomeLimpio();
                } else {
                      
                    irAlLogin();
                }
            }
        }, 2000);
    }

      
    private void volverAlHomeLimpio() {
        try {
            if (getActivity() != null) {
                getActivity().runOnUiThread(() -> {
                    try {
                          
                        mostrarPopupPlanActualizado();

                    } catch (Exception e) {
                        Log.e(TAG, "Error mostrando popup", e);
                          
                        navegarSinPopup();
                    }
                });
            }
        } catch (Exception e) {
            Log.e(TAG, "Error general en volverAlHomeLimpio", e);
        }
    }

    private void mostrarPopupPlanActualizado() {
        try {
              
            PlanActualizadoDialog dialog = PlanActualizadoDialog.newInstance(esRegeneracion);

              
            dialog.setOnDialogCloseListener(() -> {
                Log.d(TAG, "Popup cerrado, iniciando navegación");
                navegarDespuesDelPopup();
            });

              
            if (getActivity() != null && !getActivity().isFinishing()) {
                dialog.show(requireActivity().getSupportFragmentManager(), "plan_actualizado_dialog");
                Log.d(TAG, "Popup mostrado exitosamente");
            } else {
                  
                navegarSinPopup();
            }

        } catch (Exception e) {
            Log.e(TAG, "Error mostrando popup", e);
            navegarSinPopup();
        }
    }

    private void navegarDespuesDelPopup() {
        try {
              
            new Handler(Looper.getMainLooper()).postDelayed(() -> {
                if (getActivity() != null && isAdded()) {

                      
                    FragmentManager fm = requireActivity().getSupportFragmentManager();
                    fm.beginTransaction()
                            .remove(LoadingPlanFragment.this)
                            .commitNowAllowingStateLoss();

                      
                    while (fm.getBackStackEntryCount() > 0) {
                        String entryName = fm.getBackStackEntryAt(fm.getBackStackEntryCount() - 1).getName();
                        if (entryName != null && entryName.contains("loading")) {
                            fm.popBackStackImmediate();
                        } else {
                            break;
                        }
                    }

                      
                    if (getActivity() instanceof MainActivity) {
                        ((MainActivity) getActivity()).navegarA(R.id.nav_home);
                    }

                    Log.d(TAG, "Navegación post-popup completada");
                }
            }, 300);   

        } catch (Exception e) {
            Log.e(TAG, "Error en navegación post-popup", e);
            navegarSinPopup();
        }
    }

    private void navegarSinPopup() {
        try {
            if (getActivity() != null) {
                getActivity().runOnUiThread(() -> {
                    try {
                        FragmentManager fm = requireActivity().getSupportFragmentManager();
                        fm.beginTransaction()
                                .remove(LoadingPlanFragment.this)
                                .commitNowAllowingStateLoss();

                        if (getActivity() instanceof MainActivity) {
                            ((MainActivity) getActivity()).navegarA(R.id.nav_home);
                        }

                          
                        Toast.makeText(getActivity(), "¡Plan actualizado correctamente!", Toast.LENGTH_LONG).show();

                    } catch (Exception e) {
                        Log.e(TAG, "Error en navegación fallback", e);
                        if (getActivity() != null) {
                            getActivity().recreate();
                        }
                    }
                });
            }
        } catch (Exception e) {
            Log.e(TAG, "Error general navegación sin popup", e);
        }
    }

    private void irAlLogin() {
        Intent intent = new Intent(requireContext(), LoginActivity.class);
        intent.putExtra("plan_generated", true);
        intent.putExtra("user_email", nombreUsuario);
        startActivity(intent);
        requireActivity().finish();
    }

    private void showError(String error) {
        runOnUiThreadSafe(() -> {
            addLogMessageInternal("❌ " + error);

            if (statusText != null) {
                statusText.setText("Error en la generación");
            }

            handler.postDelayed(() -> {
                if (isAdded()) {
                    if (esRegeneracion) {
                          
                        Toast.makeText(getContext(), "Error al regenerar plan. Inténtalo más tarde.", Toast.LENGTH_LONG).show();
                        requireActivity().onBackPressed();
                    } else {
                          
                        requireActivity().onBackPressed();
                    }
                }
            }, 3000);
        });
    }

    @Override
    public void onDestroy() {
        super.onDestroy();

          
        if (handler != null) {
            handler.removeCallbacksAndMessages(null);
        }
    }

      
    public static class LogItem {
        private String message;
        private long timestamp;

        public LogItem(String message, long timestamp) {
            this.message = message;
            this.timestamp = timestamp;
        }

        public String getMessage() { return message; }
        public long getTimestamp() { return timestamp; }
    }

      
    private static class LogAdapter extends RecyclerView.Adapter<LogAdapter.LogViewHolder> {
        private List<LogItem> logItems;

        public LogAdapter(List<LogItem> logItems) {
            this.logItems = logItems;
        }

        @NonNull
        @Override
        public LogViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            View view = LayoutInflater.from(parent.getContext())
                    .inflate(R.layout.item_log, parent, false);
            return new LogViewHolder(view);
        }

        @Override
        public void onBindViewHolder(@NonNull LogViewHolder holder, int position) {
            LogItem item = logItems.get(position);
            holder.bind(item, position);
        }

        @Override
        public int getItemCount() {
            return logItems.size();
        }

        static class LogViewHolder extends RecyclerView.ViewHolder {
            TextView messageText;
            TextView timestampText;
            View statusIndicator;

            public LogViewHolder(@NonNull View itemView) {
                super(itemView);
                messageText = itemView.findViewById(R.id.messageText);
                timestampText = itemView.findViewById(R.id.timestampText);
                statusIndicator = itemView.findViewById(R.id.statusIndicator);
            }

            public void bind(LogItem item, int position) {
                messageText.setText(item.getMessage());

                  
                long seconds = (System.currentTimeMillis() - item.getTimestamp()) / 1000;
                timestampText.setText("+" + seconds + "s");

                  
                itemView.setAlpha(0f);
                itemView.animate()
                        .alpha(1f)
                        .setDuration(300)
                        .setStartDelay(100)
                        .start();
            }
        }
    }
}