var fs = require('fs');
var crypto = require('crypto');
var console = process.console;
var config  = require('./config.js');
var getSteamAPIKey = require('steam-web-api-key');
var redisClient, io, requestify;
var requestify = require('requestify');

module.exports.init = function(redis, ioSocket, requestifyCore) {
    io = ioSocket;
    redisClient = redis.createClient();
    requestify = requestifyCore;
}

var hash = require('crypto').createHash('sha1');
hash.update(Math.random().toString());
hash = hash.digest('hex');
var device_id = 'android:' + hash;

function log(log) {console.log('[BOTS] ' + log);}

requestify.post('http://' + config.domain + '/api/getBots')
.then((response) => {
    response = JSON.parse(response.body);
    if(!response.success) {
        log('Не удалось найти бота!');
        return;
    }
    getBots(response.bots);
}, (response) => {
    log(JSON.stringify(response.body));
});

function getBots(bots) {

for(var i = 0; i < bots.length; i++) startBot(bots[i]);

}

function startBot(data) {
function botLog(log) {
	console.tag('ROULETTE', logTime()).log(log);
	}
var logOnOptions     = {
	account_name : data.username,
  	password    : data.password
}

var g_Steamid              = data.steamid64;
var g_Device_ID            = device_id;
var g_Indentity_Secret     = data.identity;
var g_Shared_Secret        = data.shared;

function getSHA1(bytes) {
    var shasum = crypto.createHash('sha1');
    shasum.end(bytes);
    return shasum.read();
}

var Steam = require('steam');
var steam = new Steam.SteamClient();
var SteamTradeOffers = require('steam-tradeoffers');
var offers = new SteamTradeOffers();
var steamUser = new Steam.SteamUser(steam);
var SteamTotp = require('steam-totp');
var steamFriends = new Steam.SteamFriends(steam);
var SteamWebLogOn = require('steam-weblogon');
var steamWebLogOn = new SteamWebLogOn(steam, steamUser);
var SteamConf = require('steamcommunity-mobile-confirmations');
var steamConf;
var confirmTimer;
steam.connect();

function GetEscrowCode(){
	botLog('Код авторизиции : '+SteamTotp.generateAuthCode(data.shared));
	setTimeout(function(){
		GetEscrowCode()
	}, 30000);
}
GetEscrowCode();
logOnOptions['two_factor_code'] = SteamTotp.generateAuthCode(g_Shared_Secret);
steam.on('connected', function() {
	steamUser.logOn(logOnOptions);
	});

steam.on('debug', botLog);

steam.on('logOnResponse', function(result) {
    if (result.eresult === Steam.EResult.OK) {
        botLog('Авторизовались!');
        reWebLogOn(steam);
        steamFriends.setPersonaState(Steam.EPersonaState.Online);
    } else {
		botLog('Ошибка при авторизиции - ' + result.eresult);
	}
});


function logTime() {

    var date = new Date();
    var hour = date.getHours();
    var min  = date.getMinutes();
    var sec  = date.getSeconds();

    var year = date.getFullYear();
    var month = date.getMonth() + 1;
    var day  = date.getDate();

    hour = (hour < 10 ? "0" : "") + hour;
    min = (min < 10 ? "0" : "") + min;
    sec = (sec < 10 ? "0" : "") + sec;
    month = (month < 10 ? "0" : "") + month;
    day = (day < 10 ? "0" : "") + day;

    return hour + ":" + min + ":" + sec;
}


var checkingOffers = [],
    WebSession = false,
    globalSession;

function reWebLogOn(steam, callback) {
	steamWebLogOn.webLogOn(function(webSessionID, newCookie){
		botLog('Подключили cookie! - ' + newCookie);
        steamConf = new SteamConf(
        {
            steamid:         g_Steamid,
            identity_secret: g_Indentity_Secret,
            device_id:       g_Device_ID,
            webCookie:       newCookie,
        });
        getSteamAPIKey({
            sessionID: webSessionID,
            webCookie: newCookie
        }, function(err, APIKey) {
                offers.setup({
                    sessionID: webSessionID,
                    webCookie: newCookie,
                    APIKey: APIKey
                }, function(err){
                    WebSession = true;
                    globalSession = webSessionID;
                    redisClient.lrange(redisChannels.tradeoffersList, 0, -1, function(err, offers){
                        offers.forEach(function(offer) {
                            checkingOffers.push(offer);
                        });
                        handleOffers();
                    });
                    botLog('Настройка Офферов!');
                });
				botLog('Создал сессию! - '+ webSessionID);
        });

	});
}

function confirmTrade(){
	    steamConf.FetchConfirmations((function (err, confirmations) {
        if (err) {
            botLog('Ошибка подтверждения оффера: ' + err);
            return;
        }
        botLog('Трейдов в ожидании:' + confirmations.length);
        if (!confirmations.length) {
            return;
        }
        steamConf.AcceptConfirmation(confirmations[0], (function (err, result) {
            if (err) {
                botLog('Ошибка подтверждения оффера: ' + err);
                return;
            }
            botLog('Result:' + result);
        }).bind(this));
    }).bind(this));



}


const redisChannels = {
    checkItemsList: 'checkItems.list',
    checkList:      'check.list',
    checkedList:    'checked.list',
    betsList:       'bets.list',
    sendOffersList: 'send.offers.list',
    tradeoffersList: 'tradeoffers.list',
    declineList:    'decline.list',
    usersQueue:     'usersQueue.list'
}


steamUser.on('updateMachineAuth', function(sentry, callback) {
    fs.writeFileSync('sentry', sentry.bytes);
    callback({ sha_file: getSHA1(sentry.bytes) });
});


function checkBadGame(){
var mysql = require('mysql');
var connection = mysql.createConnection({
host : 'localhost',
user : 'root',
password : config.passmysql,
database : config.dbmysql
});

connection.connect();

getBadGame ='SELECT won_items, winner_id, items, won_items, g.id as id, steamid64, accessToken FROM `games` as g JOIN users as u ON winner_id = u.id WHERE `not_sended` = 1 AND status = 3 ORDER BY id DESC LIMIT 0,1';
connection.query(getBadGame, function(err, rows, fields) {
rows.forEach(function(item, i, arr) {
botLog('Игра # '+item.id+' игрок #'+ item.winner_id + ' не отправлено '+ item.items +" предметов, пытаюсь отправить сейчас.");
sendoffer = [];
offer = JSON.parse(item.won_items);
offer.forEach(function(it, key, array) {
sendoffer.push(it.classid);
});
sendTradeOffer(730, item.steamid64, item.accessToken, sendoffer, '', item.id, '');
});
});
connection.end();
}
setInterval(function(){checkBadGame();}, 120000);



function handleOffers() {
    offers.getOffers({
        get_received_offers: 1,
        active_only: 1
    }, function(error, body) {
        if (
            body
            && body.response
            && body.response.trade_offers_received
        ) {
            body.response.trade_offers_received.forEach(function(offer) {
                if (offer.trade_offer_state == 2) {
                    if(is_checkingOfferExists(offer.tradeofferid)) return;

                    if(offer.items_to_give != null && config.admins.indexOf(offer.steamid_other) != -1) {
                        botLog('Оффер #' + offer.tradeofferid + ' От: Admin ' + offer.steamid_other);
                        offers.acceptOffer({tradeOfferId: offer.tradeofferid});
						confirmTrade();
                        return;
                    }

          offers.getTradeHoldDuration({tradeOfferId : offer.tradeofferid}, function(err, response)
          {
                botLog(offer.steamid_other);
                botLog(offer.accessToken);

                if (response && response.their != 0)
                {
                  botLog('Hold TradeOfferID: '+offer.tradeofferid+' days: '+response.their);


                  redisClient.multi([
                      ['rpush', redisChannels.declineList, offer.tradeofferid],
                      ['lrem', redisChannels.checkItemsList, 0, offer],
                      ['lrem', redisChannels.checkedList, 0, offer]
                  ])
                  .exec(function (err, replies) {
                  });


                  requestify.post('http://'+config.domain+'/api/haventescrow', {secretKey: config.secretKey , steamid: offer.steamid_other});

                  return;
                 }

            });
                    if(offer.items_to_give != null) {
                        offers.declineOffer({tradeOfferId: offer.tradeofferid});
                        return;
                    }
                    if (offer.items_to_receive != null && offer.items_to_give == null) {
                        checkingOffers.push(offer.tradeofferid);
                        botLog('Оффер #' + offer.tradeofferid + ' От: ' + offer.steamid_other);
                        redisClient.multi([
                            ['rpush', redisChannels.tradeoffersList, offer.tradeofferid],
                            ['rpush', redisChannels.checkItemsList, JSON.stringify(offer)],
                            ['rpush', redisChannels.usersQueue, offer.steamid_other]
                        ]).exec(function(){
                            redisClient.lrange(redisChannels.usersQueue, 0, -1, function(err, queues) {
                                io.sockets.emit('queue', queues);
                            });
                        });
                        return;
                    }
                }
            });
        }
    });
}


steamUser.on('tradeOffers', function(number) {
    if (number > 0) {
        handleOffers();
    }
});


var parseOffer = function(offer, offerJson){
    offers.loadPartnerInventory({partnerSteamId: offer.steamid_other, appId: 730, contextId: 2, tradeOfferId: offer.tradeofferid, language: "russian"}, function(err, hitems) {
        if (err) {
            redisClient.multi([
                ['rpush', redisChannels.declineList, offer.tradeofferid],
                ['lrem', redisChannels.checkItemsList, 0, offerJson],
                ['lrem', redisChannels.usersQueue, 1, offer.steamid_other]
            ])
                .exec(function (err, replies) {
                    parseItemsProcceed = false;
                    return;
                });
            return;
        }
        var items = offer.items_to_receive;
        var items_to_check = [], num = 0;
        for (var i = 0; i < items.length; i++) {
            for (var j = 0; j < hitems.length; j++) {
                if (items[i].assetid == hitems[j].id) {
                    items_to_check[num] = {
                        appid:hitems[j].appid,
                        name:hitems[j].market_name,
                        market_hash_name:hitems[j].market_hash_name,
                        classid:hitems[j].classid
                    };
                    var type = hitems[j].type;
                    var rarity = '';
                    var arr = type.split(',');
                    if (arr.length == 2) type = arr[1].trim();
                    if (arr.length == 3) type = arr[2].trim();
                    if (arr.length && arr[0] == 'Нож') type = '★';
                    switch (type) {
                        case 'Армейское качество':      rarity = 'milspec'; break;
                        case 'Запрещенное':             rarity = 'restricted'; break;
                        case 'Засекреченное':           rarity = 'classified'; break;
                        case 'Тайное':                  rarity = 'covert'; break;
                        case 'Ширпотреб':               rarity = 'common'; break;
                        case 'Промышленное качество':   rarity = 'common'; break;
                        case '★':                       rarity = 'rare'; break;
                    }
                    items_to_check[num].rarity = rarity;
                    num++;
                    break;
                }
            }
        }
        var value = {
            offerid: offer.tradeofferid,
            accountid: offer.steamid_other,
            items: JSON.stringify(items_to_check)
        };

        console.tag('ROULETTE','OFFER:' + value.offerid).log(value);

        redisClient.multi([
            ['rpush', redisChannels.checkList, JSON.stringify(value)],
            ['lrem', redisChannels.checkItemsList, 0, offerJson]
        ])
            .exec(function (err, replies) {
                parseItemsProcceed = false;
            });

    });
}

var checkOfferPrice = function () {
    requestify.get('http://' + config.domain + '/api/checkOffer', {
        secretKey: config.secretKey
    })
        .then(function (response) {
            var answer = JSON.parse(response.body);

            if (answer.success) {
                checkProcceed = false;
            }
        }, function (response) {
            console.tag('SteamBot', logTime()).error('Что-то не так с проверкой офферов.');
            setTimeout(function () {
                checkOfferPrice()
            }, 1000);
        });

}

var checkNewBet = function () {
    requestify.get('http://' + config.domain + '/api/newBet', {
        secretKey: config.secretKey
    })
        .then(function (response) {
            var answer = JSON.parse(response.body);
            if (answer.success) {
                betsProcceed = false;
            }
        }, function (response) {
            console.tag('SteamBot', logTime()).error('Что-то не так с отправлением новой ставки.');
            setTimeout(function () {
                checkNewBet()
            }, 1000);
        });
}

var checkArrGlobal = [];

var sendTradeOffer = function(appId, partnerSteamId, accessToken, sendItems, message, game, offerJson){
    try {
        offers.loadMyInventory({
            appId: appId,
            contextId: 2
        }, function (err, items) {
            if(err) {
                botLog(err);
                sendProcceed = false;
                return;
            }
            var itemsFromMe = [],
                checkArr = [],
                num = 0;
            var i = 0;
            for (var i = 0; i < sendItems.length; i++) {
                for (var j = 0; j < items.length; j++) {
                    if (items[j].tradable && (items[j].classid == sendItems[i])) {
                        if ((checkArr.indexOf(items[j].id) == -1) && (checkArrGlobal.indexOf(items[j].id) == -1)) {
                            checkArr[i] = items[j].id;
                            itemsFromMe[num] = {
                                appid: 730,
                                contextid: 2,
                                amount: items[j].amount,
                                assetid: items[j].id
                            };
                            num++;
                            break;
                        }
                    }
                }
            }
            if (num > 0) {
                offers.makeOffer({
                    partnerSteamId: partnerSteamId,
                    accessToken: accessToken,
                    itemsFromMe: itemsFromMe,
                    itemsFromThem: [],
                    message: 'Поздравляем с победой на сайте '+config.nameSite+' > В игре #' + game
                }, function (err, response) {
                    if (err) {
                        console.tag('SteamBot', 'SendPrize', logTime()).error('Ошибка отправления оффера:' + err.message);
                        getErrorCode(err.message, function(errCode) {
                            if(errCode == 2 || errCode == 3 || errCode == 6 || errCode == 15 || errCode == 16 || errCode == 25 || errCode == 50 || err.message.indexOf('was an error sending your trade offer. Please try again later.')) { // if there is an error in submitting the winning re-send it
                                redisClient.lrem(redisChannels.sendOffersList, 0, offerJson, function (err, data) {
                                    setPrizeStatus(game, 2);
									CheckGameForSend(game, 1);
								   setTimeout(function () {
                                   CheckGameForSend(game, 0);
								   setPrizeStatus(game, 1);
								   console.tag('SteamBot', 'SendPrize', logTime()).log('Прошло 10 минут, останавливем переотправку, и ставим статус раунда - 1.');
                                }, 60000);
                                    sendProcceed = false;
                                });
                                sendProcceed = false;
                            }
                            sendProcceed = false;
                        });
                        return;
                    }
                    checkArrGlobal = checkArrGlobal.concat(checkArr);
                    botLog(checkArrGlobal);
                    botLog(checkArr);
                    redisClient.lrem(redisChannels.sendOffersList, 0, offerJson, function(err, data){
                        setPrizeStatus(game, 1);
						CheckGameForSend(game, 0);
                        sendProcceed = false;
                    });
                    botLog('Оффер #' + response.tradeofferid +' отправлен!');
					confirmTrade();
                });
            }else{
               botLog('Нету предметов!');
                redisClient.lrem(redisChannels.sendOffersList, 0, offerJson, function(err, data){
                    setPrizeStatus(game, 1);
					CheckGameForSend(game, 0);
                    sendProcceed = false;
                });
            }
        });

    }catch(ex){
        console.tag('SteamBot', logTime()).error('Error to send the bet');
        setPrizeStatus(game, 2);
		CheckGameForSend(game, 1);
        sendProcceed = false;
    }
};



var setPrizeStatus = function(game, status){
    requestify.post('http://'+config.domain+'/api/setPrizeStatus', {
        secretKey: config.secretKey,
        game: game,
        status: status
    })
        .then(function(response) {

        },function(response){
            botLog('Что-то не так с установкой prize status.');
            setTimeout(function(){setPrizeStatus()}, 1000);
        });
}

var CheckGameForSend = function(game, status){
    requestify.post('http://'+config.domain+'/api/CheckGameForSend', {
        secretKey: config.secretKey,
        game: game,
        status: status
    })
        .then(function(response) {

        },function(response){
            botLog('Что-то не так с установкой CheckGameForSend.');
            setTimeout(function(){CheckGameForSend()}, 1000);
        });
}

var is_checkingOfferExists = function(tradeofferid){
    for(var i = 0, len = checkingOffers.length; i<len; ++i ){
        var offer = checkingOffers[i];
        if(offer == tradeofferid){
            return true;
            break;
        }
    }
    return false;
}

var checkedOffersProcceed = function(offerJson){
    var offer = JSON.parse(offerJson);
    if (offer.success) {
        botLog('Принимаем: #' + offer.offerid);
        offers.acceptOffer({tradeOfferId: offer.offerid}, function (err, body) {
            if (!err) {
                redisClient.multi([
                    ["lrem", redisChannels.tradeoffersList, 0, offer.offerid],
                    ["lrem", redisChannels.usersQueue, 1, offer.steamid64],
                    ["rpush", redisChannels.betsList, offerJson],
                    ["lrem", redisChannels.checkedList, 0, offerJson]
                ])
                    .exec(function (err, replies) {
                        redisClient.lrange(redisChannels.usersQueue, 0, -1, function(err, queues) {
                            io.sockets.emit('queue', queues);
                            botLog("Новый депозит принят!");
                            checkedProcceed = false;
                        });
                    });

            } else {
               botLog('Ошибка. Не могу принять оффер #' + offer.offerid + ' Log: ' + err)

                offers.getOffer({tradeOfferId: offer.offerid}, function (err, body){
                    if(body && body.response && body.response.offer){
                        var offerCheck = body.response.offer;
                        if(offerCheck.trade_offer_state == 2) {
                            checkedProcceed = false;
                            return;
                        }
                        if(offerCheck.trade_offer_state == 3){
                            redisClient.multi([
                                ["lrem", redisChannels.tradeoffersList, 0, offer.offerid],
                                ["lrem", redisChannels.usersQueue, 1, offer.steamid64],
                                ["rpush", redisChannels.betsList, offerJson],
                                ["lrem", redisChannels.checkedList, 0, offerJson]
                            ])
                                .exec(function (err, replies) {
                                    redisClient.lrange(redisChannels.usersQueue, 0, -1, function(err, queues) {
                                        io.sockets.emit('queue', queues);
                                        checkedProcceed = false;
                                    });
                                });
                        }else{
                            redisClient.multi([
                                ["lrem", redisChannels.tradeoffersList, 0, offer.offerid],
                                ["lrem", redisChannels.usersQueue, 1, offer.steamid64],
                                ["lrem", redisChannels.checkedList, 0, offerJson]
                            ])
                                .exec(function (err, replies) {
                                    redisClient.lrange(redisChannels.usersQueue, 0, -1, function(err, queues) {
                                        io.sockets.emit('queue', queues);
                                        checkedProcceed = false;
                                    });
                                });
                        }
                    }
                })
            }
        });
    }
}

var declineOffersProcceed = function(offerid){
   botLog('Отменяем: #' + offerid);
    offers.declineOffer({tradeOfferId: offerid}, function (err, body) {
        if (!err) {
           botLog('Оффер #' + offerid + ' Отменен!');
            redisClient.lrem(redisChannels.declineList, 0, offerid);
            declineProcceed = false;
        } else {
            botLog('Ошибка. Не могу отменить оффер #' + offer.offerid + ' Log: ' + err)
            declineProcceed = false;
        }
    });
}


var queueProceed = function(){
    redisClient.llen(redisChannels.checkList, function(err, length) {
        if (length > 0 && !checkProcceed && WebSession) {
            console.tag('SteamBot','Queues', logTime()).info('Проверяем Офферы:' + length);
            checkProcceed = true;
            checkOfferPrice();
        }
    });
    redisClient.llen(redisChannels.declineList, function(err, length) {
        if(length > 0 && !declineProcceed && WebSession) {
            console.tag('SteamBot','Queues', logTime()).info('Отклоняем Офферы:' + length);
            declineProcceed = true;
            redisClient.lindex(redisChannels.declineList, 0,function (err, offer) {
                declineOffersProcceed(offer);
            });
        }
    });
    redisClient.llen(redisChannels.checkedList, function(err, length) {
        if(length > 0 && !checkedProcceed && WebSession) {
            console.tag('SteamBot','Queues', logTime()).info('Проверенные Офферы:' + length);
            checkedProcceed = true;
            redisClient.lindex(redisChannels.checkedList, 0,function (err, offer) {
                checkedOffersProcceed(offer);
            });
        }
    });
    redisClient.llen(redisChannels.betsList, function(err, length) {
        if (length > 0 && !betsProcceed && !delayForNewGame) {
            console.tag('SteamBot','Queues', logTime()).info('Ставки:' + length);
            betsProcceed = true;
            checkNewBet();
        }
    });
    redisClient.llen(redisChannels.sendOffersList, function(err, length) {
        if (length > 0 && !sendProcceed && WebSession) {
            console.tag('SteamBot','Queues', logTime()).info('Отправляем победителю оффер:' + length);
            sendProcceed = true;
            redisClient.lindex(redisChannels.sendOffersList, 0,function (err, offerJson) {
                offer = JSON.parse(offerJson);
                sendTradeOffer(offer.appId, offer.steamid, offer.accessToken, offer.items, '', offer.game, offerJson);
		  });
        }
    });
    redisClient.llen(redisChannels.checkItemsList, function(err, length) {
        if (length > 0 && !parseItemsProcceed && WebSession) {
            console.tag('SteamBot','Queues', logTime()).info('Парсим предметы:' + length);
            parseItemsProcceed = true;
            redisClient.lindex(redisChannels.checkItemsList, 0, function (err, offerJson) {
                offer = JSON.parse(offerJson);
                parseOffer(offer, offerJson);
            });
        }
    });
}
var parseItemsProcceed = false;
var checkProcceed = false;
var checkedProcceed = false;
var declineProcceed = false;
var betsProcceed = false;
var sendProcceed = false;
var delayForNewGame = false;
setInterval(queueProceed, 1500);

module.exports.handleOffers = handleOffers;
module.exports.delayForNewGame = function(value){
    delayForNewGame = value;
};

function getErrorCode(err, callback){
    var errCode = 0;
    var match = err.match(/\(([^()]*)\)/);
    if(match != null && match.length == 2) errCode = match[1];
    callback(errCode);
}

}