#include <iostream>
#include<string>
#include<fstream>
#include<iomanip>

using namespace std;

#include "Attletas.h"

//Tamaño arrelgo
const int size = 50; //SIZE SUFICIENTEMENTE GRANDE PARA ACEPTAR CUALQUIER CANTIDAD DE CORREDORES CON UN LIMITE DE 50 CORREDORES

void sorting(Attletas[], int);
int busquedaBinaria(Attletas[], int,string);


int main()
{
    char N[100];//Arreglo de 100 caracteres obtener nombre corredor
    int iD = 0;//Numero id corredor
    float t = 0;//obtener informacion tiempo del corredor

    int cantidadCorredores; //NUEVA VARIABLE PARA QUE USUARIO ENTRE CUALQUIER CANTIDAD DE CORREDORES

    //Classe :Attleta objeto.
    Attletas A[size];

    cout << "Entre cantidad de corredores: ";
    cin >> cantidadCorredores; //USUARIO LIMITA EL ARREGLO DE CORREDORES
    cout << endl << endl;
    for (int i = 0; i < cantidadCorredores; i++) //LOOP SE REPITE PARA CADA CORREDOR, SEGUN ESPECIFICADO POR EL USER
    {
        cout << "************" << endl << endl;

        cout << "Nombre: ";
        cin.ignore();
        cin.getline(N, 100, '\n');
        A[i].setName(N);

        cout << "Tiempo: ";
        cin >> t;
        A[i].settime(t);

        cout << "Id :";
        cin >> iD;
        A[i].setid(iD);

        cout << endl;
    }


    sorting(A, cantidadCorredores);
    cout << fixed << showpoint << setprecision(2);
    for (int x = 0; x < cantidadCorredores; x++)
    {
        cout<<"Tiempo "<< (x+1)<<") " << A[x].gettime() << " " << endl;
    }

    char Nombre[100];
    cout << "Entre nombre a buscar :"; cin.ignore(); cin.getline(Nombre, 100);


    int N_E;

    N_E=busquedaBinaria(A, cantidadCorredores, Nombre);

    if (N_E == -1)
    {
        cout << "No se encontro nombre!" << endl << endl;
    }
    else{

        cout << "Nombre ::" << A[N_E].getnames() << endl;
        cout << "Id ::" << A[N_E].getid() << endl;
        cout << "Tiempo ::" << A[N_E].gettime() << endl << endl;
    }


    return 0;
}

void sorting(Attletas A[], int size)
{
    /*
    "elComparado" es la casilla que va a ser comparada
    con el resto de las casillas(paraComparar)
    el loop externo escoge la casilla que se va a revisar,
    luego el interno va casilla por casilla viendo si es menor que "elComparado"
    */
    int elComparado;
    float tiempoMenorTemp;//TOMO EL TIEMPO DEL PRIMER CORREDOR COMO EL MENOR PARA DESPUES COMPARARLO
    int minLocation; //LOCATION DEL QUE SE ENCONTRO QUE FUE MENOR QUE "elComparado"

    for (elComparado = 0; elComparado < size -1; elComparado++)
    {
        tiempoMenorTemp = A[elComparado].gettime();
        minLocation = elComparado;

        for (int paraComparar = elComparado + 1; paraComparar < size; paraComparar++)
        {
            if (A[paraComparar].gettime() < tiempoMenorTemp)
            {
                tiempoMenorTemp = A[paraComparar].gettime();
                minLocation = paraComparar;
            }
        }
        A[minLocation] = A[elComparado];
        A[elComparado].settime(tiempoMenorTemp);
    }
}

int busquedaBinaria(Attletas A[], int S,string N)
{

    int primero = 0;
    int ultimo = S - 1;
    int medio;


    while ( primero <= ultimo)
    {
        medio = (primero + ultimo) / 2;

        if (A[medio].getnames() == N)
        {

            return medio;

        }
        else if (A[medio].getnames() < N)
        {

             primero=medio+1;
        }
        else
        {
            ultimo=medio-1;
        }
    }

    return -1;
}