var fs = require('fs');
var crypto = require('crypto');
var request = require('request');
var log4js = require('log4js');
var sha256 = require('sha256');
var express = require('express');
var randomMath_questions = require('random-math-question');
var randomWord = require('random-word');
var config = require('./config.js');
var options = {
    key: fs.readFileSync('echo.key'),
    cert: fs.readFileSync('echo.crt'),
    requestCert: false
};
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io').listen(server);
server.listen(6969, '0.0.0.0');
var ExpressTrade = require('expresstrade');

var ET = new ExpressTrade({
    apikey: config.vgo_api_key,
    twofactorsecret: config.secret,
    pollInterval: config.poll_interval
});

log4js.configure({
    appenders: {
        console: {
            type: 'console'
        },
        default: {
            type: 'file',
            filename: 'logs/main_'+time()+'.log'
        }
    },
    categories: {
        default: {
            appenders: ['default', 'console'],
            level: 'trace'
        }
    }
});
var logger = log4js.getLogger();

var mysql = require('mysql');
var db_config = {
    host: config.sql.host,
    user: config.sql.user,
    password: config.sql.password,
    database: config.sql.database
};
var pool;

check_errors();
database_connection();

//global vars
var socketids = {};
var sockets = {};
var ssockets = {};
var users = {};
var chat_msgs = [];
var anti_spam_chat = {};
var tokens = {};
var users_inventory = {};
var website_inventory = [];
var website_inv_raffles = [];
var items_gone = [];
var pending_deposit = {};
var pending_withdraw = {};
var pending_raffle = {};
var user_pending_deposit = {};
var user_pending_withdraw = {};
//global vars

// roulette
var currentMode = 'NONE';
var betsUsers = {};
var currentBets = [];
var currentTimer = 200;
var currentLastNumber = -1;
var currentLastWooble = -1;
var currentHash = "";
var currentSecret = "";
var currentLottery = "";
var lastRolls = [];
var allLastRolls = [];
var minBet = 10;
var maxBet = 5000000;
var roulette_bet_color = {};
//

var Games_Work = true;

var AdminMode = {};
var antispam_user = {};

// CHAT MESSAGES
var id_chat_msgs = 0;
// CHAT MESSAGES

// PROMOTIONAL CODES
var Promotional_codes = {};
// PROMOTIONAL CODES

// Anti spam ENDPOINTS
var anti_spam_endpoints = {};
// Anti spam ENDPOINTS

// WITHDRAW
var Withdraw_disabled = false;
// WITHDRAW

// RAFFLES AUTO GENERATION
var GenerationRaffles = {
    'skins': {},
    'coins': {}
};
// RAFFLES AUTO GENERATION


//init
getLastRolls();
getAllLastRolls();
startRoulette();
//

var Chat_disabled = false;



// raffles
var Raffles = {
    List: {},
    Prizes: {},
    Prizess: {},
    WinnerSecret: {},
    Tipul: {},
    Joined: {},
    Colors: [
        '#F52222',
        '#FF03FF',
        '#8D03FF',
        '#0303FF',
        '#03C4FF',
        '#03F2FF',
        '#03FF96',
        '#22D628',
        '#75F50C',
        '#D6F50C',
        '#E0C71F',
        '#FF6A00'
    ]
};
resumeRaffles();
// raffles

// chat code
var ChatCodes = {
    code: null,
    prize: null,
    max_users: null,
    users: []
};
// chat code

// math code
var MathCodes = {
    question: null,
    answer: null,
    prize: null,
    max_users: null,
    users: []
}
// math code

// first to write
var FTWrite = {
    text: null,
    prize: null,
    enabled: false
};
// first to write

// Pinned message
var Pinned_msg = {
    default: config.default_pinned_msg,
    currently: null,
    last: null
};
//

//
var Useri_IP = {};
var ips = {};
//

// rain coins
var Rain = {
    enabled: false,
    interval: null,
    time: null,
    total_coins: 0,
    users_min: 5,
    coins_per_user_5: 10,
    coins_per_user_20: 20,
    coins_per_user_60: 40,
    coins_per_user_100: 60,
    time_to_wait: 0.75, // MINUTES
    time_to_rain: 0, // MINUTES
    users_joined: []
};
startRain();
// rain coins

var JmekWeek = false;

function startRain(timpul) {
    if(timpul > 0) var random_time = timpul;
    else var random_time = Math.floor(Math.random()*(10-3+1)+3);
    Rain.time_to_rain = random_time;

    Rain.enabled = false;
    Rain.interval = null;
    Rain.total_coins = 0;
    Rain.users_joined = [];
    Rain.time = time();

    logger.info('Rain will start in ' + random_time + ' minutes, if users online will be more than ' + Rain.users_min +'.');

    Rain.interval = setInterval(function() {
        if(Rain.enabled == false) {
            var users = Object.keys(ips).length;

            if(users > Rain.users_min) {
                clearInterval(Rain.interval);
                Rain.enabled = true;

                Rain.time = time();

                logger.info('Rain has started!');

                var $html = `
                    <p>COIN RAIN IS LIVE!</p>
                    <div id="join_rain" class="btn btn-sm btn-danger">JOIN RAIN</div>
                `;
                io.sockets.emit('user rain show', $html);

                setTimeout(function() {
                    stopRain();
                }, Rain.time_to_wait*60000);
            } else {
                Rain.time_to_rain = 5;
                logger.info('There was not enough players for rain to start. The rain will start in 5 minutes if users online will be more than ' + Rain.users_min + '.');
                clearInterval(Rain.interval);
                startRain(Rain.time_to_rain);
            }
        }
    }, Rain.time_to_rain*60000);
}

function stopRain() {
    logger.info('Rain has ended!');

    var total_users_joined = Rain.users_joined.length;

    for(var i = 0; i < total_users_joined; i++) {
        if(total_users_joined >= 1 && total_users_joined < 5) Rain.total_coins += Rain.coins_per_user_5;
        else if(total_users_joined >= 5 && total_users_joined < 60) Rain.total_coins += Rain.coins_per_user_20;
        else if(total_users_joined >= 60 && total_users_joined < 100) Rain.total_coins += Rain.coins_per_user_60;
        else if(total_users_joined >= 100) Rain.total_coins += Rain.coins_per_user_100;
    }

    var coins_per_user = parseInt(parseInt(Rain.total_coins)/parseInt(total_users_joined));

    // MAXIMUM COINS PER USER IS 1K ($1)
    if(coins_per_user >= 1000) coins = 1000;

    if(JmekWeek == true) coins_per_user = coins_per_user*2;

    for(var h in Rain.users_joined) {
        var user = Rain.users_joined[h];
        pool.query('UPDATE users SET balance = balance + ' + pool.escape(coins_per_user) + ' WHERE steamid = ' + pool.escape(user), function(er, ro) {

        });

        addLog(user, 'rain_ended', '+' + coins_per_user, 'Received ' + coins_per_user + ' from Rain!', function() {

        });

        var socketul = ssockets[user];
        if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'You have successfully received <b>' + coins_per_user + '</b> coins from the Rain!', 'balance');
    }

    var $html = `
        <p>A total of <span style="font-weight: 500;">` + Rain.users_joined.length + `</span> users received <span style="font-weight: 500;">` + parseInt(Rain.total_coins) + `</span> coins.</p>
    `;
    io.sockets.emit('user rain show', $html);

    setTimeout(function() {
        io.sockets.emit('user rain hide');
    }, 12500);

    Rain.enabled = false;
    Rain.interval = null;
    Rain.total_coins = 0;
    Rain.users_joined = [];
    startRain();
}

io.on('connection', function(socket) {
    socket.on('login', function(token) {

        //console.log(socket.handshake.headers);

        if(!ips.hasOwnProperty(socket.handshake.headers['x-forwarded-for'])) ips[socket.handshake.headers['x-forwarded-for']] = 1;

        pool.query('SELECT steamid, name, ban, avatar, balance, rank, mute, available, aff, affs, wagered, wags, wwags, steam_level, deps, withs, withamount, can_withdraw, affamount, depamount, affcollected, dailygift, hourlygift, redeemed_code, last FROM users WHERE token = ' + pool.escape(token), function(err, row) {
            if(err) throw err;
            // not logged in

            socketids[socket.id] = token;
            sockets[token] = socket.id;
            io.sockets.emit('website users online', Object.keys(ips).length);
            if(chat_msgs.length > 0) socket.emit('website chat history', chat_msgs, false);

            currentBets.forEach(function(item) {
                socket.emit('roulette_newbet', item.bet, item.color, item.user, item.avatar, item.name);
            });

            totalRollsAll(function(red, green, black) {
                socket.emit('roulette 100 rolls', red, green, black);
            });

            socket.emit('roulette_addroll', lastRolls);
            // socket.emit('roulette_hash', currentHash);
            socket.emit('roulette_start', currentTimer, currentLastNumber, currentLastWooble, currentHash);

            // not logged in
            if(row.length == 0) return;

            if(row[0].ban == 1) {
                logger.error('User ' + row[0].steamid + ' (' + row[0].name + ') [banned] tried to connect to server, but kicked and logged out automatically!');
                pool.query('UPDATE users SET token = 0 WHERE steamid = ' + pool.escape(row[0].steamid), function(e,r) {
                    socket.emit('user refresh');
                })
                return;
            }

            //logged in
            users[token] = {
                steamid: row[0].steamid,
                name: row[0].name,
                avatar: row[0].avatar,
                balance: parseInt(row[0].balance),
                rank: row[0].rank,
                mute: row[0].mute,
                promocode: null,
                deps: row[0].deps,
                depamount: parseInt(row[0].depamount),
                aff: row[0].aff,
                affs: row[0].affs,
                withs: row[0].withs,
                withamount: parseInt(row[0].withamount),
                can_withdraw: row[0].can_withdraw,
                affamount: row[0].affamount,
                affcollected: row[0].affcollected,

                available: parseInt(row[0].available),
                wagered: parseInt(row[0].wagered),

                wags: parseInt(row[0].wags),
                wwags: parseInt(row[0].wwags),

                dailygift: parseInt(row[0].dailygift),
                hourlygift: parseInt(row[0].hourlygift),
                redeemed_code: row[0].redeemed_code
            };
            tokens[row[0].steamid] = token;
            ssockets[row[0].steamid] = socket.id;

            Useri_IP[socket.handshake.headers['x-forwarded-for']] = {
                name: users[token].name,
                steamid: users[token].steamid,
                avatar: users[token].avatar,
                rank: users[token].rank
            };

            socket.emit('raffles add raffles', Raffles.List);

            var $html = `
                <p>COIN RAIN IS LIVE!</p>
                <div id="join_rain" class="btn btn-sm btn-danger">JOIN RAIN</div>
            `;
            if(Rain.users_joined.indexOf(users[token].steamid) == -1 && Rain.enabled == true) socket.emit('user rain show', $html);
            else if(Rain.users_joined.indexOf(users[token].steamid) > -1 && Rain.enabled == true) {
                var $html = `
                    <p>WAITING FOR PLAYERS TO JOIN...</p>
                `;
                socket.emit('user rain show', $html);
            }

            if(Raffles.Prizess.hasOwnProperty(users[token].steamid)) {
                for(var z in Raffles.Prizess[users[token].steamid]) {
                    var id = Raffles.Prizess[users[token].steamid][z];
                    socket.emit('user raffle prize settings', id, id, Raffles.Prizes[id]);
                }
            }

            if(users[token].redeemed_code != '') socket.emit('user aff code', users[token].redeemed_code);

            if(Pinned_msg.currently != null) socket.emit('user pinned msg', Pinned_msg.currently);

            if(users[token].promocode == null) {
                pool.query('SELECT code FROM codes WHERE user = ' + pool.escape(users[token].steamid), function(err, row) {
                    if(row.length > 0) users[token].promocode = row[0].code;

                    pool.query('SELECT COUNT(id) AS depositors FROM users WHERE deps >= 1 AND aff = ' + pool.escape(users[token].steamid), function(ah, uh) {
                        checkWebsiteLevel(token, function(level) {
                            var $color = '';

                            if(level >= 0 && level <= 4) $color = '#919191';
                            else if(level >= 5 && level <= 9) $color = '#2F65FA';
                            else if(level >= 10) $color = '#FC3232';

                            users[token].xp_level = level;
                            users[token].xp_color = $color;
                            users[token].affdepositors = uh[0].depositors;

                            socket.emit('user info', users[token]);

                            socket.emit('user settings', 'dailygift', parseInt(parseInt(users[token].dailygift)-time()), getDailyReward(token));
                            socket.emit('user settings', 'hourlygift', parseInt(parseInt(users[token].hourlygift)-time()));
                        });
                    });
                });
            }

            var timp = row[0].last+43200;

            if(timp-time() <= 0) {
                checkSteamLevel(row[0].steamid, function(level) {
                    pool.query('UPDATE users SET steam_level = ' + pool.escape(level) + ', last = ' + pool.escape(time()) + ' WHERE token = ' + pool.escape(token), function(eee) {
                        if(eee) return;

                        users[token].level = level;
                    });
                });
            }
        });
    });
    //



    var Minesweeper = {};
    var User_minesweeper = {};


    socket.on('mines', function(type, mtype, amount, token) {
        if(users.hasOwnProperty(token)) {
            if(type == "play") {
                var types = [1,3,5,24];
                var type_found = false;
                for(var i in types) {
                    if(types[i] == mtype) type_found = true;
                }

                if(type_found == false) return socket.emit('user eroare', 'This type is invalid!');

                if(User_minesweeper.hasOwnProperty(users[token].steamid)) return socket.emit('user eroare', 'You are already in a game!');

                if(amount > 0) {
                    user_balance_check(token, function(er, bal) {
                        if(bal < amount) return socket.emit('user eroare', 'You do not have enough balance to play mines!');

                        var hash;
                        var all_tiles = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25];
                        var bombs = [];
                        var secret = makeSecret();

                        if(mtype == 1) bombs.push(Math.floor(Math.random() * (25 - 1 + 1)) + 1);
                        else if(mtype == 3) {
                            do {
                                bombs[bombs.length] = all_tiles.splice(Math.floor(Math.random() * all_tiles.length), 1)[0];
                              } while (bombs.length < 3);
                        } else if(mtype == 5) {
                            do {
                                bombs[bombs.length] = all_tiles.splice(Math.floor(Math.random() * all_tiles.length), 1)[0];
                              } while (bombs.length < 5);
                        } else {
                            do {
                                bombs[bombs.length] = all_tiles.splice(Math.floor(Math.random() * all_tiles.length), 1)[0];
                              } while (bombs.length < 24);
                        }

                        hash = encrypt(secret, bombs.join('|'));

                        pool.query('UPDATE users SET balance = balance - ? WHERE token = ?', [amount, token], function(e,r) {
                            if(e) throw e;

                            pool.query('INSERT INTO mines SET user = ?, bombs = ?, type = ?, amount = ?', [users[token].steamid, bombs.join('|'), mtype, amount], function(e, rr) {
                                if(e) throw e;

                                user_balance_check(token, function(er, ball) {
                                    Minesweeper[rr.insertId] = {
                                        id: rr.insertId,
                                        user: users[token].steamid,
                                        hash: hash,
                                        secret: secret,
                                        bombs: bombs,
                                        type: mtype,
                                        amount: amount
                                    };

                                    console.log(Minesweeper[rr.insertId]);

                                    User_minesweeper[users[token].steamid] = rr.insertId;

                                    socket.emit('mines', 'play', rr.insertId, hash);

                                    socket.emit('user balance', ball);
                                });
                            });
                        });
                    });
                }
            } else if(type == "gettile") {
                var tile = mtype;
                var game = Minesweeper[amount];
                var tile_clicked_already = false;
                var bomb_checked = false;

                if(User_minesweeper.hasOwnProperty(users[token].steamid)) {
                    if(game.hasOwnProperty('tiles')) {
                        for(var i in game.tiles) {
                            if(game.tiles[i] == tile) tile_clicked_already = true;
                        }
                    }

                    if(tile_clicked_already == true) return socket.emit('user eroare', 'You have already checked this tile!');

                    for(var i in game.bombs) {
                        if(game.bombs[i] == tile) bomb_checked = true;
                    }

                    if(!game.hasOwnProperty('tiles')) {
                        Minesweeper[amount].tiles = [];
                        Minesweeper[amount].tiles.push(tile);
                    } else Minesweeper[amount].tiles.push(tile);

                    if(bomb_checked == true) {
                        pool.query('UPDATE mines SET win = 0, won_amount = 0, tiles_clicked = ? WHERE id = ?', [Minesweeper[amount].tiles.join('|'), game.id], function(aa) {

                        });
                        socket.emit('mines', 'finished', game.secret, game.bombs, 'lost');
                        delete User_minesweeper[users[token].steamid];
                        return;
                    }

                    var curr_amount = game.amount;
                    var _winning_amount = parseInt(curr_amount * ((game.tiles.length) / 250 * (game.type * 1.3)));

                    if(game.type == 24) _winning_amount = curr_amount * 24;

                    if(!game.hasOwnProperty('winning_amount')) Minesweeper[amount].winning_amount = _winning_amount;
                    else Minesweeper[amount].winning_amount = parseInt(Minesweeper[amount].winning_amount) + _winning_amount;

                    Minesweeper[amount]._win_amount = parseInt(Minesweeper[amount].winning_amount) + parseInt(Minesweeper[amount].amount);

                    if(Minesweeper[amount].type == 1 && Minesweeper[amount].tiles.length == 24) {
                        pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [Minesweeper[amount]._win_amount, token], function(e,r) {
                            if(e) throw e;

                            pool.query('UPDATE mines SET win = 1, won_amount = ?, tiles_clicked = ? WHERE id = ?', [game.id, Minesweeper[amount]._win_amount, Minesweeper[amount].tiles.join('|')], function(aa) {

                            });

                            user_balance_check(token, function(er, ball) {
                                socket.emit('user balance', ball);
                                socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                                socket.emit('mines', 'finished', game.secret, game.bombs, 'won', Minesweeper[amount]._win_amount);
                                socket.emit('user alerta', 'You have cashed out the mines game #' + game.id + ' and won ' + Minesweeper[amount]._win_amount);
                                delete User_minesweeper[users[token].steamid];
                            });

                            return;
                        });
                    } else if(Minesweeper[amount].type == 3 && Minesweeper[amount].tiles.length == 22) {
                        pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [Minesweeper[amount]._win_amount, token], function(e,r) {
                            if(e) throw e;

                            pool.query('UPDATE mines SET win = 1, won_amount = ?, tiles_clicked = ? WHERE id = ?', [game.id, Minesweeper[amount]._win_amount, Minesweeper[amount].tiles.join('|')], function(aa) {

                            });

                            user_balance_check(token, function(er, ball) {
                                socket.emit('user balance', ball);
                                socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                                socket.emit('mines', 'finished', game.secret, game.bombs, 'won', Minesweeper[amount]._win_amount);
                                socket.emit('user alerta', 'You have cashed out the mines game #' + game.id + ' and won ' + Minesweeper[amount]._win_amount);
                                delete User_minesweeper[users[token].steamid];
                            });

                            return;
                        });
                    } else if(Minesweeper[amount].type == 5 && Minesweeper[amount].tiles.length == 20) {
                        pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [Minesweeper[amount]._win_amount, token], function(e,r) {
                            if(e) throw e;

                            pool.query('UPDATE mines SET win = 1, won_amount = ?, tiles_clicked = ? WHERE id = ?', [game.id, Minesweeper[amount]._win_amount, Minesweeper[amount].tiles.join('|')], function(aa) {

                            });

                            user_balance_check(token, function(er, ball) {
                                socket.emit('user balance', ball);
                                socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                                socket.emit('mines', 'finished', game.secret, game.bombs, 'won', Minesweeper[amount]._win_amount);
                                socket.emit('user alerta', 'You have cashed out the mines game #' + game.id + ' and won ' + Minesweeper[amount]._win_amount);
                                delete User_minesweeper[users[token].steamid];
                            });

                            return;
                        });
                    } else if(Minesweeper[amount].type == 24 && Minesweeper[amount].tiles.length == 1) {
                        pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [Minesweeper[amount]._win_amount, token], function(e,r) {
                            if(e) throw e;

                            pool.query('UPDATE mines SET win = 1, won_amount = ?, tiles_clicked = ? WHERE id = ?', [game.id, Minesweeper[amount]._win_amount, Minesweeper[amount].tiles.join('|')], function(aa) {

                            });

                            user_balance_check(token, function(er, ball) {
                                socket.emit('user balance', ball);
                                socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                                socket.emit('mines', 'finished', game.secret, game.bombs, 'won', Minesweeper[amount]._win_amount);
                                socket.emit('user alerta', 'You have cashed out the mines game #' + game.id + ' and won ' + Minesweeper[amount]._win_amount);
                                delete User_minesweeper[users[token].steamid];
                            });

                            return;
                        });
                    }

                    socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                } else socket.emit('user eroare', 'You are not in a mines game!');
            } else if(type == "cashout") {
                var amount = mtype;

                if(Minesweeper.hasOwnProperty(amount) && User_minesweeper.hasOwnProperty(users[token].steamid)) {
                    var game = Minesweeper[amount];

                    pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [Minesweeper[amount]._win_amount, token], function(e,r) {
                        if(e) throw e;

                        pool.query('UPDATE mines SET win = 1, won_amount = ?, tiles_clicked = ? WHERE id = ?', [game.id, Minesweeper[amount]._win_amount, Minesweeper[amount].tiles.join('|')], function(aa) {
                            if(aa) throw aa;
                        });

                        user_balance_check(token, function(er, ball) {
                            socket.emit('user balance', ball);
                            socket.emit('mines', 'gettile', tile, _winning_amount, Minesweeper[amount]._win_amount);
                            socket.emit('mines', 'finished', game.secret, game.bombs, 'won', Minesweeper[amount]._win_amount);
                            socket.emit('user alerta', 'You have cashed out the mines game #' + game.id + ' and won ' + Minesweeper[amount]._win_amount);
                            delete User_minesweeper[users[token].steamid];
                        });
                    });
                } else socket.emit('user eroare', 'You are not in a mines game!');
            }
        }
    });

    var Dice_playing = {};


    socket.on('dice', function(amount, chance, type, token) {
        if(users.hasOwnProperty(token)) {
            var types = ['over', 'under'];
            var type_accepted = false;
            for(var i in types) {
                if(type == types[i]) type_accepted = true;
            }

            if(Dice_playing.hasOwnProperty(token)) return socket.emit('user eroare', 'Wait until the last round of dice is ended!');

            if(type_accepted == false) return socket.emit('user eroare', 'The type is not accepted!');

            if(type == "under" && (chance < 0.01 || chance > 94.00)) return socket.emit('user eroare', 'Something is wrong with your game, try again!');
            if(type == "over" && (chance < 6.00 || chance > 99.99)) return socket.emit('user eroare', 'Something is wrong with your game, try again!');

            user_balance_check(token, function(er, bal) {
                socket.emit('user balance', bal);
                if(bal < amount) return socket.emit('user eroare', 'You do not have enough balance to play dice!');

                Dice_playing[token] = 1;

                pool.query('UPDATE users SET balance = balance - ? WHERE token = ?', [amount, token], function(errr) {
                    if(errr) throw errr;

                        socket.emit('user balance', parseInt(bal-parseInt(amount)));

                        var hash;
                        var secret = makeSecret();
                        var generated_number;
                        if(type == "under") generated_number = parseFloat(parseFloat(Math.random() * (94.00 - 0.01) + 0.01).toFixed(2));
                        else if(type == "over") generated_number = parseFloat(parseFloat(Math.random() * (99.99 - 6.00) + 6.00).toFixed(2));

                        hash = encrypt(secret, generated_number.toString());

                        socket.emit('dice', 'hash', hash);

                        setTimeout(function() {
                            if(type == "under" && generated_number <= chance) {
                                var multiplier = parseFloat(parseFloat(95 / chance).toFixed(2));
                                var won_amount = parseInt(amount * multiplier);

                                pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [parseInt(won_amount), token], function(e,r) {
                                    if(e) throw e;

                                    pool.query('INSERT INTO dice SET user = ?, type = ?, amount = ?, amount_won = ?, gnumber = ?, chance = ?, won = 1', [users[token].steamid, type, amount, won_amount, generated_number, chance], function(er, ro) {
                                        if(er) throw er;
                                    });

                                    user_balance_check(token, function(er, ball) {
                                        socket.emit('user balance', ball);
                                        socket.emit('dice', 'won', secret, generated_number, multiplier, won_amount);
                                    });

                                });
                            } else if(type == "over" && generated_number >= chance) {
                                var multiplier = parseFloat(parseFloat(95 / chance).toFixed(2));
                                var won_amount = parseInt(amount * multiplier);

                                pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [parseInt(won_amount), token], function(e,r) {
                                    if(e) throw e;


                                    pool.query('INSERT INTO dice SET user = ?, type = ?, amount = ?, amount_won = ?, gnumber = ?, chance = ?, won = 1', [users[token].steamid, type, amount, won_amount, generated_number, chance], function(er, ro) {
                                        if(er) throw er;
                                    });

                                    user_balance_check(token, function(er, ball) {
                                        socket.emit('user balance', ball);
                                        socket.emit('dice', 'won', secret, generated_number, multiplier, won_amount);
                                    });
                                });
                            } else {

                                pool.query('INSERT INTO dice SET user = ?, type = ?, amount = ?, amount_won = 0, gnumber = ?, chance = ?, won = 0', [users[token].steamid, type, amount, generated_number, chance], function(er, ro) {
                                    if(er) throw er;
                                });

                                socket.emit('dice', 'lost', secret, generated_number, multiplier);
                            }

                            delete Dice_playing[token];
                        }, 1500);
                });

            });
        }
    });


























    // ADMIN USERS ONLINE
    socket.on('admin want users online', function(token) {
        if(users.hasOwnProperty(token) && users[token].rank == 100) {
            sendUsersOnline(socket);
        }
    });
    // ADMIN USERS ONLINE

    // G RECAPTCHA
    socket.on('g-recaptcha-response', function(response, token) {
        if(users.hasOwnProperty(token)) {
            var url = 'https://www.google.com/recaptcha/api/siteverify?secret=' + config.recaptcha.secret + '&response=' + response;
            request(url, function(err, resp, body) {
                var bod = JSON.parse(body);
                if(bod.success == true) {
                    if(Rain.users_joined.indexOf(users[token].steamid) == -1) {
                        if(Rain.enabled == true) {
                            Rain.users_joined.push(users[token].steamid);
                            socket.emit('user alerta', 'You have successfully entered in rain!');
                            logger.info('User ' + users[token].name + ' has joined the Rain!');

                            var $html = `
                                <p>WAITING FOR PLAYERS TO JOIN...</p>
                            `;
                            socket.emit('user rain show', $html);

                        } else socket.emit('user eroare', 'There is no rain active!');
                    } else socket.emit('user eroare', 'You are already in rain!');
                }
            });
        }
    });
    // G RECAPTCHA

    // JOIN RAIN
    socket.on('user want join rain', function(token) {
        if(users.hasOwnProperty(token) && token) {
            socket.emit('use render recaptcha', config.recaptcha.sitekey);
        }
    });
    // JOIN RAIN

    // AFF LINK
    socket.on('aff link', function(code, token) {
        if(users.hasOwnProperty(token) && code && token) {
            if(users.hasOwnProperty(token)) {
                if(users[token].redeemed_code == '') {
                    pool.query('SELECT user FROM codes WHERE code = ' + pool.escape(code), function(err, row) {
                        if(err) return logger.trace(users[token].steamid + ' aff link err - 1');
                        if(row.length == 0) return;

                        pool.query('SELECT name FROM users WHERE steamid = ' + pool.escape(row[0].user), function(er, ro) {
                            if(er) return;
                            if(ro.length == 0) return;
                            socket.emit('user get aff link', ro[0].name, code);
                        });
                    });
                }
            }
        }
    });
    // AFF LINK

    // PINNED MSG
    socket.on('admin set pin msg', function(msg, token) {
        if(users.hasOwnProperty(token) && token) {
            if(users[token].rank == 100) {
                if(msg == '') {
                    Pinned_msg.currently = null;
                    socket.emit('user alerta', 'You have changed the pin to default!');
                    io.sockets.emit('user pinned msg', Pinned_msg.default);
                } else {
                    Pinned_msg.currently = msg;
                    Pinned_msg.last = users[token].steamid;
                    socket.emit('user alerta', 'You have changed the pin to "' + Pinned_msg.currently + '" !');
                    io.sockets.emit('user pinned msg', Pinned_msg.currently);
                }
            }
        }
    });
    // PINNED MSG

    // RAFFLES22
    socket.on('user want raffles history', function(token) {
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                pool.query('SELECT * FROM raffles_entries WHERE user = ' + pool.escape(users[token].steamid) + ' AND ended = 1 ORDER BY time DESC LIMIT 80', function(err, row) {
                    if(err) return logger.trace(users[token].steamid + ' - raffle history error - 1');
                    if(row.length == 0) return;

                    socket.emit('user raffles history', row);
                });
            });
        }
    });

    socket.on('raffle get fair', function(id, token) {
        if(users.hasOwnProperty(token) && id && token) {
            pool.query('SELECT hash, secrets, secret_winner, ended FROM raffles WHERE id = ' + pool.escape(id), function(er, ro) {
                if(er) throw er;
                if(ro.length == 0) return;

                socket.emit('raffle fair check', ro[0]);
            });
        }
    });

    socket.on('admin add raffle', function(id, name, image, price, slots, token) {
        if(users.hasOwnProperty(token) && id && name && image && price && slots && token) {
            if(users[token].rank == 100) {
                createRaffle(name, image, price, id, slots, socket, 1);
            }
        }
    });

    socket.on('raffle user join', function(id, slots, token) {
        logger.trace('[RAW] raffle user join');
		logger.trace(id);
		logger.trace(slots);
		logger.trace(token);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && id && slots && token) {
            antiSpam(socket, token, function() {
                if(Games_Work == false) return socket.emit('user eroare', 'The raffles are closed!');
                joinRaffle(id, slots, token, socket);
            });
        }
    });

    socket.on('user raffles quick join', function(id, token) {
        logger.trace('[RAW] user raffles quick join');
		logger.trace(id);
		logger.trace(token);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && id && token) {
            antiSpam(socket, token, function() {
                if(Games_Work == false) return socket.emit('user eroare', 'The raffles are closed!');

                var busy_slots = [];
                var free_slots = [];

                var sslots = Raffles.List[id].sslots;
                var slots = Raffles.List[id].slots;

                for(var h in sslots) {
                    busy_slots.push(sslots[h]);
                }

                for(var f = 0; f < slots; f++) {
                    if(busy_slots.indexOf(f) > -1) continue;
                    free_slots.push(f);
                }

                var random_slot_pick = [];
                random_slot_pick.push(free_slots[Math.floor(Math.random()*(free_slots.length-1-0+1)+0)]);


                if(free_slots.length == 0) return socket.emit('user eroare', 'There is no slot active!');

                joinRaffle(id, random_slot_pick, token, socket);
            });
        }
    });

    socket.on('raffle prize get coins', function(rafid, token) {
        logger.trace('[RAW] raffle prize get coins');
		logger.trace(rafid);
		logger.trace(token);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && rafid && token) {
            antiSpam(socket, token, function() {
                if(Raffles.Prizes.hasOwnProperty(rafid)) {
                    if(Raffles.Tipul[rafid] != 0) coins = parseInt(Raffles.Prizes[rafid].price*1.03);
                    else return socket.emit('user eroare', 'An error occurred claiming coins from the raffle. Contact an admin!');

                    addLog(users[token].steamid, 'get_coins_raffle', '+' + coins, 'User got coins from a skin raffle.(' + coins + ')', function() {
                        pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(coins)) + ' WHERE steamid = ' + pool.escape(users[token].steamid), function(er, ro) {
                            if(er) throw er;

                            user_balance_check(token, function(errr, bal) {
                                pool.query('UPDATE raffles SET winner_tradeid = 0, winner_status = 1, winner_statustext = "GOT_COINS" WHERE id = ' + pool.escape(rafid), function(e,r) {
                                    logger.error('User ' + users[token].steamid + ' (' + users[token].name + ') got ' + coins + ' coins ($' + parseFloat(coins/1000).toFixed(2) + ') from raffle #' + rafid);

                                    website_inv_raffles.splice(website_inv_raffles.indexOf(Raffles.Prizes[rafid].id), 1);

                                    delete Raffles.Prizes[rafid];
                                    socket.emit('raffle coins got', coins);

                                    socket.emit('user balance', bal);
                                    Raffles.Prizess[users[token].steamid].splice(Raffles.Prizess[users[token].steamid].indexOf(rafid), 1);
                                });
                            });
                        });
                    });
                }
            });
        }
    });

    socket.on('raffle prize get withdraw', function(rafid, token) {
        logger.trace('[RAW] raffle prize get withdraw');
		logger.trace(rafid);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && rafid && token) {
            antiSpam(socket, token, function() {
                if(Raffles.Prizes.hasOwnProperty(rafid)) {

                    var prize = parseInt(Raffles.Prizes[rafid].price);

                    pool.query('SELECT disabled_withdraw FROM users WHERE steamid = ' + pool.escape(users[token].steamid), function(a, bb) {
                        if(a) return;

                        if(bb[0].disabled_withdraw == 1) return socket.emit('user eroare', 'You can\'t withdraw raffle prize!');

                        if(Raffles.Prizes[rafid].id == 0) return socket.emit('user eroare', 'This raffle item is not withdrawable!');
                        if(users[token].depamount < 5000) return socket.emit('user eroare', 'You need to deposit at least $5,00 in order to withdraw this prize!');
                        if((users[token].rank == 10 || users[token].rank == 11 || users[token].rank == 12) && users[token].can_withdraw == 0) return socket.emit('user eroare', 'You are not able to withdraw items!');

                        ET.ITrade.SendOfferToSteamId({
                            'steam_id': users[token].steamid,
                            'items_to_send': Raffles.Prizes[rafid].id,
                            'message': config.site_name + ' | Withdraw raffle prize from raffle id #' + rafid
                        }, (err, body) => {
                            if(err) return socket.emit('user eroare', 'Something happened sending your prize. Try again!');

                            if(body.response.offer.state == 2) {

                                var string = 'raffle';
                                if(users[token].rank == 100) string = 'Araffle';

                                addNewTrade(body.response.offer.id, string, Raffles.Prizes[rafid].id, token, function(err) {
                                    if(err) return logger.error(err + ' [RAFFLE]');

                                    editTradeAmount(body.response.offer.id, prize, function(er2) {
                                        if(er2) return logger.error(er2 + ' [RAFFLE]');

                                        pool.query('UPDATE raffles SET winner_tradeid = ' + pool.escape(body.response.offer.id) + ', winner_statustext = "PENDING_TRADE" WHERE id = ' + pool.escape(rafid), function(e,r) {
                                            delete Raffles.Prizes[rafid];
                                            Raffles.Prizess[users[token].steamid].splice(Raffles.Prizess[users[token].steamid].indexOf(rafid), 1);

                                            logger.error('User ' + users[token].steamid + ' (' + users[token].name + ') withdrew raffle #' + rafid + ' prize worth of $' + parseFloat(prize/1000).toFixed(2));

                                            socket.emit('user raffle prize successfully', body.response.offer.id, prize, 1);

                                            pending_raffle[body.response.offer.id] = {
                                                user: users[token].steamid,
                                                amount: prize,
                                                raffle_id: rafid
                                            };
                                        });
                                    });
                                });
                            }
                        });
                    });
                }
            });
        }
    });

    // RAFFLES22


    // DAILY FREE
    socket.on('user daily free', function(token) {
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                var nume = users[token].name.toLowerCase();
                if(nume.includes(config.site_name.toLowerCase())) {
                    if(users[token].dailygift-time() <= 0) {
                        if(users[token].deps < 1) return socket.emit('user eroare', 'You need to make at least one deposit<br>Click <b>"How do I claim this"</b> for more informations about claiming daily free.');
                        if(users[token].level < 4) return socket.emit('user eroare', 'You need to have at least Steam Level 4<br>Click <b>"How do I claim this"</b> for more informations about claiming daily free.');

                        var reward = getDailyReward(token);

                        addLog(users[token].steamid, 'get_daily_free', '+' + reward, 'Got +' + reward + ' from daily free.',function() {
                            pool.query('UPDATE users SET balance = balance + ' + pool.escape(reward) + ', dailygift = ' + pool.escape(time()+86400) + ' WHERE token = ' + pool.escape(token), function(err, row) {
                                if(err) throw err;

                                user_balance_check(token, function(er, bal) {
                                    users[token].dailygift = time()+86400;
                                    users[token].balance = bal;
                                    socket.emit('user balance', users[token].balance);

                                    socket.emit('user settings', 'dailygift', parseInt(parseInt(users[token].dailygift)-time()), getDailyReward(token));

                                    socket.emit('user alerta', 'You have successfully claimed ' + reward + ' coins from the daily free!');

                                    logger.trace('User ' + users[token].steamid + ' (' + users[token].name + ') successfully got ' + reward + ' (level: ' + users[token].xp_level + ') coins from daily gift!');
                                });
                            });
                        });
                    } else return socket.emit('user eroare', 'You have claimed daily free for this day!');
                } else return socket.emit('user eroare', 'You need to have <b>' + config.site_name + '</b> in your name<br>Click <b>"How do I claim this"</b> for more informations about claiming daily free.');
            });
        }
    });
    // DAILY FREE


    // HOURLY GIFT FREE
    socket.on('user hourly free', function(token) {
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                if(users[token].hourlygift-time() <= 0) {
                    if(users[token].deps < 1) return socket.emit('user eroare', 'You need to make at least one deposit<br>Click <b>"How do I claim this"</b> for more informations about claiming hourly free.');
                    if(users[token].level < 4) return socket.emit('user eroare', 'You need to have at least Steam Level 4<br>Click <b>"How do I claim this"</b> for more informations about claiming hourly free.');
                    antiSpamEndpoints(socket, token, function() {
                        gamesUserChecker(token, function(check) {
                            if(check == true) {
                                avatarUserChecker(token, function(check2) {
                                    if(check2 == true) {

                                        socket.emit('hourly free recaptcha', config.recaptcha.sitekey);

                                    } else return socket.emit('user eroare', 'You need to have our picture image as your Steam Profile picture<br>Click <b>"How do I claim this"</b> for more informations about claiming hourly free.');
                                });
                            } else return socket.emit('user eroare', 'You need to have 50+ hours (CS:GO, PUBG, Rust)<br>Click <b>"How do I claim this"</b> for more informations about claiming hourly free.');
                        });
                    });
                } else return socket.emit('user eroare', 'You have claimed hourly free for this hour!');
            });
        }
    });

    socket.on('hourly free get recaptcha', function(response, token) {
        if(users.hasOwnProperty(token) && response && token) {
            var url = 'https://www.google.com/recaptcha/api/siteverify?secret=' + config.recaptcha.secret + '&response=' + response;
            request(url, function(err, resp, body) {
                var bod = JSON.parse(body);
                if(bod.success == true) {
                    var random_coins = Math.floor(Math.random()*(30-20+1)+20);

                    addLog(users[token].steamid, 'get_hourly_free', '+' + random_coins, 'Hourly free, user received ' + random_coins,function() {
                        pool.query('UPDATE users SET balance = balance + ' + pool.escape(random_coins) + ', hourlygift = ' + pool.escape(time()+3600) + ' WHERE token = ' + pool.escape(token), function(err, row) {
                            if(err) throw err;

                            user_balance_check(token, function(er, bal) {
                                users[token].hourlygift = time()+3600;
                                users[token].balance = bal;
                                socket.emit('user balance', users[token].balance);

                                socket.emit('user settings', 'hourlygift', parseInt(parseInt(users[token].hourlygift)-time()));

                                socket.emit('user alerta', 'You have successfully claimed ' + random_coins + ' coins from the hourly free!');

                                logger.trace('User ' + users[token].steamid + ' (' + users[token].name + ') successfully got ' + random_coins + ' coins from hourly gift!');
                            });
                        });
                    });
                }
            });
        }
    });
    // HOURLY GIFT FREE


    // REFRESH BALANCE WANT USER
    socket.on('user want refresh balance', function(token) {
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                user_balance_check(token, function(err, bal) {
                    if(err) return socket.emit('user wanted refresh balance', err);
                    socket.emit('user wanted refresh balance', err, bal);
                });
            });
        }
    });
    // REFRESH BALANCE WANT USER

    socket.on('user get deposit inv', function(token) {
        if(users.hasOwnProperty(token)) {
            antiSpam(socket, token, function() {
                if(users.hasOwnProperty(token)) users_getInventory(token, socket, function(inv) {
                    socket.emit('user deposit inventory', inv);
                });
            });
        }
    });

    socket.on('user get withdraw inv', function(token) {
        if(users.hasOwnProperty(token)) {
            antiSpam(socket, token, function() {
                var inv = [];
                for(var z in website_inventory) {
                    for(var h in website_inv_raffles) {
                        if(website_inventory[z].id == website_inv_raffles[h]) website_inventory[z].ss = 1;
                    }
                }

                for(var z in website_inventory) {
                    if(website_inventory[z].ss != 1) inv.push(website_inventory[z]);
                }

                if(token) socket.emit('user withdraw inventory', inv);
            });
        }
    });

    socket.on('user get balance', function(token) {
        if(users.hasOwnProperty(token) && token) {
            user_balance_check(token, function(err, bal) {
                users[token].balance = bal;
                socket.emit('user balance', bal);
            });
        }
    });

    // ADMIN THINGS
    socket.on('admin get info', function(token) {
        if(users.hasOwnProperty(token) && token && users[token].rank == 100) {
            var stats = {
                deposits: {
                    _1day: 0,
                    _7days: 0,
                    _30days: 0,
                    _all: 0
                },
                withdraws: {
                    _1day: 0,
                    _7days: 0,
                    _30days: 0,
                    _all: 0
                }
            };

            pool.query(`
            SELECT ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-86400) + ` AND type = "deposit" AND status = "1" ) AS d_1day,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400)*7) + ` AND type = "deposit" AND status = "1" ) AS d_7days,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400)*30) + ` AND type = "deposit" AND status = "1" ) AS d_30days,
            ( SELECT SUM(amount) FROM trades WHERE type = "deposit" AND status = "1" ) AS d_all,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-86400) + ` AND ( type = "withdraw" OR type = "raffle" ) AND status = "1" ) AS w_1day,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400*7)) + ` AND ( type = "withdraw" OR type = "raffle" ) AND status = "1" ) AS w_7days,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400*30)) + ` AND ( type = "withdraw" OR type = "raffle" ) AND status = "1" ) AS w_30days,
            ( SELECT SUM(amount) FROM trades WHERE ( type = "withdraw" OR type = "raffle" ) AND status = "1" ) AS w_all`, function(err, row) {
                    if(err) throw err;
                    if(row.length == 0) {
                        socket.emit('admin info', stats);
                    } else {
                        stats.deposits._1day = row[0].d_1day;
                        stats.deposits._7days = row[0].d_7days;
                        stats.deposits._30days = row[0].d_30days;
                        stats.deposits._all = row[0].d_all;
                        stats.withdraws._1day = row[0].w_1day;
                        stats.withdraws._7days = row[0].w_7days;
                        stats.withdraws._30days = row[0].w_30days;
                        stats.withdraws._all = row[0].w_all;

                        socket.emit('admin info', stats);
                    }
                });
        }
    });

    socket.on('admin aget info', function(token) {
        if(users.hasOwnProperty(token) && token && users[token].rank == 100) {
            var stats = {
                adeposits: {
                    _1day: 0,
                    _7days: 0,
                    _14days: 0,
                    _all: 0
                },
                awithdraws: {
                    _1day: 0,
                    _7days: 0,
                    _14days: 0,
                    _all: 0
                }
            };

            pool.query(`
            SELECT ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-86400) + ` AND type = "Adeposit" AND status = "1" ) AS d_1day,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400)*7) + ` AND type = "Adeposit" AND status = "1" ) AS d_7days,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400)*14) + ` AND type = "Adeposit" AND status = "1" ) AS d_14days,
            ( SELECT SUM(amount) FROM trades WHERE type = "Adeposit" AND status = "1" ) AS d_all,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-86400) + ` AND ( type = "Awithdraw" OR type = "Araffle" ) AND status = "1" ) AS w_1day,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400*7)) + ` AND ( type = "Awithdraw" OR type = "Araffle" ) AND status = "1" ) AS w_7days,
            ( SELECT SUM(amount) FROM trades WHERE time >= ` + parseInt(time()-(86400*14)) + ` AND ( type = "Awithdraw" OR type = "Araffle" ) AND status = "1" ) AS w_14days,
            ( SELECT SUM(amount) FROM trades WHERE ( type = "Awithdraw" OR type = "Araffle" ) AND status = "1" ) AS w_all`, function(err, row) {
                    if(err) throw err;
                    if(row.length == 0) {
                        socket.emit('admin ainfo', stats);
                    } else {
                        stats.adeposits._1day = row[0].d_1day;
                        stats.adeposits._7days = row[0].d_7days;
                        stats.adeposits._14days = row[0].d_14days;
                        stats.adeposits._all = row[0].d_all;
                        stats.awithdraws._1day = row[0].w_1day;
                        stats.awithdraws._7days = row[0].w_7days;
                        stats.awithdraws._14days = row[0].w_14days;
                        stats.awithdraws._all = row[0].w_all;

                        socket.emit('admin ainfo', stats);
                    }
                });
        }
    });

    socket.on('admin website statistics', function(token) {
        if(users.hasOwnProperty(token) && token && users[token].rank == 100) {
            pool.query(`
            SELECT (SELECT COUNT(id) FROM users) AS users_registered,
            (SELECT COUNT(id) FROM users WHERE depamount >= 5000 AND rank = 0) as deposited_over,
            (SELECT COUNT(id) FROM users WHERE wagered >= 5000 AND rank = 0) as wagered_over,
            (SELECT COUNT(id) FROM users WHERE balance >= 5000 AND rank = 0) as balance_over,

            (SELECT SUM(amount) FROM bets) as roulette_total_bets_Amount,
            (SELECT COUNT(id) FROM bets) as roulette_total_bets_Count,

            (SELECT COUNT(id) FROM raffles) as raffles_made,
            (SELECT SUM(item_price) FROM raffles) as raffles_worth,
            (SELECT SUM(item_price)*slots FROM raffles WHERE ended = 1) as coins_wasted,

            (SELECT COUNT(id) FROM trades WHERE status = "1" AND type = "deposit") AS total_deposits_acc,
            (SELECT COUNT(id) FROM trades WHERE status = "1" AND ( type = "withdraw" OR type = "raffle" ) ) AS total_withdraws_acc,
            (SELECT COUNT(id) FROM trades WHERE status = "2" AND type = "deposit") AS total_deposits_dec,
            (SELECT COUNT(id) FROM trades WHERE status = "2" AND ( type = "withdraw" OR type = "raffle" ) ) AS total_withdraws_dec`, function(err, row) {
                if(err) throw err;
                if(row.length == 0) return;

                socket.emit('admin emit website statistics', row);
            });
        }
    });
    //



    // CHECK TRADE ID
    socket.on('admin check tid', function(tid, token) {
        if(users.hasOwnProperty(token) && tid && token) {
            if(users[token].rank == 100) {
                ET.ITrade.GetOffer({'offer_id': tid}, (err, body) => {
                    if(err) return socket.emit('user eroare', 'Error retrieving status of the offer<br>' + body.message);
                    socket.emit('user alerta', 'Trade #' + body.response.offer.id + ' have state: ' + body.response.offer.state + ' (' + body.response.offer.state_name + ')');
                });
            }
        }
    });
    // CHECK TRADE ID

    // GET SOME INFOS
    socket.on('admin get some info', function(token) {
        if(users.hasOwnProperty(token) && token) {
            if(users.hasOwnProperty(token) && users[token].rank == 100) {
                pool.query('SELECT SUM( balance ) AS balance_in_circulation, COUNT( id ) AS users_count FROM users WHERE rank = 0 AND balance > 0', function(err, row) {
                    if(err) throw err;

                    socket.emit('admin send some info', row[0].balance_in_circulation, row[0].users_count);

                });
            }
        }
    });
    // get some infos


    // REMOVE MESSAGES
    socket.on('admin remove msg', function(id_msg, token) {
        if(users.hasOwnProperty(token) && id_msg && token) {
            if(users[token].rank == 100 || users[token].rank == 1) {

                for (var i = chat_msgs.length - 1; i >= 0; --i) {
                    if (chat_msgs[i].id == id_msg) {
                        chat_msgs.splice(i,1);
                    }
                }

                io.sockets.emit('admin remove msg', id_msg);

                socket.emit('user alerta', 'Message of the user removed!');
            }
        }
    });

    socket.on('admin remove msgs', function(steamid, token) {
        if(users.hasOwnProperty(token) && steamid && token) {
            if(users[token].rank == 100 || users[token].rank == 1) {
                for(var i in chat_msgs) {
                    var steamid_chat = chat_msgs[i].steamid.toString();
                    var steamid_to_delete = steamid.toString();
                    if (steamid_chat == steamid_to_delete) {
                        chat_msgs.splice(i,1);
                    }
                }

                io.sockets.emit('admin remove msgs', steamid);

                socket.emit('user alerta', 'Messages of the user removed!');
            }
        }
    });
    // REMOVE MESSAGES

    // UNMUTE USER
    socket.on('admin unmute user', function(steamid, token) {
        if(users.hasOwnProperty(token) && steamid && token) {
            if(users[token].rank == 100 || users[token].rank == 1) {

                pool.query('UPDATE users SET mute = 0 WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                    if(err) return logger.trace(users[token].steamid + ' -  error unmuting user - 1');

                    var tokenul = tokens[steamid];
                    users[tokenul].mute = 0;

                    socket.emit('user alerta', 'User unmuted successfully!');
                });
            }
        }
    });
    // UNMUTE USER

    // BAN/UNBAN
    socket.on('admin ban user', function(steamid, token) {
        if(users.hasOwnProperty(token) && steamid && token) {
            if(users[token].rank == 100) {
                pool.query('UPDATE users SET ban = 1 WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    socket.emit('user alerta', 'User successfully banned!');
                    if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user refresh');
                });
            }
        }
    });

    socket.on('admin unban user', function(steamid, token) {
        if(users.hasOwnProperty(token) && steamid && token) {
            if(users[token].rank == 100) {
                pool.query('UPDATE users SET ban = 0 WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    socket.emit('user alerta', 'User successfully unbanned!');
                    if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user refresh');
                });
            }
        }
    });
    // BAN/UNBAN

    // SEND COINS
    socket.on('user send coins', function(steamid, coins, token) {
        logger.trace('[RAW] user send coins');
		logger.trace(steamid);
		logger.trace(coins);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && steamid && coins && token) {
            if(users[token].rank == 100) {
                addLog(users[token].steamid, 'admin_send_coins', coins, 'Admin sent coins to ' + steamid + ' - ' + coins, function() {
                    addLog(steamid, 'admin_receive_coins', '+' + coins, 'Received coins from admin ' + users[token].steamid + ' - ' + coins, function() {
                        pool.query('UPDATE users SET balance = balance + ' + pool.escape(coins) + ' WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                            if(err) throw err;

                            user_balance_check(tokens[steamid], function(er, bal) {

                                users[tokens[steamid]].balance = bal;

                                logger.error('Admin ' + users[token].steamid + ' sent ' + coins + ' coins to user ' + steamid);

                                socket.emit('user alerta', 'You have successfully sent ' + coins + ' coins to ' + users[tokens[steamid]].name);
                                if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user balance', users[tokens[steamid]].balance);
                                if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user alerta', 'You have successfully received ' + coins + ' coins from ' + users[token].name);
                            });
                        });
                    });
                });
            } else {
                antiSpam(socket, token, function() {
                    if(steamid == users[token].steamid) return socket.emit('user eroare', 'You can\'t send coins to yourself!');

                    coins = tofix(coins);
                    var reg = /^\d+$/;
                    if(reg.test(coins) == false) return socket.emit('user eroare', 'The amount need to be a valid number!');


                    pool.query('SELECT disabled_send FROM users WHERE token = ' + pool.escape(token), function(aaa, bbb) {

                        if(bbb[0].disabled_send == 1) return socket.emit('user eroare', 'You can\'t send coins!');

                        user_balance_check(token, function(er, bal) {
                            if(er) return socket.emit('user eroare', 'There was an error loading your balance. Try again!');

                            if(bal < coins) return socket.emit('user eroare', 'You do not have enough coins to send!');
                            if(!users.hasOwnProperty(tokens[steamid])) return socket.emit('user eroare', 'The user needs to be on site when sending coins!');
                            if(users[token].wagered < 15000) return socket.emit('user eroare', 'You need to have wagered 15,000 coins to use send command!');
                            if(parseInt(coins) < 1) return socket.emit('user eroare', 'You need to type a positive number to send coins!');
                            if(users[token].level < 5) return socket.emit('user eroare', 'To send coins you need to have at least level 5 on Steam!');
                            if(users[token].depamount < 5000) return socket.emit('user eroare', 'To send coins you need to deposit at least $5,00!');
                            pool.query('UPDATE users SET balance = balance - ' + pool.escape(parseInt(coins)) + ' WHERE token = ' + pool.escape(token), function(er, ro) {
                                pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(coins)) + ' WHERE steamid = ' + pool.escape(steamid), function(e, r) {

                                    addLog(users[token].steamid, 'send_coins_to_user', '-' + coins, 'Sent coins to ' + steamid + ' - ' + coins, function() {
                                        addLog(steamid, 'received_coins_from_user', '+' + coins, 'Received coins from ' + users[token].steamid + ' - ' + coins, function() {
                                            users[token].balance = bal;

                                            user_balance_check(tokens[steamid], function(err2, bal2) {
                                                if(err2) return socket.emit('user eroare', 'There was an error loading recipient\'s balance. Try again!');


                                                logger.error('User ' + users[token].steamid + ' sent ' + coins + ' coins to user ' + steamid);

                                                users[tokens[steamid]].balance = bal2;
                                                socket.emit('user balance', users[token].balance);
                                                if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user balance', users[tokens[steamid]].balance);
                                                socket.emit('user alerta', 'You have successfully sent ' + coins + ' coins to ' + users[tokens[steamid]].name);
                                                if(io.sockets.connected[ssockets[steamid]]) io.sockets.connected[ssockets[steamid]].emit('user alerta', 'You have successfully received ' + coins + ' coins from ' + users[token].name);
                                            });
                                        });
                                    });
                                });
                            });
                        });
                    });
                });
            }
        }
    });
    // SEN COINDS

    // MUTE USER
    socket.on('admin mute user', function(steamid, timpul, option, token) {
        if(users.hasOwnProperty(token) && steamid && timpul && option && token) {
            if(users[token].rank == 100 || users[token].rank == 1) {
                var new_time = 0;
                timpul = parseInt(timpul);

                if(option == 'seconds') new_time = time() + timpul;
                else if(option == 'minutes') new_time = time() + (timpul*60);
                else if(option == 'hours') new_time = time() + (timpul*60*60);
                else if(option == 'days') new_time = time() + (timpul*86400);

                var show_time;
                if(option == 'seconds') show_time = timpul + ' second(s)';
                else if(option == 'minutes') show_time = parseInt(timpul) + ' minute(s)';
                else if(option == 'hours') show_time = parseInt(timpul) + ' hour(s)';
                else if(option == 'days') show_time = parseInt(timpul) + ' day(s)';

                pool.query('UPDATE users SET mute = ' + pool.escape(new_time) + ' WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    users[tokens[steamid]].mute = new_time;
                    socket.emit('user alerta', 'User successfully muted for ' + show_time + '!');

                    logger.info('User ' + steamid + ' successfully muted for ' + show_time + ' by admin/mod ' + users[token].steamid + ' (' + users[token].name + ')');
                });
            }
        }
    });
    // MUTE USER






    // PROFILE STATS
    socket.on('user want profile stats', function(token) {
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                pool.query(`SELECT * FROM trades WHERE user = ` + pool.escape(users[token].steamid) + ` ORDER BY tid DESC LIMIT 20`, function(err, row) {
                    if(err) return;

                    var transactions = [];

                    for(var h in row) {
                        var itm = row[h];
                        transactions.push({
                            tid: itm.tid,
                            type: itm.type,
                            status: itm.status,
                            amount: itm.amount,
                            time: new Date(parseInt(itm.time*1000)).toLocaleDateString("en-US")
                        });
                    }

                    var stats = {
                        name: users[token].name,
                        avatar: users[token].avatar,
                        wagered: users[token].wagered,
                        rank: users[token].rank,
                        transactions: transactions,
                        wags: users[token].wags,
                        wwags: users[token].wwags
                    };

                    checkWebsiteLevel(token, function(level, xp, nextxp, oldxp) {
                        stats.nivel = level;
                        stats.curxp = xp;
                        stats.nextxp = nextxp;
                        stats.oldxp = oldxp;
                        socket.emit('user profile statistics', stats);
                    });
                });
            });
        }
    });
    // PROFILE STATS








    //
    socket.on('chat messages language', function(lang, token) {
        if(users.hasOwnProperty(token) && lang && token) {
            socket.emit('website chat history', chat_msgs, true);
        }
    });
    //

    socket.on('user chat message', function(lang, msg, token) {
        if(users.hasOwnProperty(token) && lang && msg && token) {
            if(lang != 'main' && lang != 'streamers' && lang != 'turkish') return logger.info('User ' + users[token].steamid + ' (' + users[token].name + ') tried to speak in Room ' + lang + '!');

            var mesaj = chat_message_escape(msg).trim();

            if(mesaj.includes(ChatCodes.code)) {
                if(ChatCodes.users.length >= ChatCodes.max_users) return socket.emit('user eroare', 'Chat code giveaway ended!');
                if(ChatCodes.users.indexOf(users[token].steamid) == -1) {
                    ChatCodes.users.push(users[token].steamid);
                    socket.emit('user alerta', 'Successfully entered in the chat code giveaway!');

                    if(ChatCodes.users.length >= ChatCodes.max_users) {
                        ChatCodes.code = null;
                        for(var z in ChatCodes.users) {
                            var userr = ChatCodes.users[z];
                            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(ChatCodes.prize)) + ' WHERE steamid = ' + pool.escape(userr), function(e,r) {
                            });

                            addLog(users[token].steamid, 'chatcode_won', '+'+parseInt(ChatCodes.prize), 'Won chatcode - coins ' + parseInt(ChatCodes.prize), function() {

                            });

                            var socketul = ssockets[userr];
                            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Succesfully received ' + ChatCodes.prize + ' coins by entering in the chat code giveaway!', 'balance');
                        }

                        var text_message = 'A total of <b>' + ChatCodes.users.length + '</b> users received <b>' + parseInt(ChatCodes.prize*ChatCodes.users.length) + '</b> coins from the chat code giveaway!';
                        id_chat_msgs++;
                        var props = {
                            id: id_chat_msgs,
                            steamid: '-1',
                            name: 'System',
                            avatar: config.domain_name + 'vendor/img/favicon.png',
                            rank: 101,
                            msg: text_message,
                            lang: ''
                        };
                        chat_msgs.push(props);
                        checkChatMessages();
                        io.sockets.emit('user chat message add', '', props);
                    }

                }  else socket.emit('user eroare', 'You are already in the chat code giveaway!');
                return;
            }

            if(mesaj.includes(MathCodes.answer)) {
                if(MathCodes.users.length >= MathCodes.max_users) return socket.emit('user eroare', 'Math code giveaway ended!');
                if(MathCodes.users.indexOf(users[token].steamid) == -1) {
                    MathCodes.users.push(users[token].steamid);
                    socket.emit('user alerta', 'Sucessfully entered in the math code giveaway!');

                    if(MathCodes.users.length >= MathCodes.max_users) {
                        MathCodes.answer = null;
                        for(var z in MathCodes.users) {
                            var userr = MathCodes.users[z];
                            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(MathCodes.prize)) + ' WHERE steamid = ' + pool.escape(userr), function(e,r) {
                            });

                            addLog(users[token].steamid, 'mathcode_won', '+'+parseInt(MathCodes.prize), 'Won mathcode - coins ' + parseInt(MathCodes.prize), function() {

                            });

                            var socketul = ssockets[userr];
                            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Succesfully received ' + MathCodes.prize + ' coins by entering in the math code giveaway!', 'balance');
                        }

                        var text_message = 'A total of <b>' + MathCodes.users.length + '</b> users received <b>' + parseInt(MathCodes.prize*MathCodes.users.length) + '</b> coins from the math code giveaway!';
                        id_chat_msgs++;
                        var props = {
                            id: id_chat_msgs,
                            steamid: '-1',
                            name: 'System',
                            avatar: config.domain_name + 'vendor/img/favicon.png',
                            rank: 101,
                            msg: text_message,
                            lang: ''
                        };
                        chat_msgs.push(props);
                        checkChatMessages();
                        io.sockets.emit('user chat message add', '', props);
                    }
                } else socket.emit('user eroare', 'You are already in the math code giveaway!');
                return;
            }

            if(FTWrite.enabled == true && mesaj.includes(FTWrite.text)) {
                FTWrite.enabled = false;
                var timpul = parseInt(time() - FTWrite.time);

                pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(FTWrite.prize)) + ' WHERE steamid = ' + pool.escape(users[token].steamid), function(e,r) {
                    socket.emit('user alerta', 'You have successfully won the <b>First to Write</b> event!', 'balance');

                    addLog(users[token].steamid, 'ftwrite_won', '+'+parseInt(FTWrite.prize), 'Won ftwrite event - coins ' + parseInt(FTWrite.prize), function() {

                    });
                });

                var text_message = 'User <b>' + users[token].name + '</b> won the <b>First to Write</b> event in ' + timpul + 's.';
                id_chat_msgs++;
                var props = {
                    id: id_chat_msgs,
                    steamid: '-1',
                    name: 'System',
                    avatar: config.domain_name + 'vendor/img/favicon.png',
                    rank: 101,
                    msg: text_message,
                    lang: ''
                };
                chat_msgs.push(props);
                checkChatMessages();
                io.sockets.emit('user chat message add', '', props);
                return;
            }

            if(AdminMode.hasOwnProperty(users[token].steamid) && !(args = /^\/admin/.exec(mesaj))) {
                if(args = /^\/chatcode ([0-9]*) ([0-9]*)/.exec(mesaj)) {
                    adminMakeChatCodeGame(args[1], args[2]);
                } else if(args = /^\/mathcode ([0-9]*) ([0-9]*) ([a-z]*)/.exec(mesaj)) {
                    adminMakeMathCodeGame(args[1], args[2], args[3], socket);
                } else if(args = /^\/ftwrite ([0-9]*)/.exec(mesaj)) {
                    adminFirstToWriteGame(args[1]);
                } else if(args = /^\/stop/.exec(mesaj)) {
                    pool.query('UPDATE settings SET maintenance = 1', function(er, ro) {
                        socket.emit('user alerta', 'Successfully changed the website to maintenance on!');
                        io.sockets.emit('user refresh');
                    });
                } else if(args = /^\/start/.exec(mesaj)) {
                    pool.query('UPDATE settings SET maintenance = 0', function(er, ro) {
                        socket.emit('user alerta', 'Successfully changed the website to maintenance off!');
                    });
                } else if(args = /^\/doubleweek/.exec(mesaj)) {
                    if(JmekWeek == false) {
                        Pinned_msg.currently = "Double Weekend Rain - stay active on " + config.site_name + " to get 2x coins from rain!";
                        Pinned_msg.last = users[token].steamid;
                        socket.emit('user alerta', 'Double Weekend enabled.');
                        io.sockets.emit('user pinned msg', Pinned_msg.currently);
                        JmekWeek = true;
                    } else {
                        Pinned_msg.currently = null;
                        socket.emit('user alerta', 'Double Weekend disabled.');
                        io.sockets.emit('user pinned msg', Pinned_msg.default);
                    }
                } else if(args = /^\/bets/.exec(mesaj)) {
                    if(Games_Work == true) {
                        Games_Work = false;
                        socket.emit('user alerta', 'Bets closed!');
                    } else {
                        Games_Work = true;
                        socket.emit('user alerta', 'Bets opened!');
                    }
                } else if(args = /^\/raffle ([0-9]*) ([0-9]*) ([0-9]*)/.exec(mesaj)) {
                    var many = parseInt(args[1]);
                    var coins = parseInt(args[2]);
                    var useri = parseInt(args[3]);

                    for(var i = 0; i < many; i++) {
                        createRaffle(coins + ' Coins', config.coins_img_url, coins, '0', useri, socket, 0);
                    }

                    socket.emit('user alerta', 'Successfully made ' + many + ' coins raffles, worth of ' + coins + ' with ' + useri + ' users!');
                }
                return;
            }

            if(anti_spam_chat[token]+2 >= time() && users[token].rank != 100) return socket.emit('user eroare', 'Do not spam!');
            else anti_spam_chat[token] = time();

            if(mesaj.length > 256 && users[token].rank != 100) return socket.emit('user eroare', 'The message is too long!');
            else if(mesaj.length < 2 && users[token].rank != 100) return socket.emit('user eroare', 'The message is too short!');

            var args = null;
            if(args = /^\/mute ([0-9]*) ([0-9]*)/.exec(mesaj) && ( users[token].rank == 100 || users[token].rank == 1 )) {

                var new_time = time() + parseInt(args[2]);

                var show_time;
                if(parseInt(args[2]) < 60) show_time = parseInt(args[2]) + ' seconds';
                else if(parseInt(args[2]) >= 60 && parseInt(args[2]) < 3600) show_time = parseInt(parseInt(args[2]) / 60) + ' minute(s)';
                else if(parseInt(args[2]) >= 3600 && parseInt(args[2]) < 86400) show_time = parseInt(parseInt(args[2]) / 3600) + ' hour(s)';
                else if(parseInt(args[2]) >= 86400 && parseInt(args[2]) < 2592000) show_time = parseInt(parseInt(args[2]) / 86400) + ' day(s)';
                else if(parseInt(args[2]) >= 2592000) show_time = parseInt(parseInt(args[2]) / 2592000) + ' month(s)';

                pool.query('UPDATE users SET mute = ' + pool.escape(new_time) + ' WHERE steamid = ' + pool.escape(args[1]), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    users[tokens[args[1]]].mute = new_time;
                    socket.emit('user alerta', 'User successfully muted for ' + show_time + '!');
                });

            } else if(args = /^\/ban ([0-9]*)/.exec(mesaj) && ( users[token].rank == 100 )) {

                pool.query('UPDATE users SET ban = 1 WHERE steamid = ' + pool.escape(args[1]), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    socket.emit('user alerta', 'User successfully banned!');
                    if(io.sockets.connected[ssockets[args[1]]]) io.sockets.connected[ssockets[args[1]]].emit('user refresh');
                });

            } else if(args = /^\/unban ([0-9]*)/.exec(mesaj) && ( users[token].rank == 100 )) {

                pool.query('UPDATE users SET ban = 0 WHERE steamid = ' + pool.escape(args[1]), function(err, row) {
                    if(err) return socket.emit('user eroare', 'This user doesn\'t exists!');

                    socket.emit('user alerta', 'User successfully unbanned!');
                });

            } else if(args = /^\/gclear/.exec(mesaj) && ( users[token].rank == 100 || users[token].rank == 1 )) {

                chat_msgs = [];
                io.sockets.emit('website chat clear', '');
                socket.emit('user alerta', 'You have cleared the chat globally!');

            } else if(args = /^\/clear ([a-z]*)/.exec(mesaj) && ( users[token].rank == 100 || users[token].rank == 1 )) {

                var room = args[1].toString();

                for(var i in chat_msgs) {
                    if (chat_msgs[i].lang == room) {
                        chat_msgs.splice(i, 1);
                    }
                }
                io.sockets.emit('website chat clear', args[1]);
                socket.emit('user alerta', 'You have cleared the <b>' + args[1] + '</b> chat!');

            } else if(args = /^\/amountrain/.exec(mesaj) && ( users[token].rank == 100 || users[token].rank == 1) ) {

                socket.emit('user alerta', Rain.total_coins);

            } else if(args = /^\/withdraw/.exec(mesaj) && users[token].rank == 100) {

                if(Withdraw_disabled == false) {
                    Withdraw_disabled = true;
                    socket.emit('user alerta', 'Withdraw has been disabled!');
                } else {
                    Withdraw_disabled = false;
                    socket.emit('user alerta', 'Withdraw has been enabled!');
                }

            } else if(args = /^\/chat/.exec(mesaj) && users[token].rank == 100) {

                if(Chat_disabled == false) {
                    Chat_disabled = true;
                    socket.emit('user alerta', 'Chat has been disabled!');
                } else {
                    Chat_disabled = false;
                    socket.emit('user alerta', 'Chat has been enabled!');
                }

            } else if(args = /^\/tiprain ([0-9]*)/.exec(mesaj)) {
                if(args[1] <= 0) return socket.emit('user eroare', 'The number needs to be positive!');

                args[1] = tofix(args[1]);

                var Numele = users[token].name;

                user_balance_check(token, function(er, bal) {
                    if(args[1] > bal) return socket.emit('user eroare', 'You do not have enough balance to tip rain!');
                    if(Rain.enabled == true) return socket.emit('user eroare', 'There is a rain active right now!');
                    if(users[token].level < 4) return socket.emit('user eroare', 'You need to have at least Steam Level 4 to tip Rain!');
                    if(users[token].depamount < 5000) return socket.emit('user eroare', 'You need deposit at least $5,00 before tipping Rain!');

                    pool.query('UPDATE users SET balance = balance - ' + pool.escape(args[1]) + ' WHERE steamid = ' + pool.escape(users[token].steamid), function(er) {
                        if(er) return logger.trace(users[token].steamid + ' -  error tipping rain - 1');

                        user_balance_check(token, function(e, ba) {
                            var users = parseInt(Object.keys(ips).length);

                            Rain.total_coins += parseInt(args[1]);

                            addLog(users[token].steamid, 'tip_rain', '-'+args[1], 'Tip rain - coins ' + args[1] , function() {

                            });

                            if(args[1] >= 100) {
                                var text_message = 'User <b>' + Numele + '</b> tipped <b>' + args[1] + '</b> coins to the <b>Rain</b>!<br>New rain amount: <b>' + parseInt(Rain.total_coins) + '</b>';
                                id_chat_msgs++;
                                var props = {
                                    id: id_chat_msgs,
                                    steamid: '-1',
                                    name: 'System',
                                    avatar: config.domain_name + 'vendor/img/favicon.png',
                                    rank: 101,
                                    msg: text_message,
                                    lang: ''
                                };
                                chat_msgs.push(props);
                                checkChatMessages();
                                io.sockets.emit('user chat message add', '', props);
                            } else {
                                var text_message = 'You have tipped <b>' + args[1] + '</b> coins to the <b>Rain</b>!<br>To broadcast for all players, you need to tip more than 100 coins!<br>New rain amount: <b>' + parseInt(Rain.total_coins) + '</b>';
                                id_chat_msgs++;
                                var props = {
                                    id: id_chat_msgs,
                                    steamid: '-1',
                                    name: 'System',
                                    avatar: config.domain_name + 'vendor/img/favicon.png',
                                    rank: 101,
                                    msg: text_message,
                                    lang: ''
                                };
                                socket.emit('user chat message add', '', props);
                            }

                            socket.emit('user balance', ba);

                            socket.emit('user alerta', 'You have successfully added <b>' + args[1] + '</b> coins to the <b>Rain</b>!');
                        });
                    });
                });
            } else if(args = /^\/lastrain/.exec(mesaj)) {

                var timp = parseInt(parseInt(time() - Rain.time)/60);

                socket.emit('user alerta', 'The last rain was <b>' + timp + '</b> minutes ago.');

            } else if(args = /^\/nextrain/.exec(mesaj) && users[token].rank == 100) {

                var timp_last = parseInt(parseInt(time() - Rain.time)/60);
                var next = parseInt(Rain.time_to_rain-timp_last);

                socket.emit('user alerta', 'The next rain will be in <b>' + next + '</b> minutes.');

            } else if(args = /^\/refresh/.exec(mesaj) && users[token].rank == 100) {

                io.sockets.emit('user refresh');

            } else if(args = /^\/with/.exec(mesaj) && users[token].rank == 100) {

                website_getInventory();
                socket.emit('user alerta', 'Withdraw inventory reloaded!');

            } else if(args = /^\/crain/.exec(mesaj) && users[token].rank == 100) {

                startRain();

                socket.emit('user alerta', 'Rain cancelled!');
                logger.info('Admin ' + users[token].steamid + ' (' + users[token].name + ') cancelled the Rain!');

            } else if(args = /^\/admin/.exec(mesaj) && users[token].rank == 100) {

                if(AdminMode.hasOwnProperty(users[token].steamid)) {
                    delete AdminMode[users[token].steamid];
                    socket.emit('user alerta', 'You are no mode in the admin mode!');
                } else {
                    AdminMode[users[token].steamid] = 1;
                    socket.emit('user alerta', 'You are now in admin mode!');
                }

            } else if(args = /^\/send ([0-9]*) ([0-9]*)/.exec(mesaj)) {
                if(args[1] == users[token].steamid) return socket.emit('user eroare', 'You can\'t send coins to yourself!');

                pool.query('SELECT disabled_send FROM users WHERE token = ' + pool.escape(token), function(aaa, bbb) {

                    if(bbb[0].disabled_send == 1) return socket.emit('user eroare', 'You can\'t send coins!');

                    user_balance_check(token, function(err, bal) {
                        if(err) return socket.emit('user eroare', 'There was an error loading your balance. Try again!');

                        if(bal < args[2]) return socket.emit('user eroare', 'You do not have enough coins to send!');
                        if(!users.hasOwnProperty(tokens[args[1]])) return socket.emit('user eroare', 'The user needs to be on site when sending coins!');
                        if(users[token].wagered < 15000) return socket.emit('user eroare', 'You need to have wagered 15,000 coins to use send command!');
                        if(parseInt(args[2]) < 1) return socket.emit('user eroare', 'You need to type a positive number to send coins!');
                        if(users[token].level < 2) return socket.emit('user eroare', 'To send coins you need to have at least level 5 on Steam!');
                        if(users[token].depamount < 5000) return socket.emit('user eroare', 'To send coins you must deposit at least $5,00!');
                        pool.query('UPDATE users SET balance = balance - ' + pool.escape(parseInt(args[2])) + ' WHERE token = ' + pool.escape(token), function(er, ro) {
                            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(args[2])) + ' WHERE steamid = ' + pool.escape(args[1]), function(e, r) {

                                addLog(users[token].steamid, 'user_send_coins', '-'+parseInt(args[2]), 'Send coins to ' + args[1] + ' - ' + args[2], function() {
                                    addLog(args[1], 'user_receive_coins', '+'+parseInt(args[2]), 'Received coins from ' + users[token].steamid + ' - ' + args[2], function() {

                                        users[token].balance = bal;

                                        user_balance_check(tokens[args[1]], function(err2, bal2) {
                                            if(err2) return socket.emit('user eroare', 'There was an error loading recipient\'s balance. Try again!');


                                            logger.error('User ' + users[token].steamid + ' sent ' + args[2] + ' coins to user ' + args[1]);

                                            users[tokens[args[1]]].balance = bal2;
                                            socket.emit('user balance', users[token].balance);
                                            if(io.sockets.connected[ssockets[args[1]]]) io.sockets.connected[ssockets[args[1]]].emit('user balance', users[tokens[args[1]]].balance);
                                            socket.emit('user alerta', 'You have successfully sent money to ' + users[tokens[args[1]]].name);
                                            if(io.sockets.connected[ssockets[args[1]]]) io.sockets.connected[ssockets[args[1]]].emit('user alerta', 'You have successfully received ' + args[2] + ' coins from ' + users[token].name);
                                        });
                                    });
                                });
                            });
                        });
                    });

                });
            } else if(args = /^\/help/.exec(mesaj)) {

                var rank = users[token].rank;
                var allowed_comenzi = [];
                var syntax = [
                    '/mute [user] [seconds]',
                    '/ban [user]',
                    '/unban [user]',
                    '/gclear',
                    '/clear [chat]',
                    '/amountrain',
                    '/tiprain [amount]',
                    '/lastrain',
                    '/refresh',
                    '/admin',
                    '/send [user] [amount]',
                    '/doubleweek',
                    '/withdraw',
                    '/nextrain',
                    '/chat',
                    '/crain'
                ];
                var info = [
                    'Mute user [user] for [seconds] seconds',
                    'Ban user [user] permanently',
                    'Unban user [user]',
                    'Clear the chat globally',
                    'Clear the chat [chat]',
                    'Show the currently amount of rain',
                    'Tip [amount] coins to the rain',
                    'Show how time has passed since the last rain',
                    'Refresh the browser for all users',
                    'You switch to admin mode',
                    'Send [amount] coins to user [user]',
                    'Enable/Disable 2x Rain Coins for Weekend',
                    'Enable/Disable Withdraw for Players',
                    'See in how much time will be the next rain',
                    'Enable/Disable Chat for Players',
                    'Cancel the current Rain'
                ];
                var comenzi = ['/mute', '/ban', '/unban', '/gclear', '/clear', '/amountrain', '/tiprain', '/lastrain', '/refresh', '/admin', '/send', '/doubleweek', '/withdraw', '/nextrain', '/chat', '/crain'];
                for(var h in comenzi) {
                    var sy = syntax[h];
                    var inf = info[h];
                    var cmd = comenzi[h];
                    if(rank == 0) {
                        if(cmd == '/tiprain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/lastrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/send') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                    } else if(rank == 1) {
                        if(cmd == '/tiprain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/lastrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/send') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/mute') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/gclear') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/clear') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                    } else if(rank == 100) {
                        if(cmd == '/tiprain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/lastrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/send') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/mute') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/gclear') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/clear') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/ban') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/unban') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/amountrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/refresh') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/admin') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/doubleweek') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/withdraw') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/nextrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/chat') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/crain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                    } else {
                        if(cmd == '/tiprain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/lastrain') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                        if(cmd == '/send') allowed_comenzi.push({
                            syntax: sy,
                            info: inf,
                            cmd: cmd
                        });
                    }
                }

                socket.emit('user help', allowed_comenzi);


            } else {
                if(mesaj.includes('/mute') && users[token].rank == 100) return cmdSyntax('/mute', socket);
                else if(mesaj.includes('/ban') && users[token].rank == 100) return cmdSyntax('/ban', socket);
                else if(mesaj.includes('/unban') && users[token].rank == 100) return cmdSyntax('/unban', socket);
                else if(mesaj.includes('/clear') && users[token].rank == 100) return cmdSyntax('/gclear', socket);
                else if(mesaj.includes('/send')) return cmdSyntax('/send', socket);

                // CHECK IF IT'S COMMAND
                if(mesaj.startsWith('/')) return socket.emit('user eroare', 'Command not found.');
                // CHECK IF IT'S COMMAND

                if(users[token].mute-time() > 0) return socket.emit('user eroare', 'You are muted!');
                else if(Chat_disabled == true && (users[token].rank != 100) ) return;
                else {
                    id_chat_msgs++;

                    var props = {
                        id: id_chat_msgs,
                        steamid: users[token].steamid,
                        name: users[token].name,
                        avatar: users[token].avatar,
                        rank: users[token].rank,
                        msg: mesaj,
                        lang: lang,
                        xp_level: users[token].xp_level,
                        xp_color: users[token].xp_color
                    };

                    chat_msgs.push(props);
                    checkChatMessages();

                    io.sockets.emit('user chat message add', lang, props);
                }
            }
        }
    });

    socket.on('user deposit items', function(ids, token) {
        logger.trace('[RAW] user deposit items');
		logger.trace(ids);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && ids && token) {
            antiSpam(socket, token, function() {
                var items = ids.join(',');
                if(user_pending_deposit.hasOwnProperty(users[token].steamid)) return socket.emit('user eroare', 'You have a pending deposit, please accept/cancel it first for another deposit!');

                ET.ITrade.GetUserInventoryFromSteamId({'steam_id': users[token].steamid, 'app_id': 1, 'per_page': 500}, (err, body) => {
                    if(err) return socket.emit('user eroare', 'An error occurred. Try again!');

                    var iteme_pt_depozit = [];
                    var iteme = body.response.items;

                    for(var h in iteme) {
                        for(var j in ids) {
                            if(iteme[h].id == ids[j]) iteme_pt_depozit.push(iteme[h].id);
                        }
                    }

                    if(iteme_pt_depozit.length != ids.length) return socket.emit('user eroare', 'Some items are not in your inventory. Please refresh!');

                    ET.IItem.GetItemsById({'item_id': ids.join(',')}, (er, bod) => {
                        if(er) return socket.emit('user eroare', bod.message);

                        var amount = 0;
                        var Iteme = bod.response.items;
                        for(var z in Iteme) {
                            var pret = parseInt(Iteme[z].suggested_price*10);
                            amount += pret;
                            if(pret == 0) {
                                amount = 0;
                                break;
                            }
                        }

                        ET.ITrade.SendOfferToSteamId({
                            'steam_id': users[token].steamid,
                            'items_to_receive': items,
                            'message': config.site_name + ' | Deposit offer with ' + ids.length + ' items worth of $' + parseFloat(amount/1000).toFixed(2)
                        }, (e, bo) => {
                            if(e) return socket.emit('user eroare', bo.message);

                            if(bo.response.offer.state == 2) {
                                pending_deposit[bo.response.offer.id] = {
                                    steamid: users[token].steamid,
                                    amount: amount
                                };
                                user_pending_deposit[users[token].steamid] = bo.response.offer.id;

                                // FOR CHECKING OF VALUE
                                var trade_amount = 0;
                                for(var h in bo.response.offer.recipient.items) {
                                    var itm = bo.response.offer.recipient.items[h];
                                    trade_amount += parseInt(itm.suggested_price*10);
                                }
                                // FOR CHECKING OF VALUE

                                var string = 'deposit';
                                if(users[token].rank == 100) string = 'Adeposit';

                                addNewTrade(bo.response.offer.id, string, ids.join(','), token, function(eroare, mesaj) {
                                    if(eroare) return socket.emit('user eroare', mesaj);

                                    editTradeAmount(bo.response.offer.id, amount, function(eeroare) {
                                        //CHECK IF TRADE BELONGS TO STEAMID OF THE USER
                                        if(users[token].steamid != bo.response.offer.recipient.steam_id) {
                                            ET.ITrade.CancelOffer({
                                                'offer_id': bo.response.offer.id
                                            }, (eror, bot) => {
                                                socket.emit('user eroare', 'Something happened with the trade, refresh deposit page and try again!');
                                            });
                                        //CHECK IF TRADE BELONGS TO STEAMID OF THE USER
                                        } else {
                                            // CHECK IF VALUE ON WEDBSITE IS SAME AS ON TRADEOFFER, IF NOT DECLINE
                                            if(amount != trade_amount) {
                                                ET.ITrade.CancelOffer({
                                                    'offer_id': bo.response.offer.id
                                                }, (eror, bot) => {
                                                    socket.emit('user eroare', 'Something happened with the trade, refresh deposit page and try again!');
                                                });
                                                return;
                                            // CHECK IF VALUE ON WEDBSITE IS SAME AS ON TRADEOFFER, IF NOT DECLINE
                                            } else {
                                                socket.emit('user deposit successfully', bo.response.offer.id, amount, ids.length);
                                                logger.info('Trade #' + bo.response.offer.id + ' by user ' + users[token].name + '(' + users[token].steamid + ')' + ' has been created (deposit)');
                                            }
                                        }
                                    });
                                });
                            }
                        });
                    });
                });
            });
        }
    });

    socket.on('user withdraw items', function(ids, token) {
        logger.trace('[RAW] user withdraw items');
		logger.trace(ids);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && ids && token) {
            antiSpam(socket, token, function() {

                if(Withdraw_disabled == true && users[token].rank != 100) return socket.emit('user eroare', 'Withdraw is disabled at this moment. Check later!');

                var items = ids.join(',');
                if(user_pending_withdraw.hasOwnProperty(users[token].steamid)) return socket.emit('user eroare', 'You have a pending withdraw, please accept/cancel it first for another withdraw!');

                var items_goned = 0;
                for(var z in ids) {
                    for(var h in items_gone) {
                        if(ids[z] == items_gone[h]) items_goned++;
                    }
                }
                if(items_goned > 0) {
                    var inv = [];
                    for(var z in website_inventory) {
                        for(var h in website_inv_raffles) {
                            if(website_inventory[z].id == website_inv_raffles[h]) website_inventory[z].ss = 1;
                        }
                    }

                    for(var z in website_inventory) {
                        if(website_inventory[z].ss != 1) inv.push(website_inventory[z]);
                    }


                    socket.emit('user eroare', 'Some items are already in trade or already traded!');
                    return;
                }
                var amount = 0;

                ET.IItem.GetItemsById({'item_id': ids.join(',')}, (err, body) => {
                    if(err) return socket.emit('user eroare', body.message);

                    var Iteme = body.response.items;
                    for(var z in Iteme) {
                        var pret = parseInt(parseInt(Iteme[z].suggested_price*10)*1.15);
                        amount += pret;
                        if(pret == 0) {
                            amount = 0;
                            break;
                        }
                    }

                    if(amount == 0) {
                        pool.query('UPDATE users SET ban = 1 WHERE token = ' + pool.escape(token), function(e, r) {
                            socket.emit('user refresh');
                        });
                        return;
                    }

                    if(users[token].rank == 0 && amount >= 25000) {
                        logger.error('User ' + users[token].steamid + ' (' + users[token].name + ') tried to withdraw more than $25,00 at a time!');
                        socket.emit('user eroare', 'Security<br>You have a limited account and you can withdraw a total of $25,00 at a time.<br>Contact an admin.');
                        return;
                    }

                    if(users[token].rank == 0 && users[token].withamount >= 100000) {
                        logger.error('User ' + users[token].steamid + ' (' + users[token].name + ') tried to withdraw items and he has $100,00 total withdrew!');
                        socket.emit('user eroare', 'Security<br>You have a limited account and you can withdraw a total of $100,00.<br>Contact an admin.');
                        return;
                    }

                    var raffle_check = false;
                    for(var f in ids) {
                        for(var h in website_inv_raffles) {
                            if(ids[f] == website_inv_raffles[h]) raffle_check = true;
                        }
                    }

                    if(raffle_check == true) return socket.emit('user eroare', 'This item is already in another trade!');

                    user_balance_check(token, function(er, bale) {
                        if(er) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                        if(bale < amount) return socket.emit('user eroare', 'You do not have enough balance to withdraw these items!');
                        if(users[token].depamount < 5000 || users[token].depamount == 0) return socket.emit('user eroare', 'You need to deposit at least $5 before withdraw!');
                        if(users[token].available < amount) return socket.emit('user eroare', 'You must wager more coins before withdrawing! (' + users[token].available + '/' + amount + ')');
                        if(users[token].wagered < parseInt(users[token].depamount/2)) return socket.emit('user eroare', 'You need to bet 50% your deposit amount! (' + users[token].wagered + '/' + parseInt(users[token].depamount/2) + ')');
                        if((users[token].rank == 10 || users[token].rank == 11 || users[token].rank == 12) && users[token].can_withdraw == 0) return socket.emit('user eroare', 'You are not able to withdraw!');

                        pool.query('SELECT disabled_withdraw FROM users WHERE token = ' + pool.escape(token), function(aaa, bbb) {

                            if(bbb[0].disabled_withdraw == 1) return socket.emit('user eroare', 'You can\'t withdraw items!');

                            ET.ITrade.SendOfferToSteamId({
                                'steam_id': users[token].steamid,
                                'items_to_send': items,
                                'message': config.site_name + ' | Withdraw offer with ' + ids.length + ' items worth of $' + parseFloat(amount/1000).toFixed(2)
                            }, (e, bo) => {
                                if(e) return socket.emit('user eroare', bo.message);
                                if(bo.response.offer.state == 2) {
                                    pending_withdraw[bo.response.offer.id] = {
                                        steamid: users[token].steamid,
                                        amount: amount
                                    };
                                    user_pending_withdraw[users[token].steamid] = bo.response.offer.id;

                                    var string = 'withdraw';
                                    if(users[token].rank == 100) string = 'Awithdraw';

                                    addNewTrade(bo.response.offer.id, string, ids.join(','), token, function(eroare, mesaj) {
                                        if(eroare) return socket.emit('user eroare', mesaj);

                                        editTradeAmount(bo.response.offer.id, amount, function(eeroare) {
                                            if(eeroare) return logger.trace(users[token].steamid + ' - error withdrawing items - 1');

                                            pool.query('UPDATE users SET balance = balance - ' + pool.escape(amount) + ', available = available - ' + pool.escape(amount) + ', withs = withs + 1, withamount = withamount + ' + pool.escape(amount) + ' WHERE token = ' + pool.escape(token), function(ror) {

                                                addLog(users[token].steamid, 'withdraw_items', '-' + amount, 'Withdraw ' + ids.length + ' items worth of ' + amount + ' coins.', function() {
                                                    user_balance_check(token, function(alab, hhh) {
                                                        if(alab) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                                                        users[token].balance = hhh;
                                                        socket.emit('user balance', users[token].balance);
                                                        socket.emit('user withdraw successfully', bo.response.offer.id, amount, ids.length);
                                                        logger.error('Trade #' + bo.response.offer.id + ' created by ' + users[token].steamid + ' (' + users[token].name + ') for withdrew items worth of ' + amount + ' coins ($' + parseFloat(amount/1000).toFixed(2) + ' || ' + ids.length + ')');
                                                        users[token].available -= parseInt(amount);
                                                    });
                                                });
                                            });
                                        });
                                    });
                                }
                            });
                        });
                    });
                });
            });
        }
    });

    socket.on('roulette_addbet', function(value, bet, token) {
        logger.trace('[RAW] roulette_addbet')
		logger.trace(value);
		logger.trace(bet);
		logger.trace(token);
        logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token)) {
            antiSpam(socket, token, function() {
                if(Games_Work == false) return socket.emit('user eroare', 'The bets are currently closed!');
                if(currentMode == 'WAITING') {
                    var steamid = users[token].steamid;
                    var name = users[token].name;
                    var avatar = users[token].avatar;

                    value = tofix(value);

                    if(roulette_bet_color.hasOwnProperty(token) && ( roulette_bet_color[token].red == 1 && bet == 'black') ) return socket.emit('user eroare', 'You can\'t place black if you placed a bet on red!');
                    if(roulette_bet_color.hasOwnProperty(token) && ( roulette_bet_color[token].black == 1 && bet == 'red') ) return socket.emit('user eroare', 'You can\'t place black if you placed a bet on red!');

                    user_balance_check(token, function(er, balul) {
                        if(er) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                        if(balul < value) return socket.emit('user eroare', 'You do not have enough money!');
                        else if(value < minBet) return socket.emit('user eroare', 'Minimum bet is ' + minBet + '!');
                        else if(value > maxBet) return socket.emit('user eroare', 'Maximum bet is ' + minBet + '!');
                        if(betsUsers.hasOwnProperty(steamid) && betsUsers[steamid] == 3) return socket.emit('user eroare', 'Maximum bets per round are 3!');

                        if(isPositiveNumber(value) == false) return socket.emit('user eroare', 'The bet amount needs to be a valid number!');

                        pool.query('UPDATE users SET balance = balance - ' + pool.escape(value) + ', wags = wags + ' + pool.escape(value) + ', wagered = wagered + ' + pool.escape(value) + ', available = available + ' + pool.escape(value) + ' WHERE token = ' + pool.escape(token), function(err, row) {
                            if(err) throw err;

                            addLog(users[token].steamid, 'roulette_add_bet', '-' + value, 'Added roulette bet on color ' + bet + ' value ' + value, function() {
                                user_balance_check(token, function(err, bal) {
                                    if(err) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                                    users[token].balance = bal;
                                    socket.emit('user balance', users[token].balance);

                                    users[token].wagered = users[token].wagered + parseInt(value);
                                    users[token].available = users[token].available + parseInt(value);

                                    pool.query('INSERT INTO bets SET user = ' + pool.escape(steamid) + ', color = ' + pool.escape(bet) + ', amount = ' + pool.escape(value) + ', won = 0, time = ' + pool.escape(time()), function(er, ro) {
                                        if(betsUsers.hasOwnProperty(steamid)) betsUsers[steamid]++;
                                        else betsUsers[steamid] = 1;

                                        if(roulette_bet_color.hasOwnProperty(token)) roulette_bet_color[token][bet] = 1;
                                        else {
                                            roulette_bet_color[token] = {
                                                red: 0,
                                                green: 0,
                                                black: 0
                                            };

                                            roulette_bet_color[token][bet] = 1;
                                        }

                                        currentBets.push({
                                            id: ro.insertId,
                                            bet: value,
                                            color: bet,
                                            user: steamid,
                                            avatar: avatar,
                                            name: name
                                        });

                                        io.sockets.emit('roulette_newbet', value, bet, steamid, avatar, name);
                                        socket.emit('user alerta', 'You have successfully placed bet on ' + bet + '!');
                                        logger.trace('Bets - user ' + steamid + ' has bet value ' + value + ' on color ' + bet);

                                        checkWebsiteLevel(token, function(level) {
                                            var $color = '';

                                            if(level >= 0 && level <= 4) $color = '#919191';
                                            else if(level >= 5 && level <= 9) $color = '#2F65FA';
                                            else if(level >= 10) $color = '#FC3232';

                                            users[token].xp_level = level;
                                            users[token].xp_color = $color;
                                        });
                                    });
                                });
                            });
                        });
                    });
                }
            });
        }
    });

    socket.on('affiliates set referral', function(code, token) {
        logger.trace('[RAW] affiliates set referral')
		logger.trace(code);
		logger.trace(token);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && code && token) {
            antiSpam(socket, token, function() {
                if(users[token].aff != '') return socket.emit('user eroare', 'You already redeemed a code!');
                if(users[token].level < 4) return socket.emit('user eroare', 'You need to have at least level 4 on Steam!');
                var nume = users[token].name.toLowerCase();
                if(nume.includes(config.site_name.toLowerCase())) {
                    pool.query('SELECT user FROM codes WHERE code = ' + pool.escape(code), function(err, row) {
                        if(err) throw err;
                        if(row.length == 0) return socket.emit('user eroare', 'This code doesn\'t exists!');
                        var utilizator = row[0].user;

                        gamesUserChecker(token, function(check) {
                            if(check == true) {
                                if(utilizator == users[token].steamid) return socket.emit('user eroare', 'You can\'t redeem your own code!');
                                pool.query('SELECT aff FROM users WHERE steamid = ' + pool.escape(utilizator), function(e, r) {
                                    if(e) throw e;
                                    if(r.length == 0) return logger.trace(users[token].steamid + ' -  error setting referral - 1');

                                    if(r[0].aff == users[token].steamid) return socket.emit('user eroare', 'You can\'t be a referral for this code!');

                                    pool.query('UPDATE users SET aff = ' + pool.escape(utilizator) + ', balance = balance + 250, `redeemed_code` = ' + pool.escape(code) + ' WHERE token = ' + pool.escape(token), function(err, row) {

                                        addLog(users[token].steamid, 'aff_set_referral', '+250', 'Used code ' + code + ' and received 250 coins.', function() {
                                            users[token].aff = utilizator;
                                            users[token].affs = parseInt(users[token].affs + 1);
                                            user_balance_check(token, function(err, bal) {
                                                if(err) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                                                users[token].balance = bal;
                                                socket.emit('user balance', users[token].balance);
                                                socket.emit('user aff code', code);
                                                socket.emit('user modal', '#aff_mfreecoins', 'close');
                                                socket.emit('user alerta', 'You have successfully redeemed the code ' + code + ' and received 250 coins!');
                                                pool.query('UPDATE users SET affs = affs + 1 WHERE steamid = ' + pool.escape(utilizator), function(e, r) {
                                                    if(e) return logger.trace(users[token].steamid + ' - error setting referral - 2');
                                                });
                                            });
                                        });
                                    });
                                });
                            } else return socket.emit('user eroare', 'You need to have 50+ hours (CS:GO, PUBG, Rust) for using a referral code!');
                        });
                    });
                } else socket.emit('user eroare', 'You need to have ' + config.site_name + ' in your name before claiming a free code!');
            });
        }
    });

    socket.on('affiliates use promotion code', function(code, token) {
        logger.trace('[RAW] affiliates use promotion code');
		logger.trace(code);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && code && token) {
            antiSpam(socket, token, function() {
                if(Promotional_codes.hasOwnProperty(code)) {
                    var found = false;
                    for(var h in Promotional_codes[code].current_users) {
                        var itm = Promotional_codes[code].current_users[h];
                        if(itm == users[token].steamid) found = true;
                    }
                    if(found == true) return socket.emit('user eroare', 'You have already claimed this promotional code!');
                    if(users[token].level < 2) return socket.emit('user eroare', 'You need to have at least level 2 on Steam!');
                    if(users[token].depamount < 5000) return socket.emit('user eroare', 'You need to have at least $5,00 deposited before claiming a promotional code!');

                    var amount = parseInt(Promotional_codes[code].amount);
                    var uses = parseInt(Promotional_codes[code].uses);

                    Promotional_codes[code].current_users.push(users[token].steamid);
                    if(Promotional_codes[code].current_users.length >= uses) {
                        delete Promotional_codes[code];
                        logger.error('Promotional code ' + code + ' ended!');
                    }

                    pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE token = ' + pool.escape(token), function(er) {
                        user_balance_check(token, function(er, ba) {
                            if(er) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                            addLog(users[token].steamid, 'aff_use_promotional_code', '+' + amount, 'Used pcode ' + code + ' and received ' + amount + ' coins.', function() {
                                users[token].balance = ba;
                                socket.emit('user balance', users[token].balance);
                                socket.emit('user alerta', 'Promotional code claimed and you have got <b>' + amount + '</b> coins!');
                            });
                        });
                    });
                } else return socket.emit('user eroare', 'This promotional code doesn\'t exists!');
            });
        }
    });

    socket.on('affiliates collect earnings', function(token) {
        logger.trace('[RAW] affiliates collect earnings');
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && token) {
            antiSpam(socket, token, function() {
                pool.query('SELECT affamount, affcollected FROM users WHERE token = ' + pool.escape(token), function(err, row) {
                    if(err) throw err;
                    if(row.length == 0) return console.log(row);

                    var amount = parseInt(row[0].affamount);
                    var level = users[token].level;
                    if(row[0].affamount < 100) return socket.emit('user eroare', 'You can collect your earnings just when you have at least 100 coins to collect!');
                    if(level < 2) return socket.emit('user eroare', 'To collect earnings from referrals you should have at least Steam level 2!');
                    var nume = users[token].name.toLowerCase();
                    if(nume.includes(config.site_name.toLowerCase())) {
                        pool.query('UPDATE users SET affamount = 0, affcollected = affcollected + ' + pool.escape(amount) + ', balance = balance + ' + pool.escape(amount) + ' WHERE token = ' + pool.escape(token), function(er, ro) {
                            if(er) throw er;

                            addLog(users[token].steamid, 'aff_collect_earnings', '+' + amount, 'Collected ' + amount + '.', function() {
                                users[token].affamount = 0;
                                users[token].affcollected = parseInt(row[0].affcollected) + amount;

                                user_balance_check(token, function(err, bal) {
                                    if(err) return socket.emit('user eroare', 'An error occurred while checking your balance!');

                                    users[token].balance = bal;
                                    socket.emit('user balance', users[token].balance);
                                    socket.emit('user alerta', 'You have successfully collected ' + amount + ' coins from your referrals!');
                                    socket.emit('user info', users[token]);
                                });
                            });
                        });
                    } else socket.emit('user eroare', 'You need to have ' + config.site_name + ' in your name before collecting earnings!');
                });
            });
        }
    });

    socket.on('affiliates change promocode', function(code, token) {
        logger.trace('[RAW] affiliates change promocode');
		logger.trace(code);
		logger.trace(users[token].steamid);
        if(users.hasOwnProperty(token) && code && token) {
            antiSpam(socket, token, function() {
                if((/^([a-zA-Z0-9]{4,12})$/.test(code)) == true) {
                    pool.query('SELECT user FROM codes WHERE code = ' + pool.escape(code), function(err, row) {
                        if(err) throw err;

                        pool.query('SELECT id FROM codes WHERE user = ' + pool.escape(code), function(er, ro) {
                            if(er) throw er;

                            if(ro.length == 0) {
                                if(row.length == 0) {
                                    pool.query('INSERT INTO codes SET code = ' + pool.escape(code) + ', user = ' + pool.escape(users[token].steamid), function(err, row) {
                                        if(err) throw err;

                                        socket.emit('user alerta', 'Your code has been set to <b>' + code + '</b>!');
                                        users[token].promocode = code;
                                        socket.emit('affiliates code changed', users[token].promocode);
                                        socket.emit('user modal', '#aff_newpromocode', 'close');
                                    });
                                } else return socket.emit('user eroare', 'This code already exists!');
                            } else return socket.emit('user eroare', 'The promo code can be set just one time!');
                        });
                    });
                } else return socket.emit('user eroare', 'The code can be alphanumeric and between 4-12 chars.');
            });
        }
    });

        // WEBSITE FAIR CHECK
        socket.on('website fair check', function(sth, game, token) {
            if(users.hasOwnProperty(token) && game && token) {
                if(game == 'roulette') return socket.emit('user alerta', 'This round is fair! Read through the modal to understand how.');
                else if(game == 'raffles') {
                    if(!sth.includes('not ended')) return socket.emit('user alerta', 'This raffle game is fair! Read through the modal to understand how.');
                    socket.emit('user eroare', 'The raffle game is not ended!');
                }
            }
        });
        // WEBSITE FAIR CHECK

    // ADMIN CREATE PROMOTIONAL CODES
    socket.on('admin create promotional code', function(code, amount, uses, token) {
        if(users.hasOwnProperty(token) && code && amount && uses && token) {
            if(users[token].rank == 100) {
                if(amount < 1 || amount > 5000) return socket.emit('user eroare', 'Error creating code. [Amount: 1 - 5000 coins]');
                if(uses < 1 || uses > 100) return socket.emit('user eroare', 'Error creating code. [Uses: 1 - 100 uses]');

                if(Promotional_codes.hasOwnProperty(code)) {
                    socket.emit('user alerta', 'This promotional code already exists. Now is deleted + all users that claimed reseted!');
                    delete Promotional_codes[code];
                }

                Promotional_codes[code] = {
                    amount: amount,
                    uses: uses,
                    current_users: []
                };

                logger.error('Admin ' + users[token].steamid + ' made code ' + code + ' with amount ' + amount + ' for ' + uses + ' uses!');

                socket.emit('user alerta', 'Successfully created promotional code <b>' + code + '</b>, amount per user <b>' + Promotional_codes[code].amount + '</b>, max. uses <b>' + Promotional_codes[code].uses + '</b>!');
            }
        }
    });

    socket.on('admin delete promotional code', function(code, token) {
        if(users.hasOwnProperty(token) && code && token) {
            if(users[token].rank == 100) {
                if(Promotional_codes.hasOwnProperty(code)) {
                    socket.emit('user alerta', 'Code removed! Users cannot redeem it from now.');

                    logger.error('Admin ' + users[token].steamid + ' removed promotional code ' + code + '!');

                    delete Promotional_codes[code];
                } else socket.emit('user eroare', 'This code seems to no exist in the db or already ended!');
            }
        }
    });

    socket.on('admin check promotional code', function(code, token) {
        if(users.hasOwnProperty(token) && code && token) {
            if(users[token].rank == 100) {
                if(Promotional_codes.hasOwnProperty(code)) {
                    socket.emit('user alerta', 'Code: ' + code + '<br>Current users in: ' + Promotional_codes[code].current_users.length + '<br>Left uses: ' + parseInt(Promotional_codes[code].uses-Promotional_codes[code].current_users.length) + '<br>Amount: ' + Promotional_codes[code].amount + ' coins.');
                } else socket.emit('user eroare', 'This code seems to no exist in the db!');
            }
        }
    });
    // ADMIN CREATE PROMOTIONAL CODES


    // ADMIN THINGS
    socket.on('admin disable send', function(steamid, token) {
        if(users.hasOwnProperty(token) && users[token].rank == 100) {
            pool.query('SELECT disabled_send FROM users WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                if(err) return logger.trace(users[token].steamid + ' - error disabling send - 1');

                if(row[0].disabled_send == 0) {
                    pool.query('UPDATE users SET disabled_send = 1 WHERE steamid = ' + pool.escape(steamid), function(e) {
                        socket.emit('user alerta', 'The send is now disabled!');
                    });
                } else {
                    pool.query('UPDATE users SET disabled_send = 0 WHERE steamid = ' + pool.escape(steamid), function(e) {
                        socket.emit('user alerta', 'The send is now enabled!');
                    });
                }
            });
        }
    });

    socket.on('admin disable withdraw', function(steamid, token) {
        if(users.hasOwnProperty(token) && users[token].rank == 100) {
            pool.query('SELECT disabled_withdraw FROM users WHERE steamid = ' + pool.escape(steamid), function(err, row) {
                if(err) return logger.trace(users[token].steamid + ' - error disabling withdraw - 1');

                if(row[0].disabled_withdraw == 0) {
                    pool.query('UPDATE users SET disabled_withdraw = 1 WHERE steamid = ' + pool.escape(steamid), function(e) {
                        socket.emit('user alerta', 'The withdraw is now disabled!');
                    });
                } else {
                    pool.query('UPDATE users SET disabled_withdraw = 0 WHERE steamid = ' + pool.escape(steamid), function(e) {
                        socket.emit('user alerta', 'The withdraw is now enabled!');
                    });
                }
            });
        }
    });
    // ADMIN THINGS

    socket.on('disconnect', function() {
        var token = socketids[socket.id];

        if(users.hasOwnProperty(token)) {
            if(User_minesweeper.hasOwnProperty(users[token].steamid)) {
                pool.query('UPDATE users SET balance = balance + ? WHERE token = ?', [parseInt(Minesweeper[User_minesweeper[users[token].steamid]].amount), token], function(e,r) {
                    if(e) throw e;

                    pool.query('UPDATE mines SET win = 2 WHERE id = ?', [User_minesweeper[users[token].steamid]], function(er) {
                        if(er) throw er;


                        delete User_minesweeper[users[token].steamid];
                    });
                });
            }
        }


        delete sockets[socketids[socket.id]];
        delete socketids[socket.id];
        delete ips[socket.handshake.headers['x-forwarded-for']];

        delete Useri_IP[socket.handshake.headers['x-forwarded-for']];

        io.sockets.emit('website users online', Object.keys(ips).length);
    });
});

function checkSteamLevel(steamid, cb) {
    var url = 'http://api.steampowered.com/IPlayerService/GetSteamLevel/v1/?key=' + config.steam_api_key + '&steamid=' + encodeURIComponent(steamid);
    request(url, function(err, res, body) {
        if(res.statusCode == 200) {
            var level = JSON.parse(body);
            cb(level.response.player_level);
        } else cb(0);
    });
}

function cmdSyntax(cmd, socket) {
    if(cmd == '/mute') socket.emit('user alerta', 'Syntax: /mute [steamid] [seconds]');
    else if(cmd == '/ban') socket.emit('user alerta', 'Syntax: /ban [steamid]');
    else if(cmd == '/unban') socket.emit('user alerta', 'Syntax: /unban [steamid]');
    else if(cmd == '/clear') socket.emit('user alerta', 'Syntax: /clear');
    else if(cmd == '/send') socket.emit('user alerta', 'Syntax: /send [steamid] [coins]');
}

function addNewTrade(tid, type, ids, token, cb) {
    pool.query('INSERT INTO trades SET tid = ' + pool.escape(tid) + ', itemids = ' + pool.escape(ids) + ', user = ' + pool.escape(users[token].steamid) + ', type = ' + pool.escape(type) + ', status = "0", status_text = "PENDING", time = ' + pool.escape(time()), function(err, row) {
        if(err) return cb(1, 'Error occurred while adding the deposit into DB! Contact an Administrator!');

        cb(0);
    });
}

function editTrade(tid, status, cb) {
    var status_text = "";
    if(status == 1) status_text = "ACCEPTED";
    else if(status == 2) status_text = "DECLINED";
    else status_text = "NO_LONGER_VALID";

    pool.query('UPDATE trades SET status = ' + pool.escape(status) + ', status_text = ' + pool.escape(status_text) + ' WHERE tid = ' + pool.escape(tid), function(err, row) {
        if(err) cb(1);
        cb(0);
    });
}

function editTradeAmount(tid, amount, cb) {
    pool.query('UPDATE trades SET amount = ' + pool.escape(amount) + ' WHERE tid = ' + pool.escape(tid), function(err, row) {
        if(err) cb(1);
        cb(0);
    });
}

function website_getInventory() {
    website_inventory = [];

    ET.IUser.GetInventory({'app_id': 1, 'per_page': 500}, (err, body) => {
        if(err) return logger.error('An error happened while loading website inventory');

        var pages = body.total_pages;
        for(var i = 0; i < pages; i++) {
            var pagina = parseInt(i+1);
            ET.IUser.GetInventory({'app_id': 1, 'per_page': 500, 'page': pagina}, (er, bod) => {
                var items = bod.response.items;
                for(var h in items) {
                    var itm = items[h];
                    website_inventory.push({
                        id: itm.id,
                        name: itm.name,
                        price: parseInt(parseInt(itm.suggested_price*10)*1.15),
                        image: itm.image["600px"]
                    });
                }
            });
        }

        pool.query('SELECT * FROM inv', function(e, r) {
            if(e) throw e;
            if(r.length == 0) return;

            for(var h in r) {
                var itm = r[h];

                website_inventory.push({
                    id: itm.itemid,
                    name: itm.name,
                    price: parseInt(parseInt(itm.price*1000)*1.15),
                    image: itm.image
                });

            }
        });

        setTimeout(function() {
            logger.info('Successfully loaded website inventory. Items count: ' + website_inventory.length);
        }, 2500);
    });
}

function users_getInventory(token, socket, cb) {
    ET.ITrade.GetUserInventoryFromSteamId({'steam_id': users[token].steamid, 'app_id': 1, 'per_page': 500}, (err, body) => {
        if(err) return socket.emit('user eroare', 'An error occurred while loading your inventory!');

        users_inventory[token] = {
            items: []
        };

        var pages = parseInt(body.total_pages);
        for(var i = 0; i < pages; i++) {
            var pagina = parseInt(i+1);
            ET.ITrade.GetUserInventoryFromSteamId({'steam_id': users[token].steamid, 'app_id': 1, 'per_page': 500, 'page': pagina}, (er, bod) => {
                var itemele = bod.response.items;
                for(var h in itemele) {
                    var itm = itemele[h];
                    var $pret = parseInt(itm.suggested_price*10);
                    if($pret < config.deposit.minValuePerItem) continue;
                    users_inventory[token].items.push({
                        id: itm.id,
                        name: itm.name,
                        price: $pret,
                        image: itm.image["600px"]
                    });
                }
            });
        }

        setTimeout(function() {
            cb(users_inventory[token].items);
        }, 1250);
    });
}



// roulette
function startRoulette() {
    if(currentMode == 'NONE') {
        currentHash = sha256(config.site_name + '-' + time() + '-' + Math.floor(Math.random() * (690 - 1 + 1)) + 1);
        currentLottery = time();
        currentSecret = makeCode();
        logger.trace('[Roulette] nextRoll --> Round hash: ' + currentHash + ' | Lottery: ' + currentLottery + ' | Secret: ' + currentSecret + ' | Cifra: ' + getCifra(currentHash, currentSecret, currentLottery));
        io.sockets.emit('roulette_hash', currentHash);
        currentMode = 'WAITING';
        var rolls = setInterval(function() {
            currentTimer = currentTimer - 1;
            if(currentTimer == 0) {
                clearInterval(rolls);
                currentMode = 'ROLLING';
                setTimeout(function() {
                    startRolling();
                }, 600);
            }
        }, 100);
    } else if(currentMode == 'ENDED') {
        currentHash = sha256(config.site_name + '-' + time() + '-' + Math.floor(Math.random() * (690 - 1 + 1)) + 1);
        currentLottery = time();
        currentSecret = makeCode();
        logger.trace('[Roulette] nextRoll --> Round hash: ' + currentHash + ' | Lottery: ' + currentLottery + ' | Secret: ' + currentSecret + ' | Cifra: ' + getCifra(currentHash, currentSecret, currentLottery));
        io.sockets.emit('roulette_hash', currentHash);
        currentTimer = 200;
        currentMode = 'WAITING';
        var rolls = setInterval(function() {
            currentTimer = currentTimer - 1;
            if(currentTimer == 0) {
                clearInterval(rolls);
                currentMode = 'ROLLING';
                setTimeout(function() {
                    startRolling();
                }, 600);
            }
        }, 100);
        io.sockets.emit('roulette_start', currentTimer, currentLastNumber, currentLastWooble, currentHash);
    }
}

function getLastRolls() {
    pool.query('SELECT id, rolled, hash, lottery, secret FROM rolls ORDER BY id DESC LIMIT 12', function(err, row) {
        if(err) throw err;
        if(row.length == 0) return;

        for(var z in row) {
            var itm = row[z].rolled;
            lastRolls.push({
                id: itm.id,
                rolled: itm.rolled,
                hash: itm.hash,
                lottery: itm.lottery,
                secret: itm.secret
            });
        }

        lastRolls.sort(function(a,b) {return a.id-b.id;});
    });
}

function startRolling() {
    var cifra = getCifra(currentHash, currentSecret, currentLottery);

    var wooble = Math.random() * (0.8 - 0.3) + 0.3;


    currentLastNumber = cifra;
    currentLastWooble = wooble;

    pool.query('INSERT INTO rolls SET rolled = ' + pool.escape(cifra) + ', hash = ' + pool.escape(currentHash) + ', lottery = ' + pool.escape(currentLottery) + ', secret = ' + pool.escape(currentSecret), function(err, row) {
        io.sockets.emit('roulette_roll', cifra, wooble, row.insertId, currentHash, currentSecret, currentLottery);


        lastRolls.push({
            id: row.insertId,
            rolled: cifra,
            hash: currentHash,
            secret: currentSecret,
            lottery: currentLottery
        });

        if(cifra >= 1 && cifra <= 7) allLastRolls.push('red');
        else if(cifra >= 8 && cifra <= 14) allLastRolls.push('black');
        else allLastRolls.push('green');

        allLastRolls.shift();

        setTimeout(function() {
            totalRollsAll(function(red, green, black) {
                io.sockets.emit('roulette 100 rolls', red, green, black);
            });
        }, 7000);

        if(lastRolls.length >= 12) lastRolls.shift();
    });

    setTimeout(function() {
        setTimeout(function() {
            winnerRoulette(cifra);
        }, 2500);
    }, 7000);
}

function getAllLastRolls() {
    pool.query('SELECT rolled FROM rolls ORDER BY id DESC LIMIT 100', function(err, row) {
        if(err) throw err;
        if(row.length == 0) return;

        for(var z in row) {
            var itm = parseInt(row[z].rolled);
            if(itm >= 1 && itm <= 7) allLastRolls.push('red');
            else if(itm >= 8 && itm <= 14) allLastRolls.push('black');
            else allLastRolls.push('green');
        }
    });
}

function totalRollsAll(cb) {
    var red = 0;
    var black = 0;
    var green = 0;
    for(var z in allLastRolls) {
        var num = allLastRolls[z];
        if(num == 'red') red++;
        else if(num == 'black') black++;
        else green++;
    }
    cb(red, green, black);
}

function winnerRoulette(cifra) {
    currentMode = 'ENDED';
    currentBets.forEach(function(i) {
        if(i.color == 'red' && (cifra >= 1 && cifra <= 7) && i.user != -1) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(i.bet*2)) + ', wwags = wwags + ' + pool.escape(parseInt(i.bet*2)) + ' WHERE steamid = ' + pool.escape(i.user), function(err, row) {
                addLog(i.user, 'roulette_winbet', '+' + i.bet*2, 'Roulette win on color red', function() {
                    logger.info('Bets user ' + i.user + ' won ' + i.bet*2 + ' (base = ' + i.bet + ') on color red');
                    pool.query('UPDATE bets SET won = 1 WHERE id = ' + pool.escape(i.id));
                    users[tokens[i.user]].balance = parseInt(users[tokens[i.user]].balance + i.bet*2)
                    if(io.sockets.connected[ssockets[i.user]]) io.sockets.connected[ssockets[i.user]].emit('user balance', users[tokens[i.user]].balance);
                });
            });
        } else if(i.color == 'black' && (cifra >= 8 && cifra <= 14) && i.user != -1) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(i.bet*2)) + ', wwags = wwags + ' + pool.escape(parseInt(i.bet*2)) + ' WHERE steamid = ' + pool.escape(i.user), function(err, row) {
                addLog(i.user, 'roulette_winbet', '+' + i.bet*2, 'Roulette win on color black', function() {
                    logger.info('Bets user ' + i.user + ' won ' + i.bet*2 + ' (base = ' + i.bet + ') on color black');
                    pool.query('UPDATE bets SET won = 1 WHERE id = ' + pool.escape(i.id));
                    users[tokens[i.user]].balance = parseInt(users[tokens[i.user]].balance + i.bet*2)
                    if(io.sockets.connected[ssockets[i.user]]) io.sockets.connected[ssockets[i.user]].emit('user balance', users[tokens[i.user]].balance);
                });
            });
        } else if(i.color == 'green' && (cifra == 0) && i.user != -1) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(i.bet*14)) + ', wwags = wwags + ' + pool.escape(parseInt(i.bet*14)) + ' WHERE steamid = ' + pool.escape(i.user), function(err, row) {
                addLog(i.user, 'roulette_winbet', '+' + i.bet*14, 'Roulette win on color green', function() {
                    logger.info('Bets user ' + i.user + ' won ' + i.bet*14 + ' (base = ' + i.bet + ') on color green');
                    pool.query('UPDATE bets SET won = 1 WHERE id = ' + pool.escape(i.id));
                    users[tokens[i.user]].balance = parseInt(users[tokens[i.user]].balance + i.bet*14)
                    if(io.sockets.connected[ssockets[i.user]]) io.sockets.connected[ssockets[i.user]].emit('user balance', users[tokens[i.user]].balance);
                });
            });
        }
    });
    currentBets = [];
    betsUsers = {};
    roulette_bet_color = {};
    startRoulette();
}

function getCifra(hash, secret, lottery) {
    var cifra = sha256(hash+'-'+secret+'-'+lottery);
    cifra = hexdec(cifra.substr(0, 8)) % 15;
    return cifra;
}

function hexdec(hexString) {
    hexString = (hexString + '').replace(/[^a-f0-9]/gi, '')
    return parseInt(hexString, 16)
}

function makeCode() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for(var i=0; i < 16; i++)
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}
// roulette

// RAFFLES22
function resumeRaffles() {
    pool.query('SELECT * FROM raffles WHERE ended = 0', function(err, row) {
        if(err) throw err;
        if(row.length == 0) return website_getInventory();

        for(var z in row) {
            var itm = row[z];
            Raffles.WinnerSecret[itm.id] = itm.secret_winner;
            Raffles.List[itm.id] = {
                id: itm.id,
                enter: true,
                hash: itm.hash,
                secrets: itm.secrets,
                slots: itm.slots,
                sslots: [],
                busy_slots: {},
                users: {},
                item: {
                    id: itm.item_id,
                    price: itm.item_price,
                    image: itm.item_image,
                    name: itm.item_name,
                    price_per_ticket: parseInt(itm.price_per_ticket)
                }
            };

            if(itm.item_id == 0) {
                if(Raffles.List[itm.id].item.price >= 8000) {
                    if(!GenerationRaffles.coins.hasOwnProperty('high')) GenerationRaffles.coins.high = 1;
                    else GenerationRaffles.coins.high = parseInt(GenerationRaffles.coins.high) + 1;
                } else if(Raffles.List[itm.id].item.price >= 3000 && Raffles.List[itm.id].item.price < 7800) {
                    if(!GenerationRaffles.coins.hasOwnProperty('med')) GenerationRaffles.coins.med = 1;
                    else GenerationRaffles.coins.med = parseInt(GenerationRaffles.coins.med) + 1;
                } else if(Raffles.List[itm.id].item.price >= 500 && Raffles.List[itm.id].item.price < 1500) {
                    if(!GenerationRaffles.coins.hasOwnProperty('low')) GenerationRaffles.coins.low = 1;
                    else GenerationRaffles.coins.low = parseInt(GenerationRaffles.coins.low) + 1;
                }
            } else {
                if(Raffles.List[itm.id].item.price >= 8000) {
                    if(!GenerationRaffles.skins.hasOwnProperty('high')) GenerationRaffles.skins.high = 1;
                    else GenerationRaffles.skins.high = parseInt(GenerationRaffles.skins.high) + 1;
                } else if(Raffles.List[itm.id].item.price >= 3000 && Raffles.List[itm.id].item.price < 7800) {
                    if(!GenerationRaffles.skins.hasOwnProperty('med')) GenerationRaffles.skins.med = 1;
                    else GenerationRaffles.skins.med = parseInt(GenerationRaffles.skins.med) + 1;
                } else if(Raffles.List[itm.id].item.price >= 500 && Raffles.List[itm.id].item.price < 1500) {
                    if(!GenerationRaffles.skins.hasOwnProperty('low')) GenerationRaffles.skins.low = 1;
                    else GenerationRaffles.skins.low = parseInt(GenerationRaffles.skins.low) + 1;
                }
            }

            Raffles.Tipul[itm.id] = itm.tipul;
            website_inv_raffles.push(itm.item_id);
        }

        logger.info('[RAW] - Generation Raffles');
        logger.info(GenerationRaffles);

        for(var h in Raffles.List) {
            var id = Raffles.List[h].id;
            manuallyJoinRaffles(id);
        }

        website_getInventory();

        logger.info('[RAFFLES] Loaded ' + row.length + ' raffles from database!');
    });
}

function manuallyJoinRaffles(raffle_id) {
    pool.query('SELECT * FROM raffles_entries WHERE raffle_id = ' + pool.escape(raffle_id), function(err, row) {
        if(err) throw err;
        if(row.length == 0) return;

        for(var h in row) {
            var itm = row[h];
            manuallyJoinRaffle(raffle_id, itm);
        }
    });
}

function manuallyJoinRaffle(raffle_id, row) {
    pool.query('SELECT name, avatar FROM users WHERE steamid = ' + pool.escape(row.user), function(er, ro) {
        if(er) throw er;
        if(ro.length == 0) return;

        var ppp = Raffles.List[raffle_id].item.price_per_ticket;
        var total_price = 0;

        var slots_number = [];
        slots_number.push(row.slot_number);

        for(var z in slots_number) {
            total_price += ppp;
        }

        var steamid = row.user;
        var name = ro[0].name;
        var avatar = ro[0].avatar;

        for(var z in slots_number) {
            var slot_number = slots_number[z];

            if(!Raffles.Joined.hasOwnProperty(raffle_id)) Raffles.Joined[raffle_id] = [];

            Raffles.List[raffle_id].sslots.push(slot_number);
            Raffles.List[raffle_id].busy_slots[slot_number] = {
                steamid: steamid,
                name: name,
                avatar: avatar,
                color: Raffles.Colors[slot_number]
            };

            Raffles.Joined[raffle_id].push(steamid);

            if(Raffles.List[raffle_id].users.hasOwnProperty(steamid)) {
                Raffles.List[raffle_id].users[steamid].slots.push({
                    slot: slot_number,
                    color: Raffles.Colors[slot_number]
                });
            } else {
                Raffles.List[raffle_id].users[steamid] = {
                    steamid: steamid,
                    name: name,
                    avatar: avatar,
                    slots: []
                };
                Raffles.List[raffle_id].users[steamid].slots.push({
                    slot: slot_number,
                    color: Raffles.Colors[slot_number]
                });
            }
            io.sockets.emit('raffles new join raffle', Raffles.List[raffle_id]);

            logger.info('[RAFFLES - BOT] User ' + name + ' (' + steamid + ') joined raffle #' + raffle_id + ' on slot #' + slot_number + ' for ' + total_price + ' coins!');

            if(Raffles.List[raffle_id].slots == Object.keys(Raffles.List[raffle_id].busy_slots).length) {
                Raffles.List[raffle_id].enter = false;
                emitRaffleWinner(raffle_id);
            }
        }
    });
}

function createRaffle(name, image, price, itemid, slots, socket, admin) {
    var hash;
    var secrets = [];
    for(var i = 0; i < slots; i++) {
        secrets.push(RaffleSecret());
    }
    var random_user = Math.floor(Math.random()*(slots-1-0+1)+0);
    var secret_winner = secrets[random_user];
    hash = encrypt(secrets.join('-'), secret_winner);

    var price_now = price*1.08;
    var price_per_ticket = parseInt(price_now/slots);

    var tipul;
    if(itemid == 0) tipul = 0;
    else tipul = 1;

    if(itemid != 0 && website_inv_raffles.indexOf(itemid) > -1) {
        if(socket != 0) socket.emit('user eroare', 'This item is already in the raffle!');
        else logger.info('This item ' + itemid + ' is already in the raffle!');
        return;
    }

    website_inv_raffles.push(itemid);

    pool.query(`INSERT INTO raffles SET tipul = ` + pool.escape(tipul) + `, item_id = ` + pool.escape(itemid) + ` , item_name = ` + pool.escape(name) + `, item_image = ` + pool.escape(image) + `, item_price = ` + pool.escape(price) + `, slots = ` + pool.escape(slots) + `
    , price_per_ticket = ` + pool.escape(price_per_ticket) + `, hash = ` + pool.escape(hash) + `, secrets = ` + pool.escape(secrets.join('-')) + `, secret_winner = ` + pool.escape(secret_winner) + `
    , secret_number = ` + pool.escape(random_user) + ', time = ' + pool.escape(time()), function(err, row) {

        if(err) throw err;

        Raffles.WinnerSecret[row.insertId] = secret_winner;

        if(admin == 1) {
            var inv = [];
            for(var z in website_inventory) {
                for(var h in website_inv_raffles) {
                    if(website_inventory[z].id == website_inv_raffles[h]) website_inventory[z].ss = 1;
                }
            }

            for(var z in website_inventory) {
                if(website_inventory[z].ss != 1) inv.push(website_inventory[z]);
            }

            socket.emit('user withdraw inventory', inv);
        }

        Raffles.List[row.insertId] = {
            id: row.insertId,
            enter: true,
            hash: hash,
            secrets: secrets.join('-'),
            slots: slots,
            sslots: [],
            busy_slots: {},
            users: {},
            item: {
                id: itemid,
                price: price,
                image: image,
                name: name,
                price_per_ticket: parseInt(price_per_ticket)
            }
        };

        if(itemid == 0) {
            if(Raffles.List[row.insertId].item.price >= 8000) {
                if(!GenerationRaffles.coins.hasOwnProperty('high')) GenerationRaffles.coins.high = 1;
                else GenerationRaffles.coins.high = parseInt(GenerationRaffles.coins.high) + 1;
            } else if(Raffles.List[row.insertId].item.price >= 3000 && Raffles.List[row.insertId].item.price < 7800) {
                if(!GenerationRaffles.coins.hasOwnProperty('med')) GenerationRaffles.coins.med = 1;
                else GenerationRaffles.coins.med = parseInt(GenerationRaffles.coins.med) + 1;
            } else if(Raffles.List[row.insertId].item.price >= 500 && Raffles.List[row.insertId].item.price < 1500) {
                if(!GenerationRaffles.coins.hasOwnProperty('low')) GenerationRaffles.coins.low = 1;
                else GenerationRaffles.coins.low = parseInt(GenerationRaffles.coins.low) + 1;
            }
        } else {
            if(Raffles.List[row.insertId].item.price >= 8000) {
                if(!GenerationRaffles.skins.hasOwnProperty('high')) GenerationRaffles.skins.high = 1;
                else GenerationRaffles.skins.high = parseInt(GenerationRaffles.skins.high) + 1;
            } else if(Raffles.List[row.insertId].item.price >= 3000 && Raffles.List[row.insertId].item.price < 7800) {
                if(!GenerationRaffles.skins.hasOwnProperty('med')) GenerationRaffles.skins.med = 1;
                else GenerationRaffles.skins.med = parseInt(GenerationRaffles.skins.med) + 1;
            } else if(Raffles.List[row.insertId].item.price >= 500 && Raffles.List[row.insertId].item.price < 1500) {
                if(!GenerationRaffles.skins.hasOwnProperty('low')) GenerationRaffles.skins.low = 1;
                else GenerationRaffles.skins.low = parseInt(GenerationRaffles.skins.low) + 1;
            }
        }

        logger.info('[RAW] - Generation Raffles');
        logger.info(GenerationRaffles);

        Raffles.Tipul[row.insertId] = tipul;

        if(socket != 0) socket.emit('user alerta', 'Raffle #' + row.insertId + ' created successfully!');

        io.sockets.emit('raffles new raffle', Raffles.List[row.insertId]);
    });
}

function joinRaffle(raffle_id, slots_number, token, socket) {
    var min = 0;
    var max = Raffles.List[raffle_id].slots-1;
    var ppp = Raffles.List[raffle_id].item.price_per_ticket;
    var entried = false;
    var not_found = false;
    var total_price = 0;

    if(slots_number.length > 1 && users[token].rank != 100) return socket.emit('user eroare', 'You can just select on ticket per raffle!');

    for(var z in Raffles.List[raffle_id].sslots) {
        var itm = Raffles.List[raffle_id].sslots[z];
        for(var i in slots_number) {
            if(slots_number[i] == itm) entried = true;
            break;
        }
    }

    for(var i in slots_number) {
        var itm = slots_number[i];
        if(itm < min || itm > max) {
            not_found = true;
            break;
        }
    }

    for(var z in slots_number) {
        total_price += ppp;
    }

    if(entried == true) return socket.emit('user eroare', 'This ticket doesn\'t exists!');
    if(not_found == true) return socket.emit('user eroare', 'This ticket doesn\'t exists!');

    if(!Raffles.List.hasOwnProperty(raffle_id)) return socket.emit('user eroare', 'This raffle doesn\'t exists!');
    if(Raffles.List[raffle_id].enter == false) return socket.emit('user eroare', 'This raffle is ended!');

    if(Raffles.Joined.hasOwnProperty(raffle_id)) {
        if(Raffles.Joined[raffle_id].indexOf(users[token].steamid) > -1 && users[token].rank != 100) return socket.emit('user eroare', 'You have already joined this raffle!');
    } else Raffles.Joined[raffle_id] = [];

    var steamid = users[token].steamid;
    var name = users[token].name;
    var avatar = users[token].avatar;

    user_balance_check(token, function(err, bal) {
        if(total_price > bal) return socket.emit('user eroare', 'Not enough balance to buy these tickets!');

        for(var z in slots_number) {
            var slot_number = slots_number[z];

            Raffles.Joined[raffle_id].push(users[token].steamid);

            Raffles.List[raffle_id].sslots.push(slot_number);
            Raffles.List[raffle_id].busy_slots[slot_number] = {
                steamid: steamid,
                name: name,
                avatar: avatar,
                color: Raffles.Colors[slot_number]
            };

            if(Raffles.List[raffle_id].users.hasOwnProperty(steamid)) {
                Raffles.List[raffle_id].users[steamid].slots.push({
                    slot: slot_number,
                    color: Raffles.Colors[slot_number]
                });
            } else {
                Raffles.List[raffle_id].users[steamid] = {
                    steamid: steamid,
                    name: name,
                    avatar: avatar,
                    slots: []
                };
                Raffles.List[raffle_id].users[steamid].slots.push({
                    slot: slot_number,
                    color: Raffles.Colors[slot_number]
                });
            }

            io.sockets.emit('raffles new join raffle', Raffles.List[raffle_id]);
            socket.emit('user alerta', 'You successfully bought slot #' + (parseInt(slot_number)+1) + ' of raffle #' + raffle_id);

            logger.info('[RAFFLES] User ' + users[token].name + ' (' + users[token].steamid + ') joined raffle #' + raffle_id + ' on slot #' + slot_number + ' for ' + total_price + ' coins!');

            pool.query('INSERT INTO raffles_entries SET raffle_name = ' + pool.escape(Raffles.List[raffle_id].item.name) + ', raffle_img = ' + pool.escape(Raffles.List[raffle_id].item.image) + ', raffle_price = ' + pool.escape(Raffles.List[raffle_id].item.price) + ', raffle_ppt = ' + pool.escape(Raffles.List[raffle_id].item.price_per_ticket) + ', raffle_id = ' + pool.escape(raffle_id) + ', slot_number = ' + pool.escape(slot_number) + ', user = ' + pool.escape(steamid) + ', name = ' + pool.escape(name) + ', avatar = ' + pool.escape(avatar) +
            ', won = "-1", time = ' + pool.escape(time()), function(err, row) {
                if(err) throw err;


            });

            if(Raffles.List[raffle_id].slots == Object.keys(Raffles.List[raffle_id].busy_slots).length) {
                Raffles.List[raffle_id].enter = false;
                emitRaffleWinner(raffle_id);
            }
        }

        pool.query('UPDATE users SET balance = balance - ' + pool.escape(parseInt(total_price)) + ', wags = wags + ' + pool.escape(total_price) + ', wagered = wagered + ' + pool.escape(parseInt(total_price)) + ', available = available + ' + pool.escape(parseInt(total_price)) + ' WHERE steamid = ' + pool.escape(users[token].steamid), function(er, ro) {
            if(er) throw er;

            addLog(users[token].steamid, 'raffle_join', '-' + total_price, 'Joined raffle #' + raffle_id + ' on slot #' + slot_number + ' with ' + total_price, function() {
                user_balance_check(token, function(er, bale) {
                    checkWebsiteLevel(token, function(level) {
                        var $color = '';

                        if(level >= 0 && level <= 4) $color = '#919191';
                        else if(level >= 5 && level <= 9) $color = '#2F65FA';
                        else if(level >= 10) $color = '#FC3232';

                        users[token].xp_level = level;
                        users[token].xp_color = $color;
                    });

                    users[token].balance = users[token].balance - parseInt(total_price);
                    socket.emit('user balance', users[token].balance);
                });
            });
        });
    });
}

function emitRaffleWinner(raffle_id) {
    var secreturile = Raffles.List[raffle_id].secrets.split('-');
    var win_secret = Raffles.WinnerSecret[raffle_id];
    var slot_winner;
    for(var i in secreturile) {
        var sec = secreturile[i];
        if(sec == win_secret) {
            slot_winner = i;
            break;
        }
    }

    pool.query('UPDATE raffles SET ended = 1 WHERE id = ' + pool.escape(raffle_id));

    if(Raffles.List[raffle_id].item.id == 0) {
        if(Raffles.List[raffle_id].item.price >= 8000) GenerationRaffles.coins.high--;
        else if(Raffles.List[raffle_id].item.price >= 3000 && Raffles.List[raffle_id].item.price < 7800) GenerationRaffles.coins.med--;
        else if(Raffles.List[raffle_id].item.price >= 500 && Raffles.List[raffle_id].item.price < 1500) GenerationRaffles.coins.low--;
    } else {
        if(Raffles.List[raffle_id].item.price >= 8000) GenerationRaffles.skins.high--;
        else if(Raffles.List[raffle_id].item.price >= 3000 && Raffles.List[raffle_id].item.price < 7800) GenerationRaffles.skins.med--;
        else if(Raffles.List[raffle_id].item.price >= 500 && Raffles.List[raffle_id].item.price < 1500) GenerationRaffles.skins.low--;
    }

    Raffles.List[raffle_id].winner_slot = slot_winner;

    var useri = Raffles.List[raffle_id].busy_slots;
    for(var i in useri) {
        if(i == slot_winner) {
            Raffles.List[raffle_id].winner_user = useri[i];

            io.sockets.emit('raffle emit winner', Raffles.List[raffle_id]);

            logger.info('[RAFFLE] Winner of raffle #' + raffle_id + ' is ' + useri[i].steamid);
            var socket = ssockets[useri[i].steamid];

            var tokenul = tokens[useri[i].steamid];

            if(Raffles.Tipul[raffle_id] == 0) {
                pool.query('UPDATE users SET balance = balance + ' + pool.escape(parseInt(Raffles.List[raffle_id].item.price)) + ', wwags = wwags + ' + pool.escape(parseInt(Raffles.List[raffle_id].item.price)) + ' WHERE steamid = ' + pool.escape(useri[i].steamid), function(jd, lo) {
                    if(jd) throw jd;

                    setTimeout(function() {

                        addLog(users[tokenul].steamid, 'win_raffle_coins', '+' + parseInt(Raffles.List[raffle_id].item.price), 'Won raffle #' + raffle_id + ' slot #' + slot_winner, function() {
                            user_balance_check(tokenul, function(es, bal) {
                                if(es) return logger.trace(users[tokenul].steamid + ' - error getting user balance [emitrafflewinner] - 1');

                                users[tokenul].balance = bal;

                                if(io.sockets.connected[socket]) io.sockets.connected[socket].emit('user balance', bal);

                                if(io.sockets.connected[socket]) io.sockets.connected[socket].emit('user alerta', 'You have successfully won raffle #' + raffle_id + ', your balance got updated!');
                            });
                        });
                    }, 10000);

                    pool.query('UPDATE raffles_entries SET won = "1" WHERE slot_number = ' + pool.escape(slot_winner) + ' AND raffle_id = ' + pool.escape(raffle_id), function(er, row) {
                        pool.query('UPDATE raffles_entries SET ended = "1" WHERE raffle_id = ' + pool.escape(raffle_id), function(e,r) {
                            if(e) return logger.trace(useri[i].steamid + ' - error updating raffles entries [emitrafflewinner] - 2');
                            pool.query('UPDATE raffles SET winner_steamid = ' + pool.escape(useri[i].steamid) + ', winner_status = "1", winner_statustext = "GOT_COINS", time = ' + pool.escape(time()) + ' WHERE id = ' + pool.escape(raffle_id), function(aaa ,bbb) {
                                if(aaa) return logger.trace(useri[i].steamid + ' - error updating raffles [emitrafflewinner] - 3');
                            });
                        });
                    });
                });
            } else {

                pool.query('UPDATE users SET wwags = wwags + ' + pool.escape(parseInt(Raffles.List[raffle_id].item.price)) + ' WHERE steamid = ' + pool.escape(useri[i].steamid), function(jd, lo) {
                    if(jd) throw jd;


                    Raffles.Prizes[raffle_id] = Raffles.List[raffle_id].item;
                    if(Raffles.Prizess.hasOwnProperty(useri[i].steamid)) Raffles.Prizess[useri[i].steamid].push(raffle_id);
                    else {
                        Raffles.Prizess[useri[i].steamid] = [];
                        Raffles.Prizess[useri[i].steamid].push(raffle_id);
                    }

                    setTimeout(function() {
                        if(io.sockets.connected[socket]) io.sockets.connected[socket].emit('user raffle prize settings', raffle_id, raffle_id, Raffles.List[raffle_id].item);
                        if(io.sockets.connected[socket]) io.sockets.connected[socket].emit('user alerta', 'You have win the raffle #' + raffle_id + '. If you do not see any popups, refresh to redeem your prize!');
                    }, 10000);

                    pool.query('UPDATE raffles_entries SET won = "1" WHERE user = ' + pool.escape(useri[i].steamid) + ' AND raffle_id = ' + pool.escape(raffle_id), function(er, row) {
                        pool.query('UPDATE raffles_entries SET ended = "1" WHERE raffle_id = ' + pool.escape(raffle_id), function(e,r) {
                            if(e) return logger.trace(useri[i].steamid+ ' - error updating raffles entries [emitrafflewinner] - 3');
                            pool.query('UPDATE raffles SET winner_steamid = ' + pool.escape(useri[i].steamid) + ', winner_statustext = "NO_ACTION", time = ' + pool.escape(time()) + ' WHERE id = ' + pool.escape(raffle_id), function(aaa, bbb) {
                                if(aaa) return logger.trace(useri[i].steamid + ' - error updating raffles [emitrafflewinner] - 3');
                            });
                        });
                    });

                });
            }
            break;
        }
    }

    setTimeout(function() {
        raffleHide(raffle_id);
    }, 60000);
}

function raffleHide(raffle_id) {
    delete Raffles.List[raffle_id];
    io.sockets.emit('raffle hide', raffle_id);
}

function RaffleSecret() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    for(var i=0;i<16;i++) text += possible.charAt(Math.floor(Math.random() * possible.length));
    return text;
}

setInterval(function() { checkCurrentRaffles(); }, 60000);
function checkCurrentRaffles() {
    logger.info('RAW - Checking Generation Raffles');
    logger.info('SKINS - High - ' + GenerationRaffles.skins.high + ' | Med - ' + GenerationRaffles.skins.med + ' | Low - ' + GenerationRaffles.skins.low);
    logger.info('COINS - High - ' + GenerationRaffles.coins.high + ' | Med - ' + GenerationRaffles.coins.med + ' | Low - ' + GenerationRaffles.coins.low);


    if(GenerationRaffles.coins.hasOwnProperty('high') && GenerationRaffles.coins['high'] < 3) {
        var max = 3;
        var to_add = parseInt(max - GenerationRaffles.coins['high']);

        for(var i = 0; i < to_add; i++) {
            var randMoney = Math.floor(Math.random()*(13-8+1)+8);
            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    } else if(!GenerationRaffles.coins.hasOwnProperty('high')) {
        var to_add = 3;

        for(var i = 0; i < to_add; i++) {
            var randMoney = Math.floor(Math.random()*(13-8+1)+8);
            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    }

    if(GenerationRaffles.coins.hasOwnProperty('med') && GenerationRaffles.coins['med'] < 3) {
        var max = 3;
        var to_add = parseInt(max - GenerationRaffles.coins['med']);

        for(var i = 0; i < to_add; i++) {
            var randMoney = Math.floor(Math.random()*(7-5+1)+5);
            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    } else if(!GenerationRaffles.coins.hasOwnProperty('med')) {
        var to_add = 3;

        for(var i = 0; i < to_add; i++) {
            var randMoney = Math.floor(Math.random()*(7-5+1)+5);
            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    }

    if(GenerationRaffles.coins.hasOwnProperty('low') && GenerationRaffles.coins['low'] < 3) {
        var max = 3;
        var to_add = parseInt(max - GenerationRaffles.coins['low']);

        for(var i = 0; i < to_add; i++) {
            var randM = Math.floor(Math.random()*(3-1+1)+1);
            if(randM == 1) var randMoney = 0.5;
            else if(randM == 2) var randMoney = 1;
            else var randMoney = 1.5;
            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    } else if(!GenerationRaffles.coins.hasOwnProperty('low')) {
        var to_add = 3;

        for(var i = 0; i < to_add; i++) {
            var randM = Math.floor(Math.random()*(3-1+1)+1);
            if(randM == 1) var randMoney = 0.5;
            else if(randM == 2) var randMoney = 1;
            else var randMoney = 1.5;            var randUsers = Math.floor(Math.random()*(5-1+1)+1);
            if(randUsers == 5) var useri = Math.floor(Math.random()*(5-3+1)+3);
            else var useri = 2;
            createRaffle(parseInt(randMoney*1000) + ' Coins', config.coins_img_url, parseInt(randMoney*1000), '0', useri, 0, 0);
        }
    }







    if(GenerationRaffles.skins.hasOwnProperty('high') && GenerationRaffles.skins['high'] < 2) {
        var max = 2;
        var to_add = parseInt(max - GenerationRaffles.skins['high']);
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 8000 && itm.price <= 15000) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    } else if(!GenerationRaffles.skins.hasOwnProperty('high')) {
        var to_add = 2;
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 8000 && itm.price <= 15000) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    }

    if(GenerationRaffles.skins.hasOwnProperty('med') && GenerationRaffles.skins['med'] < 2) {
        var max = 2;
        var to_add = parseInt(max - GenerationRaffles.skins['med']);
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 3000 && itm.price < 7800) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    } else if(!GenerationRaffles.skins.hasOwnProperty('med')) {
        var to_add = 2;
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 3000 && itm.price < 7800) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    }

    if(GenerationRaffles.skins.hasOwnProperty('low') && GenerationRaffles.skins['low'] < 2) {
        var max = 2;
        var to_add = parseInt(max - GenerationRaffles.skins['low']);
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 500 && itm.price < 1500) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    } else if(!GenerationRaffles.skins.hasOwnProperty('low')) {
        var to_add = 2;
        var added_itemids = [];

        loop:
        for(var i = 0; i < to_add; i++) {
            for(var h in website_inventory) {
                var itm = website_inventory[h];
                if((itm.price >= 500 && itm.price < 1500) && website_inv_raffles.indexOf(itm.id) == -1 && added_itemids.indexOf(itm.id) == -1) {
                    added_itemids.push(itm.id);
                    var rand = Math.floor(Math.random()*(4-1+1)+1);
                    var random_users;
                    if(rand == 1) random_users = Math.floor(Math.random()*(5-3+1)+3);
                    else random_users = 2;
                    createRaffle(itm.name, itm.image, itm.price, itm.id, random_users, 0, 0);
                    continue loop;
                }
            }
        }
    }
}
// RAFFLES22

// CHAT CODES
function adminMakeChatCodeGame(users, money) {
    ChatCodes.code = chatcodeCreate();
    ChatCodes.prize = money;
    ChatCodes.max_users = users;
    ChatCodes.users = [];

    var text_message = 'First <b>' + ChatCodes.max_users + '</b> users to write <br><b>' + ChatCodes.code + '</b><br> win <b>' + ChatCodes.prize + '</b> coins each!';
    id_chat_msgs++;
    var props = {
        id: id_chat_msgs,
        steamid: '-1',
        name: 'System',
        avatar: config.domain_name + 'vendor/img/favicon.png',
        rank: 101,
        msg: text_message,
        lang: ''
    };
    chat_msgs.push(props);
    checkChatMessages();
    io.sockets.emit('user chat message add', '', props);
}

function chatcodeCreate() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    for(var i=0;i<12;i++) text += possible.charAt(Math.floor(Math.random() * possible.length));
    return text;
}
// CHAT CODES

// MATH CODES
function adminMakeMathCodeGame(users, money, diff, socket) {
    if(diff == 'easy') {
        var mathQuestion = randomMath_questions.get({
            numberRange: '1-100',
            amountOfNumber: '2-2',
            operations: ['*', '+', '-'],
            nagative: {
                containsNagatives: true,
                negativeChance: '5%'
            },
            exponent: {
                containsExponents: true,
                exponentChance: '5%',
                exponentRange: '2-3'
            }
        });

        MathCodes.question = mathQuestion.question;
        MathCodes.answer = parseInt(mathQuestion.answer);
        MathCodes.prize = money;
        MathCodes.max_users = users;
        MathCodes.users = [];

        var text_message = 'First <b>' + MathCodes.max_users + '</b> users to answer<br><b>(' + MathCodes.question + ') = ?</b><br> win <b>' + MathCodes.prize + '</b> coins each!';
        id_chat_msgs++;
        var props = {
            id: id_chat_msgs,
            steamid: '-1',
            name: 'System',
            avatar: config.domain_name + 'vendor/img/favicon.png',
            rank: 101,
            msg: text_message,
            lang: ''
        };
        chat_msgs.push(props);
        checkChatMessages();
        io.sockets.emit('user chat message add', '', props);

        socket.emit('user alerta', 'The answer for this math code is <b>' + MathCodes.answer + '</b>');
    } else if(diff == 'medium') {
        var mathQuestion = randomMath_questions.get({
            numberRange: '1-3800',
            amountOfNumber: '3-3',
            operations: ['*', '+', '-'],
            nagative: {
                containsNagatives: true,
                negativeChance: '25%'
            },
            exponent: {
                containsExponents: true,
                exponentChance: '25%',
                exponentRange: '2-3'
            }
        });

        MathCodes.question = mathQuestion.question;
        MathCodes.answer = parseInt(mathQuestion.answer);
        MathCodes.prize = money;
        MathCodes.max_users = users;
        MathCodes.users = [];

        var text_message = 'First <b>' + MathCodes.max_users + '</b> users to answer<br><b>(' + MathCodes.question + ') = ?</b><br> win <b>' + MathCodes.prize + '</b> coins each!';
        id_chat_msgs++;
        var props = {
            id: id_chat_msgs,
            steamid: '-1',
            name: 'System',
            avatar: config.domain_name + 'vendor/img/favicon.png',
            rank: 101,
            msg: text_message,
            lang: ''
        };
        chat_msgs.push(props);
        checkChatMessages();
        io.sockets.emit('user chat message add', '', props);

        socket.emit('user alerta', 'The answer for this math code is <b>' + MathCodes.answer + '</b>');
    } else if(diff == 'hard') {
        var mathQuestion = randomMath_questions.get({
            numberRange: '1-8000',
            amountOfNumber: '4-4',
            operations: ['*', '+', '-'],
            nagative: {
                containsNagatives: true,
                negativeChance: '50%'
            },
            exponent: {
                containsExponents: true,
                exponentChance: '50%',
                exponentRange: '2-3'
            }
        });

        MathCodes.question = mathQuestion.question;
        MathCodes.answer = parseInt(mathQuestion.answer);
        MathCodes.prize = money;
        MathCodes.max_users = users;
        MathCodes.users = [];

        var text_message = 'First <b>' + MathCodes.max_users + '</b> users to answer<br><b>(' + MathCodes.question + ') = ?</b><br> win <b>' + MathCodes.prize + '</b> coins each!';
        id_chat_msgs++;
        var props = {
            id: id_chat_msgs,
            steamid: '-1',
            name: 'System',
            avatar: config.domain_name + 'vendor/img/favicon.png',
            rank: 101,
            msg: text_message,
            lang: ''
        };
        chat_msgs.push(props);
        checkChatMessages();
        io.sockets.emit('user chat message add', '', props);

        socket.emit('user alerta', 'The answer for this math code is <b>' + MathCodes.answer + '</b>');
    } else if(diff == 'extreme') {
        var mathQuestion = randomMath_questions.get({
            numberRange: '1-15000',
            amountOfNumber: '5-6',
            operations: ['*', '+', '-'],
            nagative: {
                containsNagatives: true,
                negativeChance: '75%'
            },
            exponent: {
                containsExponents: true,
                exponentChance: '75%',
                exponentRange: '2-5'
            }
        });

        MathCodes.question = mathQuestion.question;
        MathCodes.answer = parseInt(mathQuestion.answer);
        MathCodes.prize = money;
        MathCodes.max_users = users;
        MathCodes.users = [];

        var text_message = 'First <b>' + MathCodes.max_users + '</b> users to answer<br><b>(' + MathCodes.question + ') = ?</b><br> win <b>' + MathCodes.prize + '</b> coins each!';
        id_chat_msgs++;
        var props = {
            id: id_chat_msgs,
            steamid: '-1',
            name: 'System',
            avatar: config.domain_name + 'vendor/img/favicon.png',
            rank: 101,
            msg: text_message,
            lang: ''
        };
        chat_msgs.push(props);
        checkChatMessages();
        io.sockets.emit('user chat message add', '', props);

        socket.emit('user alerta', 'The answer for this math code is <b>' + MathCodes.answer + '</b>');
    }
}
// MATH CODES

// FIRST TO WRITE
function adminFirstToWriteGame(money) {
    FTWrite.text = randomWord().toString().toUpperCase();
    FTWrite.prize = money;
    FTWrite.enabled = true;
    FTWrite.time = parseInt(time());

    var text_message = 'First user to type<br><b>' + FTWrite.text + '</b><br> win <b>' + FTWrite.prize + '</b> coins!';
    id_chat_msgs++;
    var props = {
        id: id_chat_msgs,
        steamid: '-1',
        name: 'System',
        avatar: config.domain_name + 'vendor/img/favicon.png',
        rank: 101,
        msg: text_message,
        lang: ''
    };
    chat_msgs.push(props);
    checkChatMessages();
    io.sockets.emit('user chat message add', '', props);
}
// FIRST TO WRITE


// CHECK BALANCE
function user_balance_check(token, cb) {
    pool.query('SELECT balance FROM users WHERE token = ' + pool.escape(token), function(err, row) {
        if(err) throw err;
        if(row.length == 0) return cb(1);
        cb(0, parseInt(row[0].balance));
    });
}
//



// IN CASE SOMETHING ON WITHDRAW HAPPENS. LIKE THE STATUSES DOESN'T UPDATE. USE THIS!@#!
checkTrades();
function checkTrades() {
    logger.info('[AUTOMATICALLY TRADES CHECKER] Checking pending trades... Waiting!');

    pool.query('SELECT * FROM trades WHERE status = 0', function(err, row) {
        for(var h in row) {
            var itm = row[h];
            checkTrade(itm.tid, itm.type, itm.user, itm.amount);
        }
    });
}


function checkTrade(trade, type, user, amount) {
    ET.ITrade.GetOffer({
        "offer_id": trade
    }, (err, body) => {
        if(err) {
            logger.error('Err on trade #' + trade);
            logger.error(err);
        }
        editTradeBoss(trade, body.response.offer.state, type, user, amount);
    });
}

function editTradeBoss(trade, state, type, user, amount) {
    var status = 0;
    var status_text = "";

    if(state == 3) {
        status = 1;
        status_text = "ACCEPTED";
    } else if(state == 7) {
        status = 2;
        status_text = "DECLINED";
    } else {
        status = 3;
        status_text = "NO_LONGER_VALID"
    }

    if(type == 'deposit') {
        if(state == 3) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE steamid  = ' + pool.escape(user), function(e,r) {
                logger.info('[AUTOMATICALLY TRADES CHECKER] User got +' + amount + ' from depositing trade #' + trade + ' - STATE ' + status_text + ' (' + status + ')');
                addLog(user, 'trade_resumed_deposit_accepted', '+' + amount, 'User got + ' + amount + ' from trade #' + trade + ' - deposit accepted', function() {

                });
            });
        }
    } else if(type == 'withdraw') {
        if(state == 7) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE steamid  = ' + pool.escape(user), function(e,r) {
                logger.info('[AUTOMATICALLY TRADES CHECKER] User got +' + amount + ' from withdrawing trade #' + trade + ' - STATE ' + status_text + ' (' + status + ')');
                addLog(user, 'trade_resumed_withdraw_declined', '+' + amount, 'User got + ' + amount + ' from trade #' + trade + ' - withdraw declined', function() {

                });
            });
        }
    } else if(type == 'raffle') {
        if(state == 7) {
            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE steamid  = ' + pool.escape(user), function(e,r) {
                logger.info('[AUTOMATICALLY TRADES CHECKER] User got +' + amount + ' from raffle trade #' + trade + ' - STATE ' + status_text + ' (' + status + ')');
                addLog(user, 'trade_resumed_raffle_declined', '+' + amount, 'User got + ' + amount + ' from trade #' + trade + ' - raffle declined', function() {

                });
            });
        }
    }


    pool.query('UPDATE trades SET status = ' + pool.escape(status) + ', status_text = ' + pool.escape(status_text) + ' WHERE tid = ' + pool.escape(trade), function(er, ro) {

    });
}

// UPDATE ADMIN DEPOSITS // WITHDRAWS

// var admins = [76561198848739044, 76561198832550366, 76561198168946248, 76561198832499408, 76561198832677454];

// checkAdminsTrades();
// function checkAdminsTrades() {
//     for(var h in admins) {
//         checkNow(admins[h]);
//     }
// }

// function checkNow(admin) {
//     pool.query('SELECT tid, type FROM trades WHERE user = ' + pool.escape(admin), function(er, ro) {
//         if(er) return console.log('An error occurred!');

//         for(var h in ro) {
//             updateAdminTrade(ro[h].tid, ro[h].type, admin);
//         }
//     });
// }

// function updateAdminTrade(tid, type, admin) {
//     var $typul;
//     if(type == 'withdraw') $typul = 'Awithdraw';
//     else if(type == 'deposit') $typul = 'Adeposit';
//     else return;

//     pool.query('UPDATE trades SET type = ' + pool.escape($typul) + ' WHERE tid = ' + pool.escape(tid), function(aaa, bbb) {
//         console.log('Trade #' + tid + ' updated to Admin Trade with type ' + $typul + ' [Admin: ' + admin + ']');
//     });
// }
// MANUALLY



// EXPRESS TRADE POLLING
ET.on('offerReceived', (_offer) => {
    logger.error('Offer received -> ' + _offer.id);

    ET.ITrade.CancelOffer({'offer_id': _offer.id}, (err, body) => {
        if(err) return logger.error('Offer received ' + _offer.id + ' error to be cancelled! ' + body.message);

        logger.error('Offer received ' + _offer.id + ' has been cancelled!');
    });
});

ET.on('offerAccepted', (_offer) => {
    if(pending_deposit.hasOwnProperty(_offer.id) && _offer.recipient.items.length > 0) {
        var amount = pending_deposit[_offer.id].amount;
        var userul = pending_deposit[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 1, function(err) {
            if(err) return logger.error('Error occurred while editing trade #' + _offer.id + ' [offerAccepted] - deposit');

            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ', available = available - ' + pool.escape(amount) + ', depamount = depamount + ' + pool.escape(amount) + ', deps = deps + 1 WHERE steamid = ' + pool.escape(userul), function(er) {
                if(er) return logger.trace(userul + ' - error updating balance [offerAccepted] - 1');

                if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'You have successfully deposited!<br>You got +<b>' + amount + '</b> coins!');

                logger.error('User ' + users[tokenul].name + ' (' + userul + ') deposited ' + amount + ' coins ($' + parseFloat(amount/1000).toFixed(2) + ' | ' + _offer.recipient.items.length + ')');

                user_balance_check(tokenul, function(eroare, balance) {
                    if(eroare) return logger.trace(userul + ' - error checking balance [ offerAccepted ] - 2');

                    users[tokenul].balance = balance;
                    users[tokenul].depamount += parseInt(amount);
                    users[tokenul].available -= parseInt(amount);

                    // ADD AFF EARNINGS FROM DEPOSIT
                    if(users[tokenul].aff != '' && (parseInt(amount) > 99 && parseInt(1/100*parseInt(amount)) >= 1)) {
                        var amountt = parseInt(1/100*parseInt(amount));
                        pool.query('UPDATE users SET affamount = affamount + ' + pool.escape(amountt) + ' WHERE steamid = ' + pool.escape(users[tokenul].aff), function(e, r) {
                            if(e) throw e;
                        });
                    }
                    // ADD AFF EARNINGS FROM DEPOSIT

                    addLog(users[tokenul].steamid, 'deposit_offer_accepted', '+' + amount, 'Deposit offer #' + _offer.id + ' accepted and user got coins!', function() {

                    });

                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user balance', users[tokenul].balance);
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');
                    website_getInventory();

                    delete pending_deposit[_offer.id];
                    delete user_pending_deposit[userul];
                });
            });
        });
    } else if(pending_withdraw.hasOwnProperty(_offer.id) && _offer.sender.items.length > 0) {
        var amount = pending_withdraw[_offer.id].amount;
        var userul = pending_withdraw[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 1, function(err) {
            if(err) return logger.error('Error occurred while editing trade #' + _offer.id + ' [offerAccepted] - withdraw');

            delete pending_withdraw[_offer.id];
            delete user_pending_withdraw[userul];
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Withdraw trade successfully accepted!');
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');

            website_getInventory();
        });
    } else if(pending_raffle.hasOwnProperty(_offer.id)) {
        var userul = pending_raffle[_offer.id].user;
        var rafid = pending_raffle[_offer.id].raffle_id;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 1, function(err) {
            if(err) return logger.error('Error occurred while editing trade #' + _offer.id + ' [offerAccepted] - raffle');

            pool.query('UPDATE raffles SET winner_status = 1, winner_statustext = "TRADE_ACCEPTED" WHERE id = ' + pool.escape(rafid), function(er, ro) {
                delete pending_raffle[_offer.id];
                if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Raffle prize successfully accepted!');
            });
        });
    }
});

ET.on('offerDeclined', (_offer) => {
    if(pending_deposit.hasOwnProperty(_offer.id) && _offer.recipient.items.length > 0) {
        var amount = pending_deposit[_offer.id].amount;
        var userul = pending_deposit[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 2, function(err) {
            if(err) return logger.trace(userul + ' - error [offerDeclined] ' + err.toString() + ' - 1');

            delete pending_deposit[_offer.id];
            delete user_pending_deposit[userul];
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user eroare', 'The trade has been declined!');
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');
        });
    } else if(pending_withdraw.hasOwnProperty(_offer.id) && _offer.sender.items.length > 0) {
        var amount = pending_withdraw[_offer.id].amount;
        var userul = pending_withdraw[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 2, function(err) {
            if(err) return logger.trace(userul + ' - error [offerDeclined] ' + err.toString() + ' - 2');

            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ', withs = withs - 1, available = available + ' + pool.escape(amount) + ', withamount = withamount - ' + pool.escape(amount) + ' WHERE steamid = ' + pool.escape(userul), function(err) {
                if(err) return logger.error('An error updating the balance after declining withdraw on user ' + userul);

                user_balance_check(tokenul, function(aba, hal) {
                    if(aba) {
                        delete pending_withdraw[_offer.id];
                        delete user_pending_withdraw[userul];
                        return;
                    }

                    addLog(users[tokenul].steamid, 'withdraw_offer_declined', '+' + amount, 'Withdraw offer #' + _offer.id + ' declined and user got coins back!', function() {

                    });

                    users[tokenul].available += parseInt(amount);
                    users[tokenul].balance = hal;

                    delete pending_withdraw[_offer.id];
                    delete user_pending_withdraw[userul];
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user eroare', 'The trade has been declined and you have received the coins back!');
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user balance', users[tokenul].balance);
                });
            });
        });
    } else if(pending_raffle.hasOwnProperty(_offer.id)) {
        var userul = pending_raffle[_offer.id].user;
        var amount = pending_raffle[_offer.id].amount;
        var rafid = pending_raffle[_offer.id].raffle_id;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 2, function(err) {
            if(err) return logger.error('Error occurred while editing trade #' + _offer.id + ' [offerDeclined] - raffle');

            delete pending_raffle[_offer.id];

            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE steamid = ' + pool.escape(userul), function(e, r) {
                if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Raffle prize declined.<br>You have received balance worth of skin raffle to your account.');

                addLog(users[tokenul].steamid, 'raffle_offer_declined', '+' + amount, 'Raffle offer #' + _offer.id + ' declined and user got the coins!', function() {

                });

                for(var i in _offer.sender.items) {
                    var itm = _offer.sender.items[i].id;
                    website_inv_raffles.splice(website_inv_raffles.indexOf(itm), 1);
                }

                pool.query('UPDATE raffles SET winner_status = 2, winner_statustext = "TRADE_DECLINED" WHERE id = ' + pool.escape(rafid), function(er, ro) {
                });
            });
        });
    }
});

ET.on('offerNoLongerValid', (_offer) => {
    if(pending_deposit.hasOwnProperty(_offer.id) && _offer.recipient.items.length > 0) {
        var amount = pending_deposit[_offer.id].amount;
        var userul = pending_deposit[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 3, function(err) {
            if(err) return;

            delete pending_deposit[_offer.id];
            delete user_pending_deposit[userul];
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user eroare', 'One or more items are not anymore in your inventory!');
            if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');
        });
    } else if(pending_withdraw.hasOwnProperty(_offer.id) && _offer.sender.items.length > 0) {
        var amount = pending_withdraw[_offer.id].amount;
        var userul = pending_withdraw[_offer.id].steamid;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 3, function(err) {
            if(err) return;

            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ', withs = withs - 1, available = available + ' + pool.escape(amount) + ', withamount = withamount - ' + pool.escape(amount) + ' WHERE steamid = ' + pool.escape(userul), function(err) {
                if(err) return logger.error('An error updating the balance after declining withdraw on user ' + userul);

                user_balance_check(tokenul, function(aba, hal) {
                    if(aba) {
                        delete pending_withdraw[_offer.id];
                        delete user_pending_withdraw[userul];
                        return;
                    }

                    addLog(users[tokenul].steamid, 'withdraw_offer_no_longer_available', '+' + amount, 'Withdraw offer #' + _offer.id + ' no longer available, and user got coins back!', function() {

                    });

                    users[tokenul].available += parseInt(amount);
                    users[tokenul].balance = hal;

                    delete pending_withdraw[_offer.id];
                    delete user_pending_withdraw[userul];
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user eroare', 'One or more items are not anymore in your inventory and you have received the coins back!');
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user trade done');
                    if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user balance', users[tokenul].balance);
                });
            });
        });
    }  else if(pending_raffle.hasOwnProperty(_offer.id)) {
        var userul = pending_raffle[_offer.id].user;
        var amount = pending_raffle[_offer.id].amount;
        var rafid = pending_raffle[_offer.id].raffle_id;
        var tokenul = tokens[userul];
        var socketul = ssockets[userul];

        editTrade(_offer.id, 3, function(err) {
            if(err) return logger.error('Error occurred while editing trade #' + _offer.id + ' [offerNoLongerValid] - raffle');

            delete pending_raffle[_offer.id];

            pool.query('UPDATE users SET balance = balance + ' + pool.escape(amount) + ' WHERE steamid = ' + pool.escape(userul), function(e, r) {
                if(io.sockets.connected[socketul]) io.sockets.connected[socketul].emit('user alerta', 'Raffle prize no longer valid.<br>You have received balance worth of skin raffle to your account.');

                for(var i in _offer.sender.items) {
                    var itm = _offer.sender.items[i].id;
                    website_inv_raffles.splice(website_inv_raffles.indexOf(itm), 1);
                }

                addLog(users[tokenul].steamid, 'raffle_offer_no_longer_available', '+' + amount, 'Raffle offer #' + _offer.id + ' no longer available, and user got coins!', function() {

                });

                pool.query('UPDATE raffles SET winner_status = 3, winner_statustext = "TRADE_NO_LONGER_VALID" WHERE id = ' + pool.escape(rafid), function(er, ro) {
                });
            });
        });
    }
});
// EXPRESS TRADE POLLING


// GET WEBSITE LEVEL
function checkWebsiteLevel(token, cb) {
    var currentXp = parseInt(users[token].wagered);

    for(var i = 0; i < 500; i++) {
        var xp1 = parseInt(parseInt(i+1)*1000 + parseInt(i+1)*1000);
        var xp2 = parseInt(parseInt(i)*1000 + parseInt(i)*1000);
        var old_xp = parseInt(xp2*parseInt(i) * parseInt(i)*1.5);
        var new_xp = parseInt(xp1*parseInt(i+1) * parseInt(i+1)*1.5);

        if(currentXp >= old_xp && currentXp <= new_xp) {
            cb(parseInt(i), currentXp, new_xp, old_xp);
            break;
        }

        // console.log(old_xp + ' - ' + new_xp);
        // console.log('Level ' + parseInt(i+1) + ' - xp needed: ' + new_xp);
    }
}
// GET WEBSITE LEVEL

// GET DAILY REWARD
function getDailyReward(token) {
    var levelReward = 8;
    var yourReward = 42;
    var yourLevel = users[token].xp_level;

    for(var i = 0; i < yourLevel; i++) {
        yourReward += parseInt(levelReward);
    }

    return parseInt(yourReward);
}
// GET DAILY REWARD


// AVATAR IMAGE CHECKER
function avatarUserChecker(token, cb) {
    var userul = users[token].steamid;

    var link = 'https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=' + config.steam_api_key + '&steamids=' + encodeURI(userul);
    request(link, function(er, r, body) {
        if(r.statusCode == 200) {

            var bodi = JSON.parse(body);
            var avatar = bodi.response.players[0].avatarfull.split('/')[8].split('_')[0];

            if(avatar == config.image_md5_checksum) return cb(true);

            cb(false);

        } else cb(false);
    });
}
// AVATAR IMAGE CHECKER

// USER GAME CHECKER
function gamesUserChecker(token, cb) {
    var userul = users[token].steamid;

    var link = 'https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=' + config.steam_api_key + '&steamid=' + encodeURI(userul);
    request(link, function(er, r, body) {
        if(r.statusCode == 200) {

            var bodi = JSON.parse(body);
            var games = [730, 578080, 570, 440, 433850];

            for(var h in bodi.response.games) {
                var appid = bodi.response.games[h].appid;
                var playtime = bodi.response.games[h].playtime_forever;

                for(var i in games) {
                    var joc = games[i];

                    if(appid == joc && playtime >= 3000) {
                        return cb(true);
                    }
                }
            }

            cb(false);

        } else cb(false);
    });
}
// USER GAME CHECKER


// ADD LOGS
function addLog(steamid, action, amount, log, cb) {
    pool.query('INSERT INTO logs SET steamid = ' + pool.escape(steamid) + ', action = ' + pool.escape(action) + ', amount = ' + pool.escape(amount) + ', log = ' + pool.escape(log) + ', time = ' + pool.escape(time()), function(err, row) {
        if(err) {


            logger.error('ERROR OCCURRED WHILE ADDING LOG!!!! ');
            logger.error('USER ' + steamid + ' - ACTION ' + action + ' - AMOUNT ' + action + ' - LOG ' + log);


            pool.query('UPDATE users SET ban = 1 WHERE steamid = ' + pool.escape(steamid), function(e, r) {
                var socketul = ssockets[steamid];

                if(io.sockets.connected[socketul]) {
                    io.sockets.connected[socketul].emit('user eroare', 'Our System has detected that you are partaking in fraudulent activities on ' + config.site_name + ', if this is an error please contact us!');
                    setTimeout(function() {
                        io.sockets.connected[socketul].emit('user refresh');
                    }, 5000);
                }
            });

            return;
        }

        cb();
    });
}
// ADD LOGS


// CHECK CHAT MESSAGES
function checkChatMessages() {
    var streamers = 0;
    var main = 0;
    var turkish = 0;

    for(var h in chat_msgs) {
        if(chat_msgs[h].lang == 'streamers') streamers++;
        if(chat_msgs[h].lang == 'main') main++;
        if(chat_msgs[h].lang == 'turkish') turkish++;
    }

    if(streamers >= 30) {
        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == 'streamers') {
                chat_msgs.splice(i, 1);
                break;
            }
        }

        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == '') {
                chat_msgs.splice(i, 1);
            }
        }
    }

    if(main >= 30) {
        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == 'main') {
                chat_msgs.splice(i, 1);
                break;
            }
        }

        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == '') {
                chat_msgs.splice(i, 1);
            }
        }
    }

    if(turkish >= 30) {
        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == 'turkish') {
                chat_msgs.splice(i, 1);
                break;
            }
        }

        for(var i in chat_msgs) {
            if (chat_msgs[i].lang == '') {
                chat_msgs.splice(i, 1);
            }
        }
    }
}
// CHECK CHAT MESSAGES

function sendUsersOnline(socket) {
    var Users = [];

    for(var h in Useri_IP) {
        var itm = Useri_IP[h];

        Users.push({
            name: itm.name,
            steamid: itm.steamid,
            avatar: itm.avatar,
            rank: itm.rank
        });
    }

    socket.emit('admin sent users online', Users);
}


function antiSpam(socket, token, callback) {
    if(antispam_user[token]+2 > time()) return socket.emit('user eroare', 'We are currently processing your last request! Please wait.');
    else antispam_user[token] = time();
    callback();
}

function antiSpamEndpoints(socket, token, callback) {
    if(anti_spam_endpoints[token]+60 > time()) return socket.emit('user eroare', 'Please wait 1 minute before checking again for <b>hours played</b>/<b>steam picture</b>.');
    else anti_spam_endpoints[token] = time();
    callback();
}

function check_errors() {
    process.on('uncaughtException', function (err) {
        logger.error('[ERROR]');
        logger.error(err);
    });
}

function database_connection() {
    pool = mysql.createConnection(db_config);
    pool.connect(function(err) {
        if(err) {
            logger.error('[ERROR] Connecting to database "' + err.toString() + '"');
            setTimeout(function() { database_connection(); }, 2500);
        }
        else
        {
            logger.trace('[INFO] Connected to database!');
        }
    });
    pool.on('error', function(err) {
        logger.error('[ERROR] Syntax "' + err.toString() + '"');
        logger.error(err);
        if(err.code == 'PROTOCOL_CONNECTION_LOST') {
            setTimeout(function() { database_connection(); }, 2500);
            logger.trace('[INFO] Trying to reconnect to database...');
        }
        else
        {
            logger.error('[ERROR] Connecting to database ' + err.toString());
        }
    });
}

function makeSecret() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    for(var i=0;i<8;i++) text += possible.charAt(Math.floor(Math.random() * possible.length));
    return text;
}

function makePercentage() {
    return Math.random() * (99.9999999999 - 0.0000000001) + 0.0000000001;
}

function isPositiveNumber(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

function encrypt(key, data) {
    var cipher = crypto.createCipher('aes-256-cbc', key);
    var crypted = cipher.update(data, 'utf-8', 'hex');
    crypted += cipher.final('hex');

    return crypted;
}

function decrypt(key, data) {
    var decipher = crypto.createDecipher('aes-256-cbc', key);
    var decrypted = decipher.update(data, 'hex', 'utf-8');
    decrypted += decipher.final('utf-8');

    return decrypted;
}

function isFloat(value) {
    return !isNaN(value) && value.toString().indexOf('.') != -1
}

function chat_message_escape(text) {
    var map = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#039;'
    };

    return text.replace(/[&<>"']/g, function(m) { return map[m]; });
}

function time() {
    return parseInt(new Date().getTime()/1000);
}

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
};

function tofix(x) {
    if (Math.abs(x) < 1.0) {
      var e = parseInt(x.toString().split('e-')[1]);
      if (e) {
          x *= Math.pow(10,e-1);
          x = '0.' + (new Array(e)).join('0') + x.toString().substring(2);
      }
    } else {
      var e = parseInt(x.toString().split('+')[1]);
      if (e > 20) {
          e -= 20;
          x /= Math.pow(10,e);
          x += (new Array(e+1)).join('0');
      }
    }
    return x;
}