#include <iostream>
#include <algorithm>
#include <string>
#include <mysql_connection.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/resultset.h>
#include <cppconn/statement.h>
#include <cppconn/prepared_statement.h>

#ifdef __cplusplus__
  #include <cstdlib>
#else
  #include <stdlib.h>
#endif


#define TIME 2
#define HOST "tcp://127.0.0.1:3306"
#define USER "mudgame"
#define PASSWORD "linux123"
#define DATABASE "MUDGAMEDB"


//Estados del juego
enum GameState { START, LOGIN, NEWPLAYER, SELECTCHAR, NEWCHAR, GAME, EXIT };


//Limpia la pantalla
void sclear()
{
    if (system("CLS")) system("clear");
}


int main()
{

try
{
    GameState status;
    status = START;

    //Preparamos la conexion a la base de datos
    sql::Driver* driver = get_driver_instance();
    sql::Connection* con = driver->connect(HOST, USER, PASSWORD);
    con->setSchema(DATABASE); //establecemos la conexion

    sql::Statement* stmt = con->createStatement(); //creamos el statement a partir de la conexion


    std::string sql, username, pwd1, pwd2, playerName, characterName;
    int i, exist, playerID, characterID, raceID;
    bool found;
    sql::ResultSet* res; //resultset donde guardaremos los resultados de las consultas



    while(status != GameState::EXIT) //gameloop
    {
        sclear();
        std::cout << "======| MUDGAME v.0.1.|======" << std::endl;
        if(playerName != "")
            std::cout << "You are logged as <" << playerName << ">" << std::endl;
        if(characterName != "")
            std::cout << "Your selected character is <" << characterName << ">" << std::endl;
        std::cout << std::endl;

		switch (status) {
		//inicio
		case START:
            username = "";
            std::cout << "Type in your username or type 'nuevo' to register a new player: " << std::endl;
            std::cin >> username;
            if(username == "nuevo") //si el jugador escribe "nuevo" crea un nuevo player
            {
                status = GameState::NEWPLAYER;
            }
            else
            {
                sql = "SELECT COUNT(*) FROM Players p WHERE p.PlayerName = '" + username + "';"; //mira si existe un player con el PlayerName introducido
                res = stmt->executeQuery(sql);
                if(res->next())
                {
                    if(res->getInt(1) > 0) //existe el registro
                    {
                        status = GameState::LOGIN;
                    }
                    else //no existe el jugador
                    {
                        std::cout << "Error: Non existing player" << std::endl;
                        sleep(TIME);
                    }
                }
                delete(res);
            }
            break;
		case LOGIN:
            std::cout << "---| LOGIN |---" << std::endl;
            std::cout << "Type in your password: " <<std::endl;
            std::cin >> pwd1;

            sql = "SELECT p.PlayerID FROM Players p WHERE p.PlayerName = '" + username + "' AND p.PlayerPassword = '" + pwd1 + "' LIMIT 0, 1;"; //comprueba si existe y recoge el playerID
            res = stmt->executeQuery(sql);
            while(res->next())
            {
                playerID = res->getInt("PlayerID"); //guardamos el playerID en la sesion
                playerName = username; //guardamos el playerName en la sesion
                status = GameState::SELECTCHAR;
            }
            if(playerID == NULL) //no existe un player con ese nombre y password
            {
                std::cout << "Error: Password is incorrect. Please try again." << std::endl;
                sleep(TIME);
                status = GameState::LOGIN;
            }
            delete(res);
            break;
        case NEWPLAYER:
            username = "";
            std::cout << "---| NEW PLAYER |---" << std::endl;
            std::cout << "Type in your new username: " << std::endl;
            std::cin >> username;

            //Comprueba si el nombre de jugador existe
            sql = "SELECT COUNT(*) FROM Players p WHERE p.PlayerName = '" + username + "';"; //comprueba si el player name ya existe en la base de datos
            res = stmt->executeQuery(sql);
            if(res->next())
            {
                if(res->getInt(1) > 0) // el player name existe
                {
                    std::cout << "Error: <" << username << "> is already taken. Try another name for your player." << std::endl;
                    sleep(TIME);
                }
                else //el playername no existe
                {
                    std::cout << "Type in your password: " <<std::endl;
                    std::cin >> pwd1;

                    std::cout << "Type in again your password: " <<std::endl;
                    std::cin >> pwd2;

                    if(pwd1 == pwd2) //comprueba que los passwords coincidan
                    {
                        //Crea el Player
                        sql = "INSERT INTO Players (PlayerID, PlayerName, PlayerPassword) VALUES (NULL, '" + username + "', '" + pwd1 + "');";
                        int numRows = stmt->executeUpdate(sql);
                        if(numRows == 1)
                        {
                            res = stmt->executeQuery("SELECT PlayerID FROM Players ORDER BY PlayerID DESC LIMIT 0, 1 "); //Obtenemos el ID del player recien insertado
                            res->next();
                            playerID = res->getInt("PlayerID");

                            std::cout << "Player created successfully." << std::endl;
                            sleep(TIME);
                            status = GameState::NEWCHAR;
                        }

                    }
                    else //los passwords no coinciden
                    {
                        std::cout << "Error: Passwords don't match." << std::endl;
                        sleep(TIME);
                    }
                }
            }
            delete(res);
            break;
		case SELECTCHAR:
            username = "";
            std::cout << "---| SELECT CHARACTER |---" << std::endl;
            std::cout << "Type <index> to select character or type 'nuevo' to create a new one." << std::endl;

            //Comprueba si el jugador tiene personajes disponibles
            sql = "SELECT COUNT(*) FROM Characters c WHERE c.PlayerID = " + std::to_string(playerID) + ";";
            res = stmt->executeQuery(sql);
            if(res->next())
            {
                exist = res->getInt(1);
                if(exist > 0) //si tiene personajes disponibles muestra la lista
                {
                    std::string results[exist];
                    std::cout << results[0] << " " << results[1] << std::endl;

                    sql = "SELECT c.CharacterID, c.CharacterName FROM Characters c WHERE c.PlayerID = " + std::to_string(playerID) + ";";
                    res = stmt->executeQuery(sql);
                    i = 0;

                    while(res->next())
                    {
                        results[i] = res->getString("CharacterName");
                        std::cout << "<" << i << "> " << res->getString("CharacterName") << std::endl;
                        i++;

                    }
                    std::cin >> username;

                    if(username == "nuevo")
                    {
                        status = GameState::NEWCHAR;
                    }
                    else
                    {
                        characterName = results[atoi(username.c_str())];
                        status = GameState::GAME;
                    }

                }
                else //si no tiene personajes disponibles crea un nuevo pj
                {
                    std::cout << "There are no characters for this player. Create your first character" << std::endl;
                    sleep(TIME);
                    status = GameState::NEWCHAR;
                }
            }
            delete(res);
            break;
 		case NEWCHAR:
            username = "";
            std::cout << "---| NEW CHARACTER |---" << std::endl;
            std::cout << "Type <index> to select Race: " << std::endl;
            sql = "SELECT r.RaceID, r.RaceName FROM Races r;";
            res = stmt->executeQuery(sql);

            i = 0;
            while(res->next()) //lista las razas disponibles
            {
                std::cout << "<" << res->getInt("RaceID") << "> " << res->getString("RaceName") << std::endl;
                i++;
            }

            std::cin >> raceID;

            std::cout << "Type your character name: " << std::endl;
            std::cin >> characterName;

            //Comprueba si el nombre de personaje existe
            sql = "SELECT COUNT(*) FROM Characters c WHERE c.CharacterName = '" + characterName + "';";
            res = stmt->executeQuery(sql);
            if(res->next())
            {
                if(res->getInt(1) > 0) //ya existe un personaje con ese nombre
                {
                    std::cout << "Error: <" << characterName << "> is already taken. Try another name for your character." << std::endl;
                    sleep(TIME);
                }
                else
                {
                    //Crea un nuevo personaje para el player identificado con la raza seleccionada
                    sql = "INSERT INTO Characters (CharacterID, CharacterName, PlayerID, RaceID) VALUES (NULL, '" + characterName + "', '" + std::to_string(playerID) + "', '" + std::to_string(raceID) + "');";
                    int numRows = stmt->executeUpdate(sql);
                    if(numRows == 1)
                    {

                        std::cout << "Your character " << characterName << " has been created successfully." << std::endl;
                        sleep(TIME);
                        status = GameState::GAME;

                    }

                }
            }
            delete(res);
            break;
        case GAME:
            std::cout << "GAME STARTS" << std::endl;
            status = GameState::EXIT;
            break;
        default:
            break;
        }

    }
    delete(stmt);
    delete(con);
}
catch(sql::SQLException &e) //se ha producido alguna excepcion
{
    std::cout << "ERROR: " << e.what() << std::endl;
    std::cout << "Closing..." << std::endl;
}

    return 0;
}