horse_racing_analyzer.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <limits> // Necesario para std::numeric_limits
#include <string> // Necesario para std::string
#include <numeric> // For std::accumulate
#include <cmath>   // For std::abs
#include <utility> // For std::pair

// --- Constantes para el cálculo de probabilidad ---
const double PESO_VICTORIAS_PREVIAS = 35.0;
const double PESO_PROMEDIO_POSICION = 25.0;
const double PESO_PISTA_PREFERIDA = 15.0;
const double PESO_TIPO_CARRERA_PREFERIDA = 15.0;

const double BONUS_FORMA_EXCELENTE = 10.0;
const double BONUS_FORMA_BUENA = 5.0;
const double PENALIZACION_FORMA_MALA = -5.0;

const double UMBRAL_CUOTAS_MUY_FAVORITO = 2.5;
const double UMBRAL_CUOTAS_FAVORITO = 5.0;
const double UMBRAL_CUOTAS_MEDIO = 10.0;

const double BONUS_CUOTAS_MUY_FAVORITO = 10.0;
const double BONUS_CUOTAS_FAVORITO = 5.0;
const double BONUS_CUOTAS_MEDIO = 2.0;

const double PROBABILIDAD_MINIMA = 0.0;
const double PROBABILIDAD_MAXIMA = 100.0;

// Weights for historical analysis metrics
const double PESO_PROMEDIO_TIEMPO_RELATIVO = 10.0; // Max points for this factor
const double PESO_TENDENCIA_POSICION_400M = 5.0;  // Max points for this factor
const double PESO_TENDENCIA_POSICION_800M = 5.0;  // Max points for this factor

// Thresholds/multipliers for scoring these metrics
const double UMBRAL_TIEMPO_RELATIVO_BUENO = 1.0; // e.g., horse's time <= winner's time
const double UMBRAL_TIEMPO_RELATIVO_MALO = 1.05;  // e.g., horse's time > 5% slower than winner's
// const double MULTIPLICADOR_TENDENCIA_NEGATIVA = -1.0; // This was mentioned but not directly used in the chosen logic, so commenting out.

const double UMBRAL_PROBABILIDAD_SORPRESA = 50.0; // Max probability for a horse to be a "surprise" pick if it's 3rd

// Helper function to convert a string to lowercase
std::string toLower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c){ return std::tolower(c); });
    return s;
}

// Helper function to calculate the average of a vector of doubles
double calcularPromedio(const std::vector<double>& valores) {
    if (valores.empty()) {
        return 0.0;
    }
    double suma = std::accumulate(valores.begin(), valores.end(), 0.0);
    return suma / valores.size();
}

// Helper function to calculate linear slope for y values (x is implicit 0, 1, 2...)
double calcularPendienteLineal(const std::vector<int>& valores_y) {
    int n = valores_y.size();
    if (n < 2) { // Cannot calculate a slope with less than 2 points
        return 0.0;
    }

    double sum_x = 0.0, sum_y = 0.0, sum_xy = 0.0, sum_x_squared = 0.0;

    for (int i = 0; i < n; ++i) {
        double x_i = static_cast<double>(i);
        double y_i = static_cast<double>(valores_y[i]);

        sum_x += x_i;
        sum_y += y_i;
        sum_xy += x_i * y_i;
        sum_x_squared += x_i * x_i;
    }

    // Formula for slope m: (n * sum(xy) - sum(x) * sum(y)) / (n * sum(x^2) - (sum(x))^2)
    double denominador = (static_cast<double>(n) * sum_x_squared) - (sum_x * sum_x);

    if (denominador == 0) { // Avoid division by zero
        return 0.0;
    }

    return (static_cast<double>(n) * sum_xy - sum_x * sum_y) / denominador;
}

struct AnalisisHistorial {
    double promedio_tiempo_relativo;
    double tendencia_posicion_400m;
    double tendencia_posicion_800m;
    // Potentially add other metrics later if needed
};

