module.exports = {
    bot: function(username, password, sharedSecret, identitySecret) {
        const SteamUser = require('steam-user');
        const TradeOfferManager = require('steam-tradeoffer-manager');
        const SteamTotp = require('steam-totp');
        const SteamCommunity = require('steamcommunity');
        const request = require('request');
        const config = require('./config.js');
        const community = new SteamCommunity({
            request: request.defaults({
                proxy: 'http://23.229.65.92 :3128'
            })
        });
        const client = new SteamUser({
            "promptSteamGuardCode": false
        });
        const manager = new TradeOfferManager({
            pollInterval: 1000,
            cancelTime: 300000,
            community: community,
            steam: client,
            domain: 'example.com',
            language: 'en'
        });
        const logOnOptions = {
            accountName: username,
            password: password,
            twoFactorCode: SteamTotp.generateAuthCode(sharedSecret)
        };
        client.logOn(logOnOptions);
        client.on('loggedOn', function(details) {
            console.log(`Logged into Steam as ${client.steamID.getSteam3RenderedID()}`); //online then play tf2
            client.setPersona(SteamUser.Steam.EPersonaState.Online);
            client.gamesPlayed([config.settings.gameMessage, 440]);
        });
        client.on('webSession', function(sessionID, cookies) {
            manager.setCookies(cookies, function(err) {
                if (err) return console.log(err);
                console.log(`Got API key: ${manager.apiKey}`);
            });
            community.setCookies(cookies);
            community.startConfirmationChecker(4000, identitySecret);
        });

        function keyAmountGood(keyAmount) {
            if (Math.floor(1000 / config.rates.casesForKey) < keyAmount) {
                return false;
            }
        }

        function loadInv(steamID) {
            return new Promise((resolve, reject) => {
                manager.getUserInventoryContents(steamID, 730, 2, true, (err, inv) => {
                    if (err) {
                        console.log(err.message);
                        return reject(err.message)
                    }
                    resolve(inv);
                });
            });
        }

        function makeStorageOffer(steamID, casesPerBot) {
            var offer = manager.createOffer(steamID);
            let casesToAdd = [];
            manager.getUserInventoryContents(steamID, 730, 2, true, (err, thereInv) => {
                if (err) {
                    console.log(err)
                    return
                }
                for (let i = 0; i < thereInv.length; i++) {
                    if (config.settings.acceptedCrates.includes(thereInv[i].market_hash_name) && casesPerBot > casesToAdd.length) {
                        casesToAdd.push(thereInv[i].assetid);
                    }
                }
                for (let i = 0; i < casesToAdd.length; i++) { //add items if all is good.
                    offer.addTheirItem({
                        assetid: casesToAdd[i],
                        appid: 730,
                        contextid: 2,
                        amount: 1
                    });
                }
                offer.send(function(err, status) {
                    if (err) {
                        console.log(err);
                        setTimeout(() => {
                            makeStorageOffer(steamID, casesPerBot);
                            messageAdmin("error getting cases from storage trying again in 2 mins")
                        }, 6000 * 2);
                        return;
                    } else {
                        console.log("sent offer to storage bot");
                        community.checkConfirmations();
                        casesToAdd = [];
                    }
                });
            })
        }

        function checkStock(steamID) {
            return new Promise((resolve, reject) => {
                let cases = 0;
                manager.getUserInventoryContents(steamID, 730, 2, true, (err, inv) => {
                    if (err) {
                        console.log(err.message);
                        return reject(err.message)
                    } else {
                        for (var i = 0; i < inv.length; i++) {
                            if (config.settings.acceptedCrates.includes(inv[i].market_hash_name)) {
                                cases++
                            }
                        }
                    }
                    resolve(cases);
                });
            });
        }
        async function getCases() {
            let botInv = await loadInv(config.account.id64)
            //let required_cases = config.rates.casesForKey - botInv.length;
            let required_cases = config.rates.casesForKey;
            console.log(required_cases)
            for (var i = 0; i < config.storage_accounts.length; i++) {
                if (required_cases > 0) {
                    let cases = await checkStock(config.storage_accounts[i].id64)
                    if (cases > required_cases) {
                        cases = required_cases
                        makeStorageOffer(config.storage_accounts[i].id64, cases)
                        messageAdmin('Sent storage bot ' + i + ' an offer for ' + cases + ' cases')
                        required_cases = required_cases - cases
                    } else {
                        makeStorageOffer(config.storage_accounts[i].id64, cases)
                        messageAdmin('Sent storage bot ' + i + ' an offer for ' + cases + ' cases')
                        required_cases = required_cases - cases
                    }
                }
            }
            return 1;
        }
        async function checkTotalStock() {
            let total = 0;
            for (var i = 0; i < config.storage_accounts.length; i++) {
                let cases = await checkStock(config.storage_accounts[i].id64).catch((err) => {
                    console.log(err);
                    return;
                });
                total += cases;
            }
            return total;
        }

        function checkUser(offer) {
            if (config.settings.trade.acceptEscrow == false) {
                offer.getUserDetails(function(err, me, them) {
                    if (them.escrowDays > 0) {
                        return false;
                    }
                });
            }
        }

        function depositKeys() {
            var offer = manager.createOffer(config.key_account.id64);
            let keys = []
            manager.getUserInventoryContents(config.account.id64, 730, 2, true, (err, botInv) => {
                if (err) {
                    console.log(err);
                    return
                }
                for (var i = 0; i < botInv.length; i++) {
                    if (config.settings.acceptedKeys.includes(botInv[i].market_hash_name)) {
                        keys.push(botInv[i].assetid);
                    }
                }
                for (let i = 0; i < keys.length; i++) {
                    offer.addMyItem({
                        assetid: keys[i],
                        appid: 730,
                        contextid: 2,
                        amount: 1
                    });
                }
                if (offer.itemsToGive.length < 1) {
                    return
                }
                offer.send(function(err, status) {
                    if (err) {
                        console.log(err);
                        messageAdmin("hi we had an offer sending a key deposit trade plz come get them");
                        return;
                    }
                    community.checkConfirmations();
                    keys = [];
                });
            });
        }

        function makeOffer(steamID, neededCases, keyAmount) {
            client.gamesPlayed([config.settings.busyMessage, 440]);
            var offer = manager.createOffer(steamID);
            let ourCases = [];
            let thereKeys = [];
            if (checkUser(offer) == false) {
                client.chatMessage(steamID, "It appears that you are a SCAMMER or have an ESCROW so we can not trade with you");
                client.gamesPlayed([config.settings.gameMessage, 440]);
                return
            }
            client.chatMessage(steamID, "Preparing your offer now :D");
            manager.getUserInventoryContents(steamID, 730, 2, true, (err, thereInv) => {
                if (err) {
                    console.log(err);
                    client.chatMessage(steamID, "Error loading inventory.Please try again later");
                    client.gamesPlayed([config.settings.gameMessage, 440]);
                    return
                }
                manager.getUserInventoryContents(config.account.id64, 730, 2, true, (err, botInv) => {
                    if (err) {
                        console.log(err);
                        client.chatMessage(steamID, "Error loading inventory.Please try again later");
                        client.gamesPlayed([config.settings.gameMessage, 440]);
                        return;
                    }
                    for (let i = 0; i < botInv.length; i++) {
                        if (config.settings.acceptedCrates.includes(botInv[i].market_hash_name) && neededCases > ourCases.length) {
                            ourCases.push(botInv[i].assetid);
                        }
                    }
                    for (var i = 0; i < thereInv.length; i++) {
                        if (config.settings.acceptedKeys.includes(thereInv[i].market_hash_name) && keyAmount > thereKeys.length) {
                            thereKeys.push(thereInv[i].assetid);
                        }
                    }
                    if (ourCases.length < neededCases) {
                        client.chatMessage(steamID, "Something is not right here. Please try again in a few minutes");
                        client.gamesPlayed([config.settings.gameMessage, 440]);
                        return
                    }
                    if (thereKeys.length < keyAmount) {
                        client.chatMessage(steamID, "Sorry! You do not have enough keys, you have " + thereKeys.length);
                        client.gamesPlayed([config.settings.gameMessage, 440]);
                        return;
                    }
                    for (let i = 0; i < thereKeys.length; i++) { //add items if all is good.
                        offer.addTheirItem({
                            assetid: thereKeys[i],
                            appid: 730,
                            contextid: 2,
                            amount: 1
                        });
                    }
                    for (let i = 0; i < ourCases.length; i++) { //add items if all is good.
                        offer.addMyItem({
                            assetid: ourCases[i],
                            appid: 730,
                            contextid: 2,
                            amount: 1
                        });
                    }
                    offer.send(function(err, status) {
                        if (err) {
                            console.log(err);
                            client.chatMessage(steamID, "Hi we had an issue sending your offer. Please try again in a bit");
                            client.gamesPlayed([config.settings.gameMessage, 440]);
                            return;
                        } else {
                            client.chatMessage(steamID, "Sent an offer for your " + keyAmount + " keys and my " + neededCases + " cases. You can accept here : https://steamcommunity.com/tradeoffer/" + offer.id + "/");
                            client.chatMessage(steamID, "Please accept within 5 minutes, otherwise Offer will Auto Decline");
                            console.log("sent offer");
                            community.checkConfirmations();
                            ourCases = [];
                            thereKeys = [];
                        }
                    });
                });
            });
        }

        function messageAdmin(message) {
            for (var i = 0; i < config.settings.admin.length; i++) {
                client.chatMessage(config.settings.admin[i], message);
            }
        }

        function reStock(offer) {
            if (config.key_account.id64 == offer.partner.getSteamID64()) {
                return
            }
            for (var i = 0; i < config.storage_accounts.length; i++) {
                if (config.storage_accounts[i].id64 == offer.partner.getSteamID64()) {
                    return;
                }
            }
            community.getSteamUser(offer.partner, (err, user) => {
                user.comment(config.settings.acceptedTradeComment, (err) => {
                    client.chatMessage(offer.partner, config.settings.acceptTradeChatMessage)
                    client.gamesPlayed([config.settings.restockMessage, 440]);
                    getCases()
                    //depositKeys();
                    //console.log('sent key offer trade')
                    /*setTimeout(() => {
                        getCases().then(a => {});
                        console.log('getting cases from bots')
                    }, 60000);*/
                });
            });
        }
        manager.on("sentOfferChanged", function(offer, oldState) {
            if (offer.state == TradeOfferManager.ETradeOfferState.Declined || offer.state == TradeOfferManager.ETradeOfferState.Canceled) {
                client.gamesPlayed([config.settings.gameMessage, 440]);
            }
            if (offer.state == TradeOfferManager.ETradeOfferState.Accepted) {
                client.gamesPlayed([config.settings.gameMessage, 440]);
                reStock(offer);
            }
            console.log("Offer #" + offer.id + " changed:  " + TradeOfferManager.ETradeOfferState[oldState] + " (" + oldState + ") -> " + TradeOfferManager.ETradeOfferState[offer.state] + " (" + offer.state + ")");
            community.getSteamUser(offer.partner, (err, user) => {
                if (config.settings.notify.acceptedOffers === true && offer.state == TradeOfferManager.ETradeOfferState.Accepted) {
                    messageAdmin('An offer has been accepted by ' + user.name);
                } else if (config.settings.notify.declinedOffers === true && offer.state == TradeOfferManager.ETradeOfferState.Declined) {
                    messageAdmin('An offer has been declined by ' + user.name);
                }
            });
        });
        client.on('friendRelationship', (steamID, relationship) => {
            if (relationship === 2) {
                client.addFriend(steamID);
                client.chatMessage(steamID, config.settings.welcomeMessage);
                client.inviteToGroup(steamID, config.settings.groupID);
            }
        });
        client.on('friendMessage', (steamID, message) => { //freind messgaes
            if (message.startsWith("!buy")) {
                let keyAmount = parseInt(message.split("!buy")[1]);
                let neededCases = keyAmount * config.rates.casesForKey;
                if (keyAmountGood(keyAmount) == false) {
                    client.chatMessage(steamID, "Sorry you are trying to trade to many keys at once. We can only trade " + Math.floor(1000 / config.rates.casesForKey) + " keys at a time!");
                } else {
                    checkStock(config.account.id64).then(mainBotStock => {
                        if (mainBotStock >= neededCases) {
                            makeOffer(steamID, neededCases, keyAmount);
                        } else {
                            client.chatMessage(steamID, "getting cases from stock please try again in 10 mins once we have had a chance to reStock")
                            getCases();
                        }
                    }).catch((err) => {
                        client.chatMessage(steamID, "Sorry! Steam is acting up. Try again in a bit");
                    });
                }
            } else {
                if (message == "!help") {
                    client.chatMessage(steamID, config.settings.helpMessage);
                } else {
                    if (message == "!price") {
                        client.chatMessage(steamID, config.settings.priceMessage);
                    } else {
                        if (message == "!stock") {
                        if (message == "!stock") {
                            client.chatMessage(steamID, "Calculating available stock ... ");
                            checkStock(config.account.id64).then(mainBotStock => {
                                checkTotalStock().then(totalStock => {
                                    let all = mainBotStock + totalStock
                                    client.chatMessage(steamID, "We currently have a total of " + all + " cases we can trade");
                                }).catch((err) => {
                                    client.chatMessage(steamID, "sorry steam is acting up try again in a bit");
                                });
                            }).catch((err) => {
                                client.chatMessage(steamID, "Sorry! Steam is acting up. Try again in a bit");
                            });
                        } else {
                            if (config.settings.admin.includes(steamID.getSteamID64()) && message == "!deposit") {
                                getCases()
                            } else {
                                client.chatMessage(steamID, "Sorry! That command looks incorect. Type !help to see all the commands.")
                            }
                        }
                    }
                }
            }
        });
        manager.on('newOffer', (offer) => {
            if (config.settings.admin.includes(offer.partner.getSteamID64())) {
                offer.accept(function(err, status) {
                    if (err) console.log(`Unable to accept offer: ${err.message}`);
                    community.checkConfirmations();
                });
            } else {
                offer.decline((err) => {
                    if (err) return console.log(`Unable to decline offer: ${err.message}`);
                });
            }
        });
    }
}