#include <sstream>
#include <stdexcept>

#include "CDb.h"

CDb::CDb()
{
    //ctor
}

CDb::~CDb()
{
    //dtor
    delete m_con;
}

/** @brief (one liner)
  *
  * (documentation goes here)
  */
int CDb::initialize(std::string pv_hostname ,std::string pv_username, std::string pv_password)
{
    m_hostname = pv_hostname;
    m_username = pv_username;
    m_password = pv_password;

    m_driver = sql::mysql::get_mysql_driver_instance();

    return 0;
}

int CDb::ThreadInit()
{
//	return m_driver->threadInit();
}

int CDb::ThreadEnd()
{ 
//      return m_driver->threadInit();
} 
/** @brief (one liner)
  *
  * (documentation goes here)
  */
int CDb::start()
{
    connect();
    return 0;
}

int CDb::thDummyAct()
{
    while(1==1)
    {
        sleep(60);
        int lv_ec = 1;
        sql::PreparedStatement *prep_stmt;

        try
        {
            prep_stmt = m_con->prepareStatement("select 1");
            lv_ec = prep_stmt->executeUpdate();

            delete prep_stmt;
        }
        catch(sql::SQLException &e)
        {
            std::cout << "# ERR: SQLException in " << __FILE__;
            std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
            std::cout << "# ERR: " << e.what();
            std::cout << " (MySQL error code: " << e.getErrorCode();
            std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
	    exit(1);
        }
        return lv_ec;
    }
    return 0;
}

/** @brief (one liner)
  *
  * (documentation goes here)
  */
int CDb::connect()
{
    cout << "CDb::connect()" << endl << flush;;

//    m_con = m_driver->connect("central1","gameserver","garnacha");
//    m_con = m_driver->connect("192.168.0.60","gameserver","garnacha");
    m_con = m_driver->connect("127.0.0.1","gameserver","wQd87BDJurJ-JdtK_8ez");
//    m_con = m_driver->connect("localhost","casino","hunter");
    if(m_con)
    {
//        m_thDummy = new boost::thread(boost::bind(&CDb::thDummyAct,this));
        return 0;
    }
    else
        return 1;
}

int CDb::reconnect_if_close()
{
        if(m_con->isClosed())
        {
                cout << "CDB - Conexion cerrada, reabriendo ..." << endl << flush;
                delete m_con;
                m_con = NULL;
                connect();
                sleep(10);
                if(m_con->isClosed())
                {
                        cout << "CDB - ERROR SEVERO, NO SE PUDO REABRIR LA CONEXION, SALIENDO ... " << endl << flush;
                        exit(2);
                }
                else
                {
                        cout << "CDB - Conexión reabierta con exito ..." << endl << flush;
                }
        }
}

int CDb::getUsers(char *usr, char *psw, unsigned short *uid, unsigned short *p_city_id, std::string *p_nick, unsigned char *p_blocked, unsigned char *p_error, int *p_reason)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    unsigned int lv_uid; 
    unsigned int lv_city_id;
    std::string lv_string_aux;

    try
    { 
    reconnect_if_close();
    prep_stmt = m_con->prepareStatement("SELECT * FROM casino.Users WHERE username = LOWER(?) AND password = LOWER(?) AND can_play = 'S'");
    prep_stmt->setString(1,usr);
    prep_stmt->setString(2,psw);
    res = prep_stmt->executeQuery();

    while(res->next())
    {
        std::string lv_uid_str = res->getString("id");
        lv_uid = atoi(lv_uid_str.data());
        *uid = lv_uid;
        lv_city_id = res->getUInt("city_id");
        *p_city_id = lv_city_id;	
        *p_nick = res->getString("nick");
        lv_string_aux = res->getString("blocked");
        *p_blocked = lv_string_aux.data()[0];
        lv_string_aux = res->getString("error");
        *p_error = lv_string_aux.data()[0];
        *p_reason = res->getInt("error_reason");
        lv_ec = 0;
    }
    delete res;
    delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
            std::cout << "# ERR: SQLException in " << __FILE__;
            std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
            std::cout << "# ERR: " << e.what();
            std::cout << " (MySQL error code: " << e.getErrorCode();
            std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
            exit(1);
    }

    return lv_ec;
}
/** @brief (one liner)
  *
  * (documentation goes here)
  */
int CDb::getPlayerAmount(unsigned short uid, unsigned long *amount)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    unsigned int lv_uid = uid;
    long double lv_amount;

    try
    {
    reconnect_if_close();
    prep_stmt = m_con->prepareStatement("SELECT * FROM casino.PlayerState WHERE ID_Player = ?");
    prep_stmt->setUInt(1,lv_uid);
    res = prep_stmt->executeQuery();

    while(res->next())
    {
        lv_amount = res->getDouble("Amount");
        if(lv_amount < 0)
        {
            *amount = 0;
            lv_ec = -1;
        }
        else
        {
            *amount = (unsigned long) lv_amount;
            lv_ec = 0;
        }
//        std::string lv_amount = res->getString("Amount");
//        *amount = atol(lv_amount.data());
//        lv_ec = 0;
    }

    delete res;
    delete prep_stmt;
    }
        catch(sql::SQLException &e)
        {
            std::cout << "# ERR: SQLException in " << __FILE__;
            std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
            std::cout << "# ERR: " << e.what();
            std::cout << " (MySQL error code: " << e.getErrorCode();
            std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
            exit(1);
        }


    return lv_ec;
}

int CDb::setPlayerAmount(unsigned short uid, long amount)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_uid = uid;

    try
    {
        reconnect_if_close();
//        prep_stmt = m_con->prepareStatement("UPDATE casino.PlayerState SET Amount = ? WHERE ID_Player = ?");
        prep_stmt = m_con->prepareStatement("UPDATE casino.PlayerState SET Amount = Amount + ? WHERE ID_Player = ?");

        prep_stmt->setInt(1, amount);
        prep_stmt->setUInt(2,lv_uid);
        lv_ec = prep_stmt->executeUpdate();

        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::saveBet(unsigned short p_table_num, unsigned short p_number_play, unsigned char p_winning_number, unsigned short p_uid, unsigned char p_coin_value, unsigned short *p_bets,unsigned long p_amount_b, unsigned long p_amount_in_game, int p_coins_to_save, unsigned long p_amount, unsigned long p_winning_bet)
{

    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_table_num = p_table_num; 
    unsigned int lv_number_play = p_number_play; 
    unsigned int lv_winning_number = p_winning_number; 
    unsigned int lv_uid = p_uid; 
    unsigned int lv_coin_value = p_coin_value; 
    unsigned int lv_bets;
    unsigned int lv_amount_b = p_amount_b;
    unsigned int lv_amount_in_game = p_amount_in_game;
    int lv_coins_to_save = p_coins_to_save;
    unsigned int lv_amount = p_amount;
    unsigned int lv_winning_bet = p_winning_bet;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("insert into casino.ruleta_log "
                                            "(table_id,number_play,uid,coin_value,amount_b,"
                                            "amount_in_game,coins_to_save,amount_a,winning_bet,p0,"
                                            "p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16,"
                                            "p17,p18,p19,p20,p21,p22,p23,p24,p25,p26,p27,p28,p29,p30,"
                                            "p31,p32,p33,p34,p35,p36,p00,m01,m02,m03,m12,m23,m14,"
                                            "m25,m36,m45,m56,m47,m58,m69,m78,m89,m710,m811,m912,"
                                            "m1011,m1112,m1013,m1114,m1215,m1314,m1415,m1316,m1417,"
                                            "m1518,m1617,m1718,m1619,m1720,m1821,m1920,m2021,m1922,"
                                            "m2023,m2124,m2223,m2324,m2225,m2326,m2427,m2526,m2627,"
                                            "m2528,m2629,m2730,m2829,m2930,m2831,m2932,m3033,m3132,"
                                            "m3233,m3134,m3235,m3336,m3435,m3536,cu01,cu02,cu03,"
                                            "cu1,cu3,cu4,cu6,cu7,cu9,cu10,cu12,cu13,cu15,cu16,cu18,"
                                            "cu19,cu21,cu22,cu24,cu25,cu27,cu28,cu30,cu31,cu33,"
                                            "ca3,ca6,ca9,ca12,ca15,ca18,ca21,ca24,ca27,ca30,ca33,"
                                            "ca36,cd36,cd69,cd912,cd1215,cd1518,cd1821,cd2124,"
                                            "cd2427,cd2730,cd3033,cd3336,colu1,colu2,colu3,colu12,"
                                            "colu23,menor,par,negro,rojo,impar,mayor,do1,do2,do3)"
                                            "values"
                                            "( ?,?,?,?,?,?,?,?,?,"
                                            "  ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,"
                                            "  ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,"
                                            "  ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,"
                                            "  ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,"
                                            "  ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
                                           );
        prep_stmt->setUInt(1,lv_table_num);
        prep_stmt->setUInt(2,lv_number_play);
        prep_stmt->setUInt(3,lv_uid);
        prep_stmt->setUInt(4,lv_coin_value);
        prep_stmt->setUInt(5,lv_amount_b);
        prep_stmt->setUInt(6,lv_amount_in_game);
        prep_stmt->setInt(7,lv_coins_to_save);
        prep_stmt->setUInt(8,lv_amount);
        prep_stmt->setUInt(9,lv_winning_bet);
        for(size_t i = 0; i < 160; i++)
        {
	        lv_bets = p_bets[i];
            prep_stmt->setUInt(10+i,lv_bets);
        }

        lv_ec = prep_stmt->executeUpdate();

        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::loadTable(unsigned short p_tid, std::string *p_name, float *p_amount, unsigned int *p_commission, unsigned char *p_commission_perc, float *p_second_amount, unsigned short *p_number_play, unsigned long *p_acum, float *p_second_amount_perc)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    std::string lv_str;
    unsigned int lv_commission_perc;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("SELECT * FROM casino.GamesTables WHERE id = ?");
        prep_stmt->setUInt(1,p_tid);
        res = prep_stmt->executeQuery();

        while(res->next())
        {
            *p_name = res->getString("name");
            lv_str = res->getString("amount");
            *p_amount = atof(lv_str.data());
            lv_str = res->getString("second_amount");
            *p_commission = res->getUInt("commission");
            lv_commission_perc = res->getUInt("commission_perc");
            *p_commission_perc = lv_commission_perc;
            *p_second_amount = atof(lv_str.data());
            lv_str = res->getString("number_play");
            *p_number_play = atoi(lv_str.data());
            lv_str = res->getString("acum");
            *p_acum = atoi(lv_str.data());
            lv_str = res->getString("second_amount_perc");
            *p_second_amount_perc = atoi(lv_str.data());

            lv_ec = 0;
        }

        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::loadTableAmount(unsigned short p_tid, unsigned long *p_amount)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    unsigned int lv_tid = p_tid;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("SELECT amount FROM casino.GamesTables WHERE id = ?");
        prep_stmt->setUInt(1,lv_tid);
        res = prep_stmt->executeQuery();

        while(res->next())
        {
            *p_amount = res->getUInt("amount");
            lv_ec = 0;
        }

        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}


int CDb::saveTable(unsigned short p_tid, int p_amount, unsigned int p_second_amount, unsigned int p_commission, unsigned short p_number_play, unsigned long p_acum) 
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_tid = p_tid; 
    int lv_amount = p_amount;
    unsigned int lv_second_amount = p_second_amount;
    unsigned int lv_commission = p_commission;
    unsigned int lv_number_play = p_number_play; 
    unsigned int lv_acum = p_acum;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("UPDATE casino.GamesTables SET amount = amount + ?, second_amount = ?, commission = commission + ?, number_play = ?, acum = ? WHERE id = ?");
        prep_stmt->setInt(1, lv_amount);
        prep_stmt->setUInt(2, lv_second_amount);
        prep_stmt->setUInt(3, lv_commission);
        prep_stmt->setUInt(4, lv_number_play);
        prep_stmt->setUInt(5, lv_acum);
        prep_stmt->setUInt(6, lv_tid);
        lv_ec = prep_stmt->executeUpdate();

        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::saveTableBetHist(unsigned short p_tid, unsigned short p_number_play, unsigned char p_winning_number,
        unsigned int p_amount_b, unsigned int p_second_amount_b, unsigned int p_commission_b, unsigned int p_acum_b,
        unsigned int p_amount_in_game, int p_amount_to_save, unsigned int p_amount, unsigned int p_second_amount, unsigned int p_commission, unsigned int p_acum)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_tid = p_tid;
    unsigned int lv_number_play = p_number_play;
    unsigned int lv_winning_number = p_winning_number;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("INSERT INTO casino.gamestables_bets_hist"
                                            "(table_id, number_play, winning_number, "
                                            " amount_b, second_amount_b, commission_b,"
                                            " acum_b, amount_in_game, amount_to_save, amount_a,"
                                            " second_amount_a, commission_a, acum_a)"
                                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                                            );
        prep_stmt->setUInt(1, lv_tid);
        prep_stmt->setUInt(2, lv_number_play);
        prep_stmt->setUInt(3, lv_winning_number);
        prep_stmt->setUInt(4, p_amount_b);
        prep_stmt->setUInt(5, p_second_amount_b);
        prep_stmt->setUInt(6, p_commission_b);
        prep_stmt->setUInt(7, p_acum_b);
        prep_stmt->setUInt(8, p_amount_in_game);
        prep_stmt->setInt(9, p_amount_to_save);
        prep_stmt->setUInt(10, p_amount);
        prep_stmt->setUInt(11, p_second_amount);
        prep_stmt->setUInt(12, p_commission);
        prep_stmt->setUInt(13, p_acum);

        lv_ec = prep_stmt->executeUpdate();
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::loadCasino(unsigned char p_id, float *p_commission, float *p_commission_perc)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    std::string lv_str;

    try
    {
        reconnect_if_close();
        sleep(10);
        prep_stmt = m_con->prepareStatement("SELECT * FROM casino.casino WHERE id = ?");
        prep_stmt->setUInt(1,p_id);
        res = prep_stmt->executeQuery();

        while(res->next())
        {
            lv_str = res->getString("commission");
            *p_commission = atof(lv_str.data());
            lv_str = res->getString("commission_perc");
            *p_commission_perc = atof(lv_str.data());
            lv_ec = 0;
        }

        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
	exit(1);
    }
    return lv_ec;
}

int CDb::saveCasino(unsigned char p_id, float p_commission)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("UPDATE casino.casino SET commission = ? WHERE id = ?");
        prep_stmt->setUInt(1, p_commission);
        prep_stmt->setInt(2,p_id);
        lv_ec = prep_stmt->executeUpdate();

        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;

}

int CDb::getRoomList(const char *p_module, std::vector<st_room_entry> &p_room_entry)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    std::string lv_str;
    size_t lv_dbcnt;
    size_t i = 0;

    try
    {
        sleep(10);
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("SELECT r.id, r.room_num, r.name, count(t.id) as table_max"
                                            "	FROM 	casino.Games as c,"
                                            "		    casino.Rooms as r,"
                                            "		    casino.GamesTables as t"
                                            "	WHERE"
                                            "		c.id = r.game_id AND"
                                            "		c.Module = ?     AND"
                                            "		t.room_id = r.id"
                                            "	GROUP BY r.id, r.room_num, r.name"
                                            "	ORDER by r.room_num");
        prep_stmt->setString(1,p_module);
        res = prep_stmt->executeQuery();

        lv_dbcnt = res->rowsCount();
        if(lv_dbcnt > 0)
        {
            p_room_entry.resize(lv_dbcnt);
            while(res->next())
            {
                p_room_entry[i].id = res->getUInt("id");
                p_room_entry[i].room_num = res->getUInt("room_num");
                p_room_entry[i].name = res->getString("name");
                p_room_entry[i].table_max_num = res->getUInt("table_max");
                i++;
                lv_ec = 0;
            }
        }
        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;
}

int CDb::getTableList(unsigned char p_room_id, std::vector<st_table_entry> &p_table_entry)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    unsigned int lv_room_id = p_room_id;
    size_t lv_dbcnt;
    size_t i = 0;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("SELECT t.id, t.table_num, t.name, t.max_chairs, t.amount, t.commission, t.commission_perc, t.second_amount, t.second_amount_perc, t.second_amount_limit, t.number_play, t.acum"
                                            "	FROM 	casino.Rooms as r,"
                                            "		casino.GamesTables as t"
                                            "	WHERE"
                                            "		r.id = t.room_id AND"
                                            "		r.id = ?"
                                            "	ORDER by t.table_num");
        prep_stmt->setUInt(1,lv_room_id);
        res = prep_stmt->executeQuery();

        lv_dbcnt = res->rowsCount();
        if(lv_dbcnt > 0)
        {
            p_table_entry.resize(lv_dbcnt);
            while(res->next())
            {
                p_table_entry[i].id = res->getUInt("id");
                p_table_entry[i].table_num = res->getUInt("table_num");
                p_table_entry[i].name = res->getString("name");
                p_table_entry[i].max_chairs = res->getUInt("max_chairs");
                p_table_entry[i].amount = res->getUInt("amount");
                p_table_entry[i].commission = res->getUInt("commission");
                p_table_entry[i].commission_perc = res->getUInt("commission_perc");
                p_table_entry[i].second_amount = res->getUInt("second_amount");
                p_table_entry[i].second_amount_perc = res->getUInt("second_amount_perc");
                p_table_entry[i].second_amount_limit = res->getUInt("second_amount_limit");
                p_table_entry[i].number_play = res->getUInt("number_play");
                p_table_entry[i].acum = res->getUInt("acum");
                i++;
                lv_ec = 0;
            }
        }
        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
	exit(1);
    }
    return lv_ec;
}

int CDb::getRoomCitiesList(std::vector<st_room_cities> &p_room_cities)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    sql::ResultSet  *res;
    size_t lv_dbcnt;
    size_t i = 0;

    try
    {
	reconnect_if_close();
//        prep_stmt = m_con->prepareStatement("SELECT room_num, city_id"
        prep_stmt = m_con->prepareStatement("SELECT rc.id as id, city_id"
                                            "	FROM 	casino.Rooms_Cities as rc,"
                                            "           casino.Rooms as r"
                                            "   WHERE"
                                            "           rc.room_id = r.id"
                                            "	ORDER by city_id");
        res = prep_stmt->executeQuery();

        lv_dbcnt = res->rowsCount();
        if(lv_dbcnt > 0)
        {
            p_room_cities.resize(lv_dbcnt);
            while(res->next())
            {
//                p_room_cities[i].room_num = res->getUInt("room_num");
                p_room_cities[i].room_num = res->getUInt("id");
                p_room_cities[i].city_id = res->getUInt("city_id");
                i++;
                lv_ec = 0;
            }
        }
        delete res;
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
	exit(1);
    }
    return lv_ec;
}

int CDb::createPayReq(unsigned short p_uid)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_uid = p_uid;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("insert casino.payment_request "
					    "SELECT NULL, ID_Player, casino_id, NULL, Amount, 'S', NULL "
					    "FROM casino.PlayerState WHERE ID_Player = ?");
        prep_stmt->setUInt(1,lv_uid);
        lv_ec = prep_stmt->executeUpdate();

        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode();
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
    return lv_ec;

}

int CDb::setPlayerError(unsigned short p_uid, int p_error_reason)
{
    int lv_ec = 1;
    sql::PreparedStatement *prep_stmt;
    unsigned int lv_uid = p_uid;

    try
    {
        reconnect_if_close();
        prep_stmt = m_con->prepareStatement("UPDATE casino.Users SET error = 'S', error_reason = ? WHERE id = ?");
        prep_stmt->setInt(1,p_error_reason);
        prep_stmt->setUInt(2,lv_uid);
        lv_ec = prep_stmt->executeUpdate();
        delete prep_stmt;
    }
    catch(sql::SQLException &e)
    {
        std::cout << "# ERR: SQLException in " << __FILE__;
        std::cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
        std::cout << "# ERR: " << e.what();
        std::cout << " (MySQL error code: " << e.getErrorCode(); 
        std::cout << ", SQLState: " << e.getSQLState() << " )" << endl;
        exit(1);
    }
}

/** @brief (one liner)
  *
  * (documentation goes here)
  */
CDbResult* CDb::Query(const char *p_fields, const char *p_from, const char *p_where)
{
    std::stringstream lv_sql;
    std::auto_ptr< sql::Statement > lv_stmt(m_con->createStatement());
    sql::ResultSet *lv_rs;
    CDbResult *lv_db_rs;

    lv_sql << "SELECT " ;
    lv_sql << p_fields ;
    lv_sql << "FROM " ;
    lv_sql << p_from ;
    lv_sql << "WHERE " ;
    lv_sql << p_where;

    lv_rs = lv_stmt->executeQuery(lv_sql.str());
    lv_db_rs = new CDbResult();
    lv_db_rs->setRs(lv_rs);

    return lv_db_rs;
}