AnalisisHistorial procesarHistorial(const std::vector<DatosCarreraPasada>& historial_carreras) {
    AnalisisHistorial resultados;
    resultados.promedio_tiempo_relativo = 0.0;
    resultados.tendencia_posicion_400m = 0.0;
    resultados.tendencia_posicion_800m = 0.0;

    if (historial_carreras.empty()) {
        return resultados; // Return default values if no history
    }

    std::vector<double> tiempos_relativos;
    std::vector<int> posiciones_400m_hist;
    std::vector<int> posiciones_800m_hist;

    for (const auto& carrera : historial_carreras) {
        if (carrera.tiempo_ganador_carrera > 0) { // Avoid division by zero
            tiempos_relativos.push_back(carrera.tiempo_ejemplar / carrera.tiempo_ganador_carrera);
        }
        posiciones_400m_hist.push_back(carrera.posicion_400m);
        posiciones_800m_hist.push_back(carrera.posicion_800m);
    }

    resultados.promedio_tiempo_relativo = calcularPromedio(tiempos_relativos);

    // Only calculate trend if there's enough data for a meaningful trend
    if (historial_carreras.size() >= 2) {
        resultados.tendencia_posicion_400m = calcularPendienteLineal(posiciones_400m_hist);
        resultados.tendencia_posicion_800m = calcularPendienteLineal(posiciones_800m_hist);
    }

    return resultados;
}

struct SeleccionCarrera {
    std::vector<std::pair<std::string, double>> posibles_ganadores; // To store name and probability
    std::pair<std::string, double> posible_sorpresa;
    bool sorpresa_encontrada;

    // Constructor to initialize
    SeleccionCarrera() : sorpresa_encontrada(false) {}
};

struct DatosCarreraPasada {
    double tiempo_ejemplar;
    double tiempo_ganador_carrera;
    int posicion_400m;
    int posicion_800m;
    int distancia_carrera;
    int posicion_final;
};

struct Ejemplar {
    std::string nombre;
    std::string fecha;
    std::string hipodromo_carrera; // Abreviatura del hipódromo y número de carrera actual
    std::string condiciones_terreno; // Condiciones del terreno de la carrera actual
    std::string tipo_carrera; // Tipo de carrera actual

    std::string tiempo_fraccionado;
    std::string tiempo_final;
    int posicion_final; // Posición en la carrera actual
    double distancia_puntero; // Distancia del puntero en la carrera actual
    std::string jinete;
    double peso_total;
    double cuotas; // Cuotas de apuesta iniciales/de mercado

    double probabilidad; // ¡Esta será calculada por el programa!

    // --- NUEVAS VARIABLES PARA EL CÁLCULO DE PROBABILIDAD (historial) ---
    int victorias_previas; // Número de victorias que ha tenido el ejemplar antes de esta carrera
    int carreras_corridas_previas; // Número total de carreras corridas antes de esta
    double promedio_posicion_previas; // Posición promedio en sus últimas carreras (ej. 1.5, 3.2)
    std::string pista_preferida; // Tipo de terreno en el que el ejemplar rinde mejor (ej. "Duro", "Blando")
    std::string tipo_carrera_preferida; // Tipo de carrera (por distancia o categoría) en la que rinde mejor (ej. "1200m", "Clásico")
    std::string forma_actual; // "Excelente", "Buena", "Regular", "Mala"
    std::vector<DatosCarreraPasada> historial_carreras; // Historial detallado de carreras pasadas
};

// Función de comparación para ordenar por posición final (1 = primero)
bool compararPorPosicion(const Ejemplar& a, const Ejemplar& b) {
    return a.posicion_final < b.posicion_final;
}

// Función de comparación para ordenar por probabilidad (descendente)
bool compararPorProbabilidad(const Ejemplar& a, const Ejemplar& b) {
    return a.probabilidad > b.probabilidad;
}

// Assumes SeleccionCarrera, Ejemplar, compararPorProbabilidad are defined
SeleccionCarrera realizarSeleccionTop3(const std::vector<Ejemplar>& ejemplares_carrera_const) {
    SeleccionCarrera seleccion;

    if (ejemplares_carrera_const.empty()) {
        return seleccion; // No horses, no selection
    }

    // Create a mutable copy for sorting
    std::vector<Ejemplar> ejemplares_carrera = ejemplares_carrera_const;

    std::sort(ejemplares_carrera.begin(), ejemplares_carrera.end(), compararPorProbabilidad);

    // Populate posibles_ganadores
    if (ejemplares_carrera.size() >= 1) {
        seleccion.posibles_ganadores.push_back({ejemplares_carrera[0].nombre, ejemplares_carrera[0].probabilidad});
    }
    if (ejemplares_carrera.size() >= 2) {
        seleccion.posibles_ganadores.push_back({ejemplares_carrera[1].nombre, ejemplares_carrera[1].probabilidad});
    }

    // Populate posible_sorpresa
    if (ejemplares_carrera.size() >= 3) {
        // Initial heuristic: 3rd horse is a surprise if its probability is below the threshold
        if (ejemplares_carrera[2].probabilidad < UMBRAL_PROBABILIDAD_SORPRESA) {
            seleccion.posible_sorpresa = {ejemplares_carrera[2].nombre, ejemplares_carrera[2].probabilidad};
            seleccion.sorpresa_encontrada = true;
        }
        // More complex logic could be added here: e.g., if 3rd horse is not a surprise,
        // scan further down for the first horse that meets surprise criteria.
        // For now, this simple heuristic is a starting point.
    }

    return seleccion;
}

