//Aquí iría un #ifdef <Plataforma windows>
#define EN_WINDOWS
//Aquí iría un #elif <Plataforma linux>
//#define EN_LINUX
//Aquí iría un #endif

#include <iostream>

#ifdef EN_WINDOWS
#include <Windows.h>
#endif

#ifdef EN_WINDOWS
#define LIMPIAR_CONSOLA() limpiarConsola()
#elif EN_LINUX
#define LIMPIAR_CONSOLA() system("clear")
#endif

//El tamaño de la fila o la
//columna respectivamente
const int FILA = 3;
const int COLUMNA = 3;

using namespace std;

/////////////////////////////// Prototipos ///////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola();
#endif
//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[3][3]);
//Imprime el gato
void imprimirGato(const char cCuadros[3][3]);
//Espera a que el usuario pulse ENTER
void esperar();
//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[3][3],
                   char cNumeroCuadro,
                   char cCharJugador);
//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[3][3],
                      const char *cCharJugadores);
//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[3][3],
                     const char *cCharJugadores);


int main()
{
    char cCuadro[FILA][COLUMNA];  //Array del juego (gato)
    char cCharJugador[2] = { 'X', 'O' }; //El char a usar por el jugador
    char cResJugarOtraVez[20];    //Respuesta si jugar otra vez
    char cResDosJugadores[20];      //Respuesta si 2 jugadores o no
    char cJugadaJugador[20];      //Es la jugada del jugador actual
    unsigned int uiTurnoJugador = 0;     //El turno del jugador
    int iJugadorGanador;          //El jugador que gano la partida
    bool bJugarOtraVez = false;   //Si resonde si a "¿Jugar otra vez?"
    bool bDosJugadores = false;      //Si se juega con dos jugadores
    bool bJuegoTerminado = false; //Si termina el juego o no

    do  //Se ejecutara mientras bJugarOtraVez sea true
    {
        LIMPIAR_CONSOLA();
        inicializarGato(cCuadro);

        cout << "¨Jugar n 2 jugadores? (S/N): ";
        cin >> cResDosJugadores;

        if (cResDosJugadores[0] == 'S' || cResDosJugadores[0] == 's')
            bDosJugadores = true;
        else
            bDosJugadores = false;

        //Loop del juego
        do
        {
            LIMPIAR_CONSOLA();
            imprimirGato(cCuadro);

            //Se ejecuta mientras se haga una jugada correcta
            do
            {
                cout << "Jugador " << uiTurnoJugador + 1 << " juega: ";
                cin >> cJugadaJugador;

                //Si no es un número
                if (cJugadaJugador[0] < '0' || cJugadaJugador[0] > '9')
                {
                    cout << endl;
                    cout << "Debe realizar una jugada correcta" << endl;
                    esperar();
                    continue;
                }

                //Si la jugada ya se realizó
                if (!jugadaJugador(
                    cCuadro,
                    cJugadaJugador[0],
                    cCharJugador[uiTurnoJugador])
                    )
                {
                    cout << endl;
                    cout << "Ese n£mero ya esta ocupado!" << endl;
                    cout << endl;
                    esperar();
                    continue;
                }

                break;
            } while (true);

            //Si hay un empate
            if (comprobarEmpate(cCuadro, cCharJugador))
            {
                cout << endl;
                cout << "Ha habido un empate!";
                cout << endl;
                esperar();
                break;
            }

            iJugadorGanador = comprobarVictoria(cCuadro, cCharJugador);
            //Si alguien a ganado
            if (iJugadorGanador != -1)
            {
                cout << endl;
                cout << "El jugador " << iJugadorGanador + 1 << " ha ganado!";
                cout << endl;
                bJuegoTerminado = true;
                esperar();
            }
            else
                bJuegoTerminado = false;
            if (uiTurnoJugador == 0)
                uiTurnoJugador = 1;
            else
                uiTurnoJugador = 0;
        } while (!bJuegoTerminado);

       cout << "¨Jugar otra vez? (S/N): ";
       cin >> cResJugarOtraVez;

        if (cResJugarOtraVez[0] == 'S' || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;

        //Si responde que sí
        if (cResJugarOtraVez[0] == 'S'
        || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;
    } while (bJugarOtraVez);

    return EXIT_SUCCESS;
}

////////////////////////////// Definiciones //////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola()
{
    HANDLE hOutPut;    //Manejador de salida de la consola
    CONSOLE_SCREEN_BUFFER_INFO csbi; //Información de la consola
    COORD coord = { 0, 0 };     //Desde donde empezar a borrar

    hOutPut = GetStdHandle(STD_OUTPUT_HANDLE);
    GetConsoleScreenBufferInfo(hOutPut, &csbi);

    //Limpia la consola
    FillConsoleOutputCharacter(
        hOutPut,
        '',
        csbi.dwSize.X * csbi.dwSize.Y,
        coord,
        NULL
        );
    //Situa el cursor en el inicio del lugar borrado
    SetConsoleCursorPosition(hOutPut, coord);
}
#endif

//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[3][3])
{
    char cNumero = '1'; //Es el número que se escribirá en el array

    //Escribe los valores en el array
    for (int fila = FILA - 1; fila >= 0; fila--)
    {
        for (int columna = 0; columna < COLUMNA; columna++)
        {
            cCuadros[fila][columna] = cNumero;
            //Pasa al otro número
            cNumero++;
        } //for
    } //for
}

//Imprime el gato
void imprimirGato(const char cCuadros[3][3])
{
    for (int fila = 0; fila < FILA; fila++)
    {
        for (int columna = 0; columna < COLUMNA; columna++)
        {
            cout << cCuadros[fila][columna];

            //Si no es la ultima columna
            if (columna < COLUMNA - 1)
                cout << "|";
        } //for

        cout << endl;
        //Si no es la ultima fila
        if (fila < FILA - 1)
            cout << "-+-+-";
        cout << endl;
    } //for
}

//Espera a que el usuario pulse ENTER
void esperar()
{
    cin.sync();
    cin.get();
    cin.sync();
}

//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[3][3],
                   char cNumeroCuadro,
                   char cCharJugador)
{
    //Recorre todo el gato y busca el caracter,
    //si lo encuentra lo reemplaza por el caracter
    //del jugador correspondiente
    for (int fila = 0; fila < FILA; fila++)
    {
        for (int columna = 0; columna < COLUMNA; columna++)
        {
            if (cCuadros[fila][columna] == cNumeroCuadro)
            {
                cCuadros[fila][columna] = cCharJugador;
                LIMPIAR_CONSOLA();
                imprimirGato(cCuadros);
                return true;
            } //if
        } //for
    } //for

    return false;
}

//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[3][3],
                      const char *cCharJugadores)
{
    enum JUGADOR
    {
        JUGADOR1,
        JUGADOR2
    };

    //Comprueba gatos horizontalmente
    for (int fila = 0; fila < FILA; fila++)
    {
        if (cCuadros[fila][0] == cCuadros[fila][1]
        && cCuadros[fila][1] == cCuadros[fila][2])
        {
            if (cCuadros[fila][0] == cCharJugadores[0])
                return JUGADOR1;
            else if (cCuadros[fila][0] == cCharJugadores[1])
                return JUGADOR2;
        }
    }

    //Comprueba gatos verticalmente
    for (int columna = 0; columna < COLUMNA; columna++)
    {
        if (cCuadros[0][columna] == cCuadros[1][columna]
        && cCuadros[1][columna] == cCuadros[2][columna])
        {
            if (cCuadros[0][columna] == cCharJugadores[0])
                return JUGADOR1;
            else if (cCuadros[0][columna] == cCharJugadores[1])
                return JUGADOR2;
        }
    }

    if (cCuadros[0][0] == cCuadros[1][1]
    && cCuadros[1][1] == cCuadros[2][2])
    {
        if (cCuadros[0][0] == cCharJugadores[0])
            return JUGADOR1;
        else if (cCuadros[0][0] == cCharJugadores[1])
            return JUGADOR2;
    }
    else if (cCuadros[0][2] == cCuadros[1][1]
    && cCuadros[1][1] == cCuadros[2][0])
    {
        if (cCuadros[0][2] == cCharJugadores[0])
            return JUGADOR1;
        else if (cCuadros[0][2] == cCharJugadores[1])
            return JUGADOR2;
    }

    return -1; //No encontrado
}

//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[3][3],
                     const char *cCharJugadores)
{
    //Si alguien ganó no hay empate
    if (comprobarVictoria(cCuadros, cCharJugadores) != -1)
        return false;

    for (int fila = 0; fila < FILA; fila++)
    {
        for (int columna = 0; columna < COLUMNA; columna++)
        {
            if (cCuadros[fila][columna] != cCharJugadores[0]
            && cCuadros[fila][columna] != cCharJugadores[1])
            {
                return false;
            }
        } //for
    } //for

    //Empate
    return true;
}