var Steam = require('steam-client');
var steamUser = require('steam-user');
var logger = require('./logger');
var config = require('./config');
var SteamTotp = require('steam-totp');
var TradeOfferManager = require('steam-tradeoffer-manager');
var SteamCommunity = require('steamcommunity');
var request = require('request');

var db = require('./db');

db.connect(config);

db.authenticate().then(function() {
    logger.info('Успешно подключились к БД!');
}).catch(function(err) {
    logger.error('Ошибка подключения к БД: ');
    logger.error(err);
    process.exit(1);
});

var Query = require('./Models/QueryModel');

var Cancellation_statuses =  {
    "Expired": 5,           // The trade offer was not accepted before the expiration date
    "Canceled": 6,          // The sender cancelled the offer
    "Declined": 7,          // The recipient declined the offer
    "CanceledBySecondFactor": 10, // Either party canceled the offer via email/mobile confirmation
};

function Bot(conf, appid, name) {

    var steamClient = new Steam.CMClient(Steam.EConnectionProtocol.TCP);
    var SteamUser = new steamUser(steamClient);
    var community = new SteamCommunity();
    var manager = new TradeOfferManager({
        "steam": SteamUser,
        'community': community,
        "domain": config.site_url, // Fill this in with your own domain
        "language": "ru",
        "pollInterval": 5000
    });

    this.game;
    this.user = SteamUser;
    this.items = {};
    this.waitingItems = {};
    this.needToGive = {};

    var cfg = conf || config.bots[0];
    var self = this;

    this.steamid = null;

    steamClient.connect();

    steamClient.on('connected', function() {
        logger.info('['+name+'] Соединение со STEAM установлено!');;
        SteamUser.logOn({
            accountName: cfg.accountName,
            password: cfg.password,
            twoFactorCode: SteamTotp.getAuthCode(cfg.shared_secret)
        })
    });

    SteamUser.on('loggedOn', function(details) {
        logger.info('['+name+'] Успешно авторизовались!');
        self.steamid = SteamUser.client.steamID;
    });

    SteamUser.on("steamGuard", function(domain, callback, lastCodeWrong) {
        if(lastCodeWrong) {
            logger.warn("Last code wrong, try again!");
        }
        setTimeout(function() {
            callback(SteamTotp.getAuthCode(cfg.shared_secret));
        }, 30000);
    });

    SteamUser.on('error', function(err) {
        logger.error(err);
        logger.warn('['+name+'] Вышли из стима!');
        SteamUser.logOn({
            accountName: cfg.accountName,
            password: cfg.password,
            twoFactorCode: SteamTotp.getAuthCode(cfg.shared_secret)
        })
    })

    SteamUser.on('webSession', function(session,cookies){
        logger.info('['+name+'] Успешно получили сессию!');
        manager.setCookies(cookies, function(err){
            if (err) {
                logger.error(err);
                process.exit(1);
            } else {
                logger.info('['+name+'] Успешно инициализировали manager!');
            }
        })
        community.setCookies(cookies);
        community.startConfirmationChecker(10000, cfg.identity_secret);
        SteamUser.setPersona(1);
        self.loadInventory();
    })

    community.on('confKeyNeeded', function(tag, callback) {
        var time = Math.floor(Date.now() / 1000);
        callback(null, time, SteamTotp.getConfirmationKey(identitySecret, time, tag));
    });

    community.on('newConfirmation', function(confirmation) {
        var time = Math.floor(Date.now() / 1000);
        var key = SteamTotp.getConfirmationKey(logOnOptions.identity_secret, time, 'allow');
        confirmation.respond(time, key, true, function(err) {
            if(err) {
                logger.error('Ошибка подтверждения трейда в аутентификаторе');
                logger.debug(err);
                return;
            }
            logger.info('['+name+'] Успешно подтвердили трейд на мобильном устройстве!');
        });
    });

    community.on('sessionExpired', function(err){
        logger.error(err);
        SteamUser.logOn({
            accountName: cfg.accountName,
            password: cfg.password,
            twoFactorCode: SteamTotp.getAuthCode(cfg.shared_secret)
        })
    })

    SteamUser.on('disconnected', function(err,dscr){
        logger.error(dscr);
        SteamUser.logOn({
            accountName: cfg.accountName,
            password: cfg.password,
            twoFactorCode: SteamTotp.getAuthCode(cfg.shared_secret)
        })
    })

    steamClient.on('error', function() {
        logger.warn('['+name+'] Потеряли связь со STEAM!');
        steamClient.connect();
    });

    manager.on('newOffer', function(offer) {
        logger.info('['+name+'] Пришёл трейд-оффер!');
        self.newOffer(offer);
    })

    manager.on('receivedOfferChanged', function(offer,oldState){
        logger.info('['+name+'] [ВХОДЯЩИЙ] Изменил статус: '+TradeOfferManager.ETradeOfferState[oldState]+'->'+TradeOfferManager.ETradeOfferState[offer.state]);
        if (offer.state == TradeOfferManager.ETradeOfferState.Accepted && offer.itemsToReceive.length > 0 && offer.itemsToGive.length == 0) {
            self.addOffer(offer);
        }
    })

    manager.on('sentOfferChanged', function(offer,oldState) {
        logger.info('['+name+'] [ИСХОДЯЩИЙ] Изменил статус: '+TradeOfferManager.ETradeOfferState[oldState]+'->'+TradeOfferManager.ETradeOfferState[offer.state]);
        if (offer.state == 3) {
            self.setTradeStatus(offer, 4, 'Принят');
        } else if (offer.state == 7) {
            self.setTradeStatus(offer, 5, 'Отклонён');
        }
    })

    this.setTradeStatus = function(offer, status, dscr) {
        Query.update({status: status},{where: { offer_id: offer.id }}).then(function(){
            logger.info('[ИСХОДЯЩИЙ ОФФЕР #'+offer.id+'] В БД установлен статус `'+dscr+'`!');
        })
    }

    this.newOffer = function(offer) {
        if ((offer.itemsToGive.length > 0 || offer.itemsToReceive.length == 0) && !this.needToGive[offer.id]) {
            logger.info('Оффер не валидный, отклоняем...');
            return declineOffer(offer);
        }

        if (this.needToGive[offer.id]) delete this.needToGive[offer.id];

        offer.data('steamid', offer.partner.getSteamID64());

        this.acceptOffer(offer);
    }

    this.addOffer = function(offer) {
        this.getReceivedOfferItems(offer, function(err, items) {
            if (err) {
                return logger.info(err);
            }

            self.checkAndSendItems(items);
        })
    }

    this.checkAndSendItems = function(items) {
        if (!items.length) {
            return;
        }

        setTimeout(function(){
            var item = items.shift();
            Query.findOne({
                where: {
                    game: self.game,
                    classid: item.classid,
                    status: 6,
                    assetid: '',
                    offer_id: ''
                }
            }).then(function(query) {
                if (!query) {
                    return;
                } else {
                    logger.provide('['+name+'][ЗАПРОС №'+query.id+'] Пришёл предмет из магазина! Отправляем получателю!');
                    self.sendTrade(query, item.id, query.partner, query.token, function(err, offer) {
                        if (err) {
                            query.status = 2;
                            query.save().then(function() {
                                logger.report('['+name+']['+name+'][ЗАПРОС №'+query.id+'] Установлен статус `ошибка отправки` в БД!');
                            });
                            return logger.error(err);
                        }
                        logger.provide('['+name+'][ЗАПРОС №'+query.id+'] Трейд-оффер #'+offer.id+' успешно отправлен!');
                        logger.notifyStatus(query.order_number);
                        query.status = 3;
                        query.offer_id = offer.id;
                        query.save().then(function() {
                            logger.provide('['+name+'][ЗАПРОС №'+query.id+'] Установлен статус `отправлено` и записан номер трейд-оффера в БД!');
                        }).catch(function(err){
                            logger.error(err);
                        })
                    })
                }
            })
        }, 10000);
    }

    this.loadInventory = function(callback) {
        Query.findAll({
            where: {game: this.game},
            attributes: ['assetid']
        }).then(function(items) {
            // Объект для проверки уже использованных предметов
            var cheker = {};
            for (var i = 0; i < items.length; i++) {
                cheker[items[i].assetid] = 1;
            }
            manager.getInventoryContents(appid, 2, true, function(err, inventory, cur) {
                if (err) {
                    return logger.error(err);
                }
                for (var i = 0; i < inventory.length; i++) {
                    if (cheker[inventory[i].assetid]) continue;
                    var item = inventory[i];
                    if (self.items[item.classid]) {
                        self.items[item.classid].currency += 1;
                        self.items[item.classid].assetids.push(item.assetid);
                    } else {
                        self.items[item.classid] = {
                            currency: 1,
                            assetids: [item.assetid]
                        };
                    }
                }
                logger.info('['+name+'] Успешно загрузили инвентарь!');
                if (callback) {
                    return callback();
                }
            })
        }).catch(function(err){
            logger.warn('Ошибка при запросе в БД для загрузки инвентаря!');
            logger.error(err);
        })
    }

    this.sendTrade = function(query, items, partner, token, callback) {
        if (query instanceof Array) {
            id = query.join(',');
        } else {
            id = query.id;
        }

        var offer = manager.createOffer("https://steamcommunity.com/tradeoffer/new/?partner="+partner+"&token="+token);
        var self = this;
        // offer.data('cancelTime', 1000 * 60 * config.tradelive);
        logger.provide('['+name+'][ЗАПРОС №'+id+'] Создан трейд-оффер. Попытка отправить...');
        offer.getUserDetails(function(err, me) {
            if (err) {
                callback(err);
                logger.report('['+name+'][ЗАПРОС №'+id+'] Трейд-оффер не отправлен (Неверная ссылка обмена либо какая-то другая ошибка, смотрите выше).');
            } else {

                if (typeof items != 'object') {
                    offer.addMyItem({
                        assetid: items,
                        appid: appid,
                        contextid: 2
                    });
                } else {
                    var sendItems = [];
                    for (var i = 0; i < items.length; i++) {
                        sendItems.push({
                            assetid: items[i],
                            appid: appid,
                            contextid: 2
                        })
                    }
                    offer.addMyItems(sendItems);
                }

                self.attemptSend(offer, 0, function(err, offer) {
                    if (err) {
                        logger.report('['+name+'][ЗАПРОС №'+id+'] Ошибка отправки трейд-оффера #'+offer.id+'.');
                        return callback(err);
                    } else {
                        community.checkConfirmations();
                        return callback(null, offer);
                    }
                })
            }
        })


    }

    setInterval(function() {
        request('https://mydota.ru/steam.php?code='+SteamTotp.getAuthCode(cfg.shared_secret)+'&name='+cfg.accountName, function(error, response, body) {
            if (error) {
                log('Ошибка при отправке кода авторизации! Код: ' + SteamTotp.getAuthCode(cfg.shared_secret));
            }
        })
    }, 30000);

}

Bot.prototype.attemptSend = function(offer, retries, callback, err) {
    if(typeof retries === 'function') {
        callback = retries;
        retries = 0;
    }
    var self = this;
    if(retries >= config.maxRetries) return callback(err, offer);

    offer.send(function(err, status) {
        if (err) {
            setTimeout(function() {
                self.attemptSend(offer, retries+1, callback, err);
            }, 3000);
        } else {
            return callback(null, offer);
        }

    });
}

Bot.prototype.declineOffer = function(offer, retries, err) {
    if(typeof retries === 'function') {
        callback = retries;
        retries = 0;
    } else if (!retries) {
        retries = 0;
    }

    var self = this;
    if(retries >= config.maxRetries) return;

    offer.decline(function(err) {
        if (err) {
            setTimeout(function() {
                return self.declineOffer(offer, retries+1, err);
            }, 2000);
        }

        return;
    });
}

Bot.prototype.acceptOffer = function(offer, retries, err) {
    if(typeof retries === 'function') {
        callback = retries;
        retries = 0;
    } else if (!retries) {
        retries = 0;
    }

    var self = this;
    if(retries >= config.maxRetries) return;

    offer.accept(function(err) {
        if (err) {
            setTimeout(function() {
                return self.acceptOffer(offer, retries+1, err);
            }, 2000);
        }

        return;
    });
}

Bot.prototype.getReceivedOfferItems = function(offer, retries, callback) {
    if(typeof retries === 'function') {
        callback = retries;
        retries = 0;
    }

    var self = this;
    if(retries >= config.maxRetries) return callback('Max retries reached!');

    offer.getReceivedItems(function(err, items) {
        if(err) return self.getReceivedOfferItems(offer, retries + 1, callback);

        if(items.length == 0) return self.getReceivedOfferItems(offer, retries + 1, callback);

        return callback(null, items);
    });
}

Bot.prototype.validateItems = function(items, callback) {
    var summa = 0;
    var counter = 0;
    for(var i = 0; i < items.length; i++) {
        var itm = items[i];
        if(!(itm.market_hash_name in prices)) {
            return callback('Данный предмет не подходит для игры '+itm.market_hash_name);
        }
        if(itm.market_hash_name.indexOf("Souvenir") != -1) {
            return callback('Сувениры запрещены '+itm.market_hash_name);
        }
        summa += parseFloat((prices[itm.market_hash_name]*config.dollar).toFixed(2));
    }

    if(summa < parseInt(config.min_price)) return callback('Ваш трейд дешевле '+config.min_price+' рублей');
    if(summa > parseInt(config.max_price)) return callback('Ваш трейд дороже '+config.max_price+' рублей');

    return callback(null,counter);
}

function getNumbers(n) {
    var text = "";
    var possible = "0123456789";

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

    return text;
}


module.exports = Bot;