// Función para calcular la probabilidad de ganar de un ejemplar
// Se basa en los datos del ejemplar y las condiciones de la carrera actual
double calcularProbabilidad(const Ejemplar& e,
                            int totalEjemplaresEnCarrera,
                            const std::string& condiciones_terreno_actual,
                            const std::string& tipo_carrera_actual) {

    double probabilidadCalculada = 0.0; // Base inicial para la probabilidad

    // --- Factores de Ponderación (estos valores son heurísticos y pueden ajustarse) ---

    // 1. Historial de Victorias y Experiencia (Peso significativo)
    if (e.carreras_corridas_previas > 0) {
        // Cuanto mayor sea el porcentaje de victorias, mayor la probabilidad
        probabilidadCalculada += (static_cast<double>(e.victorias_previas) / e.carreras_corridas_previas) * PESO_VICTORIAS_PREVIAS;
    }

    // 2. Posición Promedio en Carreras Previas (Peso medio-alto)
    // Un promedio de posición bajo (cercano a 1) es muy bueno.
    // Asumimos que un promedio de 1.0 es excelente, y si es peor, el impacto disminuye.
    if (e.promedio_posicion_previas > 0) {
        // Escala inversa: un promedio de 1 da el máximo bonus, un promedio igual al total de ejemplares da poco.
        probabilidadCalculada += ((totalEjemplaresEnCarrera - e.promedio_posicion_previas + 1.0) / totalEjemplaresEnCarrera) * PESO_PROMEDIO_POSICION;
    }

    // 3. Preferencias de Terreno (Peso medio)
    // Si la pista preferida del ejemplar coincide con las condiciones actuales de la carrera
    if (e.pista_preferida == condiciones_terreno_actual) {
        probabilidadCalculada += PESO_PISTA_PREFERIDA;
    }

    // 4. Preferencias de Tipo/Distancia de Carrera (Peso medio)
    // Si el tipo de carrera preferida coincide con el actual
    if (e.tipo_carrera_preferida == tipo_carrera_actual) { // Assuming tipo_carrera_preferida is also normalized if needed
        probabilidadCalculada += PESO_TIPO_CARRERA_PREFERIDA;
    }

    // 5. Forma Actual (Peso moderado)
    // e.forma_actual is already lowercase from input
    if (e.forma_actual == "excelente") {
        probabilidadCalculada += BONUS_FORMA_EXCELENTE;
    } else if (e.forma_actual == "buena") {
        probabilidadCalculada += BONUS_FORMA_BUENA;
    } else if (e.forma_actual == "regular") {
        // Sin cambio o ligera penalización si lo deseas
    } else if (e.forma_actual == "mala") {
        probabilidadCalculada += PENALIZACION_FORMA_MALA; // Penalización por mala forma
    }

    // 6. Cuotas (Peso moderado - reflejan la opinión del mercado)
    // Las cuotas más bajas (más favoritas) deberían dar mayor probabilidad.
    // Mapeamos cuotas a puntos de probabilidad.
    if (e.cuotas > 0) {
        if (e.cuotas <= UMBRAL_CUOTAS_MUY_FAVORITO) { // Muy favorito
            probabilidadCalculada += BONUS_CUOTAS_MUY_FAVORITO;
        } else if (e.cuotas <= UMBRAL_CUOTAS_FAVORITO) { // Favorito
            probabilidadCalculada += BONUS_CUOTAS_FAVORITO;
        } else if (e.cuotas <= UMBRAL_CUOTAS_MEDIO) { // Medio
            probabilidadCalculada += BONUS_CUOTAS_MEDIO;
        }
        // Cuotas muy altas (más de UMBRAL_CUOTAS_MEDIO) no añaden mucho o nada
    }

    // --- 7. Análisis del Historial Detallado (NUEVO) ---
    AnalisisHistorial analisisHist = procesarHistorial(e.historial_carreras);
    if (!e.historial_carreras.empty()) { // Only apply if history exists
        // Score based on promedio_tiempo_relativo
        if (analisisHist.promedio_tiempo_relativo > 0) { // Ensure it was calculated
            if (analisisHist.promedio_tiempo_relativo <= UMBRAL_TIEMPO_RELATIVO_BUENO) {
                probabilidadCalculada += PESO_PROMEDIO_TIEMPO_RELATIVO;
            } else if (analisisHist.promedio_tiempo_relativo >= UMBRAL_TIEMPO_RELATIVO_MALO) {
                probabilidadCalculada -= PESO_PROMEDIO_TIEMPO_RELATIVO;
            }
            // No complex interpolation for now, simple tiered approach.
        }

        // Score based on tendencia_posicion_400m
        // Negative slope is good (improving position), positive is bad.
        if (analisisHist.tendencia_posicion_400m < 0) { // Improving
            probabilidadCalculada += PESO_TENDENCIA_POSICION_400M * std::min(1.0, std::abs(analisisHist.tendencia_posicion_400m)); // Proportional, capped
        } else if (analisisHist.tendencia_posicion_400m > 0) { // Worsening
            probabilidadCalculada -= PESO_TENDENCIA_POSICION_400M * std::min(1.0, analisisHist.tendencia_posicion_400m); // Proportional, capped
        }

        // Score based on tendencia_posicion_800m
        if (analisisHist.tendencia_posicion_800m < 0) { // Improving
            probabilidadCalculada += PESO_TENDENCIA_POSICION_800M * std::min(1.0, std::abs(analisisHist.tendencia_posicion_800m));
        } else if (analisisHist.tendencia_posicion_800m > 0) { // Worsening
            probabilidadCalculada -= PESO_TENDENCIA_POSICION_800M * std::min(1.0, analisisHist.tendencia_posicion_800m);
        }
    }

    // Asegurarse de que la probabilidad final esté en el rango de 0 a 100
    if (probabilidadCalculada < PROBABILIDAD_MINIMA) probabilidadCalculada = PROBABILIDAD_MINIMA;
    if (probabilidadCalculada > PROBABILIDAD_MAXIMA) probabilidadCalculada = PROBABILIDAD_MAXIMA;

    return probabilidadCalculada;
}

// Función para analizar el desempeño de un ejemplar basándose en su probabilidad calculada y posición real
std::string analizarEjemplar(const Ejemplar& e, int totalEjemplares) {
    if (e.probabilidad >= 60.0 && e.posicion_final == 1) {
        return "Desempeño esperado (favorito ganó)";
    } else if (e.probabilidad < 40.0 && e.posicion_final == 1) {
        return "Sorpresa positiva (ganador inesperado con baja probabilidad)";
    } else if (e.probabilidad >= 60.0 && e.posicion_final > totalEjemplares / 2) {
        return "Desempeño por debajo de lo esperado (favorito falló)";
    } else if (e.probabilidad < 40.0 && e.posicion_final > totalEjemplares / 2) {
        return "Desempeño esperado (no era favorito y no ganó)";
    } else if (e.posicion_final >= 1 && e.posicion_final <= 3) {
        return "Buen desempeño (en los primeros tres lugares)";
    } else {
        return "Desempeño promedio o inferior";
    }
}

int main() {
    int numCarreras;
    std::cout << "Ingrese el número de carreras a registrar: ";
    while (!(std::cin >> numCarreras) || numCarreras <= 0) {
        std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para las carreras: ";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Limpiar el búfer

    std::ofstream archivo("resultados_carreras.txt", std::ios::app);
    if (!archivo) {
        std::cerr << "Error: No se pudo abrir el archivo 'resultados_carreras.txt' para guardar resultados.\n";
        return 1;
    }

    for (int c = 1; c <= numCarreras; ++c) {
        int numEjemplares;
        std::string condiciones_terreno_carrera_actual;
        std::string tipo_carrera_actual;

        std::cout << "\n--- Datos de la Carrera #" << c << " ---\n";
        std::cout << "Ingrese las condiciones del terreno para esta carrera (ej. Duro, Blando, Pesado): ";
        std::getline(std::cin, condiciones_terreno_carrera_actual);
        condiciones_terreno_carrera_actual = toLower(condiciones_terreno_carrera_actual);

        std::cout << "Ingrese el tipo/distancia de la carrera (ej. 1200m, Handicap, Clásico): ";
        std::getline(std::cin, tipo_carrera_actual);
        // tipo_carrera_actual could also be converted toLower if needed for comparisons

        std::cout << "Ingrese la cantidad de ejemplares que participaron: ";
        while (!(std::cin >> numEjemplares) || numEjemplares <= 0) {
            std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para los ejemplares: ";
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

        std::vector<Ejemplar> ejemplares(numEjemplares);

        for (int i = 0; i < numEjemplares; ++i) {
            std::cout << "\n--- Datos del Ejemplar #" << (i + 1) << " ---\n";
            std::cout << "Nombre del ejemplar: ";
            std::getline(std::cin, ejemplares[i].nombre);

            std::cout << "Fecha de la carrera (DD/MM/AAAA): ";
            std::getline(std::cin, ejemplares[i].fecha); // Fecha de la carrera actual

            std::cout << "Abreviatura del hipódromo y número de la carrera (ej. VAL-05): ";
            std::getline(std::cin, ejemplares[i].hipodromo_carrera);

            // Las condiciones del terreno y tipo de carrera para el ejemplar en esta carrera
            ejemplares[i].condiciones_terreno = condiciones_terreno_carrera_actual;
            ejemplares[i].tipo_carrera = tipo_carrera_actual;

            std::cout << "Tiempo fraccionado (ej. 23.4, 46.2): ";
            std::getline(std::cin, ejemplares[i].tiempo_fraccionado);

            std::cout << "Tiempo final (ej. 1:12.5): ";
            std::getline(std::cin, ejemplares[i].tiempo_final);

            std::cout << "Posición final en ESTA carrera: ";
            while (!(std::cin >> ejemplares[i].posicion_final) || ejemplares[i].posicion_final <= 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para la posición final: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Distancia del puntero en ESTA carrera (en cuerpos): ";
            while (!(std::cin >> ejemplares[i].distancia_puntero) || ejemplares[i].distancia_puntero < 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número no negativo para la distancia del puntero: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Nombre del jinete: ";
            std::getline(std::cin, ejemplares[i].jinete);

            std::cout << "Peso total (kg, incluido equipamiento): ";
            while (!(std::cin >> ejemplares[i].peso_total) || ejemplares[i].peso_total <= 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número positivo para el peso total: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Cuotas de apuesta iniciales/de mercado (ej. 2.50, 5.00): ";
            while (!(std::cin >> ejemplares[i].cuotas) || ejemplares[i].cuotas <= 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número positivo para las cuotas: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            // --- Solicitar datos de historial para el cálculo de probabilidad ---
            std::cout << "--- Historial del Ejemplar para Cálculo de Probabilidad ---\n";

            std::cout << "Número total de carreras corridas previamente: ";
            while (!(std::cin >> ejemplares[i].carreras_corridas_previas) || ejemplares[i].carreras_corridas_previas < 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número no negativo para las carreras corridas previamente: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Número de victorias previas: ";
            while (!(std::cin >> ejemplares[i].victorias_previas) || ejemplares[i].victorias_previas < 0 || ejemplares[i].victorias_previas > ejemplares[i].carreras_corridas_previas) {
                std::cout << "Entrada inválida. Por favor ingrese un número no negativo para las victorias previas (no puede ser mayor que las carreras corridas): ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Posición promedio en carreras previas (ej. 2.1, 5.0): ";
            while (!(std::cin >> ejemplares[i].promedio_posicion_previas) || ejemplares[i].promedio_posicion_previas <= 0) {
                std::cout << "Entrada inválida. Por favor ingrese un número positivo para la posición promedio previa: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            std::cout << "Pista preferida (ej. Duro, Blando, Sintética): ";
            std::getline(std::cin, ejemplares[i].pista_preferida);
            ejemplares[i].pista_preferida = toLower(ejemplares[i].pista_preferida);

            std::cout << "Tipo de carrera preferida (ej. 1200m, Clásico, Handicap): ";
            std::getline(std::cin, ejemplares[i].tipo_carrera_preferida);
            // ejemplares[i].tipo_carrera_preferida could also be converted toLower if needed

            std::cout << "Forma actual del ejemplar (Excelente, Buena, Regular, Mala): ";
            std::getline(std::cin, ejemplares[i].forma_actual);
            ejemplares[i].forma_actual = toLower(ejemplares[i].forma_actual);

            // --- Solicitar datos de carreras pasadas del ejemplar ---
            int numCarrerasPasadasEjemplar;
            std::cout << "\n--- Historial de Carreras Pasadas del Ejemplar #" << (i+1) << " ---\n";
            std::cout << "Ingrese el número de carreras pasadas a registrar para este ejemplar (0-6): ";
            while (!(std::cin >> numCarrerasPasadasEjemplar) || numCarrerasPasadasEjemplar < 0 || numCarrerasPasadasEjemplar > 6) {
                std::cout << "Entrada inválida. Por favor ingrese un número entero entre 0 y 6: ";
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            for (int j = 0; j < numCarrerasPasadasEjemplar; ++j) {
                DatosCarreraPasada carreraPasada;
                std::cout << "\n--- Datos de la Carrera Pasada #" << (j + 1) << " ---\n";

                std::cout << "Distancia de la carrera pasada (metros): ";
                while (!(std::cin >> carreraPasada.distancia_carrera) || carreraPasada.distancia_carrera <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para la distancia: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                std::cout << "Tiempo del ejemplar en la carrera pasada (segundos): ";
                while (!(std::cin >> carreraPasada.tiempo_ejemplar) || carreraPasada.tiempo_ejemplar <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número positivo para el tiempo del ejemplar: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                std::cout << "Tiempo del ganador de la carrera pasada (segundos): ";
                while (!(std::cin >> carreraPasada.tiempo_ganador_carrera) || carreraPasada.tiempo_ganador_carrera <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número positivo para el tiempo del ganador: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                // Adicionalmente, podríamos validar que tiempo_ejemplar >= tiempo_ganador_carrera si posicion_final > 1

                std::cout << "Posición del ejemplar a los 400m: ";
                while (!(std::cin >> carreraPasada.posicion_400m) || carreraPasada.posicion_400m <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para la posición a los 400m: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                std::cout << "Posición del ejemplar a los 800m: ";
                while (!(std::cin >> carreraPasada.posicion_800m) || carreraPasada.posicion_800m <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para la posición a los 800m: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                std::cout << "Posición final del ejemplar en la carrera pasada: ";
                while (!(std::cin >> carreraPasada.posicion_final) || carreraPasada.posicion_final <= 0) {
                    std::cout << "Entrada inválida. Por favor ingrese un número entero positivo para la posición final: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

                ejemplares[i].historial_carreras.push_back(carreraPasada);
            }

            // ¡Calcular la probabilidad aquí mismo, después de tener todos los datos!
            ejemplares[i].probabilidad = calcularProbabilidad(ejemplares[i], numEjemplares,
                                                              condiciones_terreno_carrera_actual,
                                                              tipo_carrera_actual);
        }

        // Mostrar y guardar resumen de datos ingresados y análisis
        std::cout << "\n--- Resumen de Datos Ingresados y Análisis de la Carrera #" << c << " ---\n";
        archivo << "\n--- Resumen de Datos Ingresados y Análisis de la Carrera #" << c << " ---\n";
        for (int i = 0; i < numEjemplares; ++i) {
            const Ejemplar& e = ejemplares[i];
            std::cout << "\nDetalle del Ejemplar #" << (i + 1) << ":\n";
            archivo << "\nDetalle del Ejemplar #" << (i + 1) << ":\n";
            std::cout << "Nombre: " << e.nombre << "\n";
            archivo << "Nombre: " << e.nombre << "\n";
            std::cout << "Fecha de Carrera: " << e.fecha << "\n";
            archivo << "Fecha de Carrera: " << e.fecha << "\n";
            std::cout << "Hipódromo y Carrera: " << e.hipodromo_carrera << "\n";
            archivo << "Hipódromo y Carrera: " << e.hipodromo_carrera << "\n";
            std::cout << "Condiciones Terreno Actual: " << e.condiciones_terreno << "\n";
            archivo << "Condiciones Terreno Actual: " << e.condiciones_terreno << "\n";
            std::cout << "Tipo de Carrera Actual: " << e.tipo_carrera << "\n";
            archivo << "Tipo de Carrera Actual: " << e.tipo_carrera << "\n";
            std::cout << "Tiempo Fraccionado: " << e.tiempo_fraccionado << "\n";
            archivo << "Tiempo Fraccionado: " << e.tiempo_fraccionado << "\n";
            std::cout << "Tiempo Final: " << e.tiempo_final << "\n";
            archivo << "Tiempo Final: " << e.tiempo_final << "\n";
            std::cout << "Posición Final: " << e.posicion_final << "\n";
            archivo << "Posición Final: " << e.posicion_final << "\n";
            std::cout << "Distancia del Puntero: " << e.distancia_puntero << "\n";
            archivo << "Distancia del Puntero: " << e.distancia_puntero << "\n";
            std::cout << "Jinete: " << e.jinete << "\n";
            archivo << "Jinete: " << e.jinete << "\n";
            std::cout << "Peso Total: " << e.peso_total << "\n";
            archivo << "Peso Total: " << e.peso_total << "\n";
            std::cout << "Cuotas de Apuesta: " << e.cuotas << "\n";
            archivo << "Cuotas de Apuesta: " << e.cuotas << "\n";

            // Datos de Historial
            std::cout << "Victorias Previas: " << e.victorias_previas << "\n";
            archivo << "Victorias Previas: " << e.victorias_previas << "\n";
            std::cout << "Carreras Corridas Previas: " << e.carreras_corridas_previas << "\n";
            archivo << "Carreras Corridas Previas: " << e.carreras_corridas_previas << "\n";
            std::cout << "Posición Promedio Previa: " << e.promedio_posicion_previas << "\n";
            archivo << "Posición Promedio Previa: " << e.promedio_posicion_previas << "\n";
            std::cout << "Pista Preferida: " << e.pista_preferida << "\n";
            archivo << "Pista Preferida: " << e.pista_preferida << "\n";
            std::cout << "Tipo de Carrera Preferida: " << e.tipo_carrera_preferida << "\n";
            archivo << "Tipo de Carrera Preferida: " << e.tipo_carrera_preferida << "\n";
            std::cout << "Forma Actual: " << e.forma_actual << "\n";
            archivo << "Forma Actual: " << e.forma_actual << "\n";

            // Mostrar Historial de Carreras Pasadas
            if (!e.historial_carreras.empty()) {
                std::cout << "Historial de Carreras Pasadas:\n";
                archivo << "Historial de Carreras Pasadas:\n";
                for (size_t j = 0; j < e.historial_carreras.size(); ++j) {
                    const DatosCarreraPasada& cp = e.historial_carreras[j];
                    std::cout << "  Carrera Pasada #" << (j + 1) << ":\n";
                    archivo << "  Carrera Pasada #" << (j + 1) << ":\n";
                    std::cout << "    Distancia: " << cp.distancia_carrera << "m\n";
                    archivo << "    Distancia: " << cp.distancia_carrera << "m\n";
                    std::cout << "    Tiempo Ejemplar: " << cp.tiempo_ejemplar << "s\n";
                    archivo << "    Tiempo Ejemplar: " << cp.tiempo_ejemplar << "s\n";
                    std::cout << "    Tiempo Ganador: " << cp.tiempo_ganador_carrera << "s\n";
                    archivo << "    Tiempo Ganador: " << cp.tiempo_ganador_carrera << "s\n";
                    std::cout << "    Posición a 400m: " << cp.posicion_400m << "\n";
                    archivo << "    Posición a 400m: " << cp.posicion_400m << "\n";
                    std::cout << "    Posición a 800m: " << cp.posicion_800m << "\n";
                    archivo << "    Posición a 800m: " << cp.posicion_800m << "\n";
                    std::cout << "    Posición Final: " << cp.posicion_final << "\n";
                    archivo << "    Posición Final: " << cp.posicion_final << "\n";
                }
            }

            // Probabilidad Calculada y Análisis de Desempeño
            std::cout << "Probabilidad Calculada: " << e.probabilidad << "%\n";
            archivo << "Probabilidad Calculada: " << e.probabilidad << "%\n";
            std::string analisis = analizarEjemplar(e, numEjemplares);
            std::cout << "Análisis de Desempeño: " << analisis << "\n";
            archivo << "Análisis de Desempeño: " << analisis << "\n";
        }

        // Ordenar el vector de ejemplares por su posición final (1 = primero) para mostrar los resultados de la carrera
        std::sort(ejemplares.begin(), ejemplares.end(), compararPorPosicion);

        std::cout << "\n--- Resultados de la Carrera #" << c << " (Ordenados por Posición Final) ---\n";
        archivo << "\n--- Resultados de la Carrera #" << c << " (Ordenados por Posición Final) ---\n";

        if (!ejemplares.empty()) {
            std::cout << "Ganador: " << ejemplares[0].nombre << " (Probabilidad Calculada: " << ejemplares[0].probabilidad << "%)\n";
            archivo << "Ganador: " << ejemplares[0].nombre << " (Probabilidad Calculada: " << ejemplares[0].probabilidad << "%)\n";
        }

        if (ejemplares.size() >= 2) {
            std::cout << "Segundo lugar: " << ejemplares[1].nombre << " (Probabilidad Calculada: " << ejemplares[1].probabilidad << "%)\n";
            archivo << "Segundo lugar: " << ejemplares[1].nombre << " (Probabilidad Calculada: " << ejemplares[1].probabilidad << "%)\n";
        }

        if (ejemplares.size() >= 3) {
            std::cout << "Tercer lugar: " << ejemplares[2].nombre << " (Probabilidad Calculada: " << ejemplares[2].probabilidad << "%)\n";
            archivo << "Tercer lugar: " << ejemplares[2].nombre << " (Probabilidad Calculada: " << ejemplares[2].probabilidad << "%)\n";
        }

        // Identificar si el ganador fue una sorpresa (baja probabilidad calculada)
        if (!ejemplares.empty() && ejemplares[0].probabilidad < 40.0) {
            std::cout << "¡El ganador fue una sorpresa! " << ejemplares[0].nombre << " tenía una probabilidad calculada de " << ejemplares[0].probabilidad << "%\n";
            archivo << "¡El ganador fue una sorpresa! " << ejemplares[0].nombre << " tenía una probabilidad calculada de " << ejemplares[0].probabilidad << "%\n";
        } else if (!ejemplares.empty()) {
            std::cout << "El ganador fue un favorito o tenía una probabilidad calculada media.\n";
            archivo << "El ganador fue un favorito o tenía una probabilidad calculada media.\n";
        }

        // --- Selección de Probabilidades para la Carrera ---
        SeleccionCarrera seleccion_top = realizarSeleccionTop3(ejemplares);

        std::cout << "\n--- Selección de Probabilidades para la Carrera #" << c << " ---\n";
        archivo << "\n--- Selección de Probabilidades para la Carrera #" << c << " ---\n";

        if (!seleccion_top.posibles_ganadores.empty()) {
            std::cout << "Posibles Ganadores (según probabilidad calculada):\n";
            archivo << "Posibles Ganadores (según probabilidad calculada):\n";
            for (size_t k = 0; k < seleccion_top.posibles_ganadores.size(); ++k) {
                std::cout << (k + 1) << ". " << seleccion_top.posibles_ganadores[k].first
                          << " (Probabilidad: " << seleccion_top.posibles_ganadores[k].second << "%)\n";
                archivo   << (k + 1) << ". " << seleccion_top.posibles_ganadores[k].first
                          << " (Probabilidad: " << seleccion_top.posibles_ganadores[k].second << "%)\n";
            }
        } else {
            std::cout << "No se pudieron determinar posibles ganadores.\n";
            archivo << "No se pudieron determinar posibles ganadores.\n";
        }

        std::cout << "\nPosible Sorpresa (según probabilidad calculada):\n";
        archivo << "\nPosible Sorpresa (según probabilidad calculada):\n";
        if (seleccion_top.sorpresa_encontrada) {
            std::cout << "- " << seleccion_top.posible_sorpresa.first
                      << " (Probabilidad: " << seleccion_top.posible_sorpresa.second << "%)\n";
            archivo   << "- " << seleccion_top.posible_sorpresa.first
                      << " (Probabilidad: " << seleccion_top.posible_sorpresa.second << "%)\n";
        } else {
            std::cout << "No se identificó una sorpresa clara con los criterios actuales.\n";
            archivo << "No se identificó una sorpresa clara con los criterios actuales.\n";
        }
    }

    archivo.close();
    std::cout << "\nProceso completado. Los resultados y análisis han sido guardados en 'resultados_carreras.txt'.\n";
    return 0;
}