/**********************************************************************/ /**
 *
 * @file pr5_juego_v0.cpp
 *
 * @brief Práctica 5 EDA-GIM: Programa principal
 *
 * @version 0.9
 * @author Marina Martinez y Laura Crespo
 * @date 06-11-2019
 *
 */ /**********************************************************************/

#include <map>
#include <vector>
#include <utility>      //pair, make_pair
#include <algorithm>    //make_heap, push_heap, pop_heap
#include <fstream>
#include <iostream>
#include <string>

using namespace std;

//Alias para el tipo mapa (jugadoresConectados)
typedef map<string,int> TipoMapa;
//Alias para los elementos que se guardan en el monticulo y en los equipos
typedef pair<int,string> TElemento;
//Alias para el tipo monticulo (rankingJugadores)
typedef vector<TElemento> TipoMonticulo;
//Nombres de los archivos de entrada y salida
const string NOM_ARCHIVO_INICIO = "usuarios_conectados_small.dat";
const string NOM_ARCHIVO_SALIDA = "pr5_jugadores_final.dat";

//Prototipos de funciones auxiliares
void ConstruirMapaInicial(TipoMapa&);
void MostrarJugadoresConectados(TipoMapa);
void ConstruirMonticuloInicial(TipoMapa, TipoMonticulo&);
void MostrarRankingJugadores (TipoMonticulo);
void FormarEquipos(TipoMonticulo&, vector<TElemento>&, vector<TElemento>&);
void MostrarEquipo(vector<TElemento>);
void ActualizarPuntuacion(vector<TElemento>, int, TipoMonticulo&, TipoMapa&);
void GuardarResultados(TipoMapa);

/** @brief Programa principal organizado con la estructura de tareas
 *  del guion de la practica
 */
int main()
{
    TipoMapa jugadoresConectados ;
    TipoMonticulo rankingJugadores;
    vector<TElemento> equipo_1, equipo_2;

    //Tarea 1: Carga inicial y verificacion
    ConstruirMapaInicial(jugadoresConectados);
    cout << endl << "Jugadores Conectados" << endl;
    cout << "-----------------------------" << endl;
    MostrarJugadoresConectados(jugadoresConectados);
    ConstruirMonticuloInicial(jugadoresConectados, rankingJugadores);
    cout << endl << "Ranking de jugadores" << endl;
    cout << "-----------------------------" << endl;
    MostrarRankingJugadores(rankingJugadores);

    //Tarea 2: Formacion de equipos y verificacion
    FormarEquipos(rankingJugadores, equipo_1, equipo_2);
    cout << endl << "* Equipo 1" << endl;
    cout << "*****************" << endl;
    MostrarEquipo(equipo_1);
    cout << endl << "* Equipo 2" << endl;
    cout << "*****************" << endl;
    MostrarEquipo(equipo_2);
    cout << endl << "Ranking de jugadores (sin los equipos)" << endl;
    cout << "-----------------------------" << endl;
    MostrarRankingJugadores(rankingJugadores);

    //Tarea 3: Fin de juego por equipos y Actualizacion de puntuacion
    //Gana equipo 2 y sus miembros acumulan 25 puntos más
    ActualizarPuntuacion(equipo_2, +25, rankingJugadores, jugadoresConectados);
    //Pierde equipo 2 y sus miembros restan 10 puntos menos
    ActualizarPuntuacion(equipo_1, -10, rankingJugadores, jugadoresConectados);
    cout << endl << "Ranking de jugadores (de nuevo con los equipos)" << endl;
    cout << "-----------------------------" << endl;
    MostrarRankingJugadores(rankingJugadores);
    cout << endl << "Jugadores Conectados" << endl;
    cout << "-----------------------------" << endl;
    MostrarJugadoresConectados(jugadoresConectados);

    //Tarea 4: Resultados finales
    GuardarResultados(jugadoresConectados);

    return 0;
}

/**********************************************************************/ /**
 *
 *  @brief Construir el mapa inicial con los jugadores conectados
 *  La informacion se lee del archivo NOM_ARCHIVO_INICIO
 *
 *  @param[out] m Mapa generado (registro de jugadores conectados)
 *
 */ /**********************************************************************/
void ConstruirMapaInicial(TipoMapa& m)
{
    //#IMPLENTAR

    ifstream f_in;
    string nombre;
    int puntos;

    f_in.open (NOM_ARCHIVO_INICIO);
    //f_in.open ("A.dat");
    if ( f_in.fail())
        cout << "Error al abrir el fichero" << endl;
    else
    {
        while (getline (f_in, nombre, ':'))
        {
            f_in >> puntos;
            f_in.ignore();
            //m.insert(pair<string, int>(nombre, puntos));
            m.insert(make_pair(nombre, puntos));
        }

        f_in.close();




    }

    return;




}

/**********************************************************************/ /**
 *
 *  @brief Mostrar en pantalla los elementos de un mapa, ordenados por clave
 *
 *  @param [in]  m   Mapa con los jugadores conectados
 *
 */ /**********************************************************************/
void MostrarJugadoresConectados(TipoMapa m)
{
    for (TipoMapa::iterator it=m.begin(); it!=m.end() ; it++)
        cout << it->first << " => " << it->second << endl;
    cout << endl << "Total = " << m.size() << endl;
    cout << "-----------------------------" << endl;
}

/**********************************************************************/ /**
 *
 *  @brief Construir el monticulo inicial a partir de los jugadores conectados
 *
 *  @param [in]  mapa   Mapa con los jugadores conectados
 *  @param [out] monte Monticulo generado
 *
 */ /**********************************************************************/
void ConstruirMonticuloInicial(TipoMapa mapa, TipoMonticulo& monte)
{
//#IMPLENTAR
    //monte = make_heap (mapa.begin(), mapa.end());

    /*//Alias para el tipo mapa (jugadoresConectados)
    typedef map<string,int> TipoMapa;
    //Alias para los elementos que se guardan en el monticulo y en los equipos
    typedef pair<int,string> TElemento;
    //Alias para el tipo monticulo (rankingJugadores)
    typedef vector<TElemento> TipoMonticulo;*/

    /*make_heap (monte.begin(), monte.end());
    for (TipoMapa::iterator it=mapa.begin(); it!=mapa.end(); it++)
    {

         monte.push_back(//it );
         push_heap (monte.begin(), monte.end());

    }*/



}

/**********************************************************************/ /**
 *
 *  @brief Mostrar en pantalla los elementos de un monticulo
 *  Los datos no están ordenados, se muestran en orden de indices en el vector
 *
 *  @param [in]  m   Monticulo con las puntuaciones de los jugadores
 *
 */ /**********************************************************************/
void MostrarRankingJugadores (TipoMonticulo m)
{
    for (size_t i=0; i < m.size(); i++)
    {
        if ( i==0 )
            cout << "[Raiz] ";
        else
        {
            size_t padre = (i-1)/2;
            cout << "[Hijo de " << m[padre].second << "] ";
        }
        cout << m[i].first << ":" << m[i].second << endl;
    }
    cout << endl << "Total = " << m.size() << endl;
    cout << "-----------------------------" << endl;
}

/**********************************************************************/ /**
 *
 *  @brief Formar 2 equipos de 5 jugadores con los jugadores de mayor puntuacion
 *  Los jugadores seleccionados son eliminados del monticulo
 *
 *  @param [in,out]  m   Monticulo con las puntuaciones de los jugadores
 *  @param [out]  eq1   Equipo resultante 1
 *  @param [out]  eq2   Equipo resultante 2
 *  @exception runtime_error No hay suficientes jugadores=no se pueden formar los equipos
 *
 */ /**********************************************************************/
void FormarEquipos(TipoMonticulo& m, vector<TElemento>& eq1, vector<TElemento>& eq2)
{
//#IMPLENTAR
}

/**********************************************************************/ /**
 *
 *  @brief Mostrar por pantalla los jugadores miembros de un equipo
 *
 *  @param [in]  e   Equipo
 *
 */ /**********************************************************************/
void MostrarEquipo(vector<TElemento> e)
{
    for (size_t i=0; i < e.size(); i++)
        cout << e[i].first << ":" << e[i].second << endl;
    cout << endl << "Total = " << e.size() << endl;
    cout << "-----------------------------" << endl;
}

/**********************************************************************/ /**
 *
 *  @brief Actualizar la puntuacion de los miembros de un equipo
 *  Los jugadores se reincorporan al ranking de jugadores y se actualizan sus
 *  datos en el registro de jugadores conectados
 *
 *  @param [in]  eq   Equipo
 *  @param [in]  ptos Puntos añadidos (o restados si negativo)
 *  @param [in,out]  monte Monticulo con el ranking de jugadores
 *  @param [in,out]  mapa Mapa con el registro de jugadores conectados
 *
 */ /**********************************************************************/
void ActualizarPuntuacion(vector<TElemento> eq, int ptos, TipoMonticulo& monte, TipoMapa& mapa)
{
//#IMPLENTAR
}

/**********************************************************************/ /**
 *
 *  @brief Almacenar los resultados finales de los jugadores conectados
 *  en un archivo (NOM_ARCHIVO_SALIDA)
 *
 *  @param [in]  mapa Mapa con el registro de jugadores conectados
 *
 */ /**********************************************************************/
void GuardarResultados(TipoMapa m)
{
//#IMPLENTAR
}