var Steam = require('steam');
var SteamWeb = require('steam-webapi')
var fs = require('fs');
var winston = require('winston');
var params = require('./settings');
var sha = require('crypto').createHash('sha1');
var SteamTradeOffers = require('steam-tradeoffers');
var getSteamAPIKey = require('steam-web-api-key');
var SteamWebLogOn = require('steam-weblogon');
var util = require('util');
var request = require('request');
var Long = require('long');

var Bot = {}

SteamWeb.key = params.apiKey;

var myCustomLevels = {
    levels: {
        error: 0,
        success: 1,
        info: 2,
        debug: 3
    },
    colors: {
        error: 'red',
        success: 'green',
        info: 'blue',
        debug: 'yellow'
    }
};

var logger = new(winston.Logger)({
    transports: [
        new(winston.transports.Console)({
            level: 'debug',
            colorize: true
        })
    ],
    levels: myCustomLevels.levels
});

winston.addColors(myCustomLevels.colors);

// Declarations
var serversFile = 'servers';
var sentryFile = 'sentry';
var sentryHash;

// Localization
var messages = {

}

logger.info('Starting bot...');

if (fs.existsSync(sentryFile + '.shasentryfile')) {
    logger.success('Reading sentry hash from sha file...')
    sentryHash = fs.readFileSync(sentryFile + '.shasentryfile');
    params.auth_code = undefined;
} else if (fs.existsSync(sentryFile + '.sentryfile')) {
    logger.success("Found steam sentry file! Converting and using...");
    sha.update(fs.readFileSync(sentryFile + '.sentryfile'));
    sha = new Buffer(sha.digest(), 'binary');
    sentryHash = sha;
    fs.writeFileSync(sentryFile + '.shasentryfile', sentryHash);
    params.auth_code = undefined;
} else if (params.guardCode != '') {
    logger.info('No sentry hash was found. The Steam Guard code will be used instead.')
}

if (fs.existsSync(serversFile)) {
    Steam.servers = JSON.parse(fs.readFileSync(serversFile));
} else {
    logger.warn("No servers file found, using defaults");
}


// Starting to use node-steam from here
var steamClient = new Steam.SteamClient();
var bot = new Steam.SteamUser(steamClient);
var steamFriends = new Steam.SteamFriends(steamClient);
var steamWebLogOn = new SteamWebLogOn(steamClient, bot);
var steamTrade = new SteamTradeOffers();

// Logging in with supplied info
var logOnInfo = {
    account_name: params.username,
    password: params.password,
    auth_code: params.guardCode,
    sha_sentryfile: sentryHash
};

steamClient.connect();
steamClient.on('connected', function() {
    logger.info('Logging in...');
    bot.logOn(logOnInfo);
});

steamClient.on('logOnResponse', function(logonResp) {
    if (logonResp.eresult === Steam.EResult.OK) {
        logger.success("Logged in to Steam");
        steamFriends.setPersonaState(Steam.EPersonaState.Online);
        logger.info("Initializing Steam Trading...");
        steamWebLogOn.webLogOn(function(sessionID, newCookie) {
            getSteamAPIKey({
                sessionID: sessionID,
                webCookie: newCookie
            }, function(err, APIKey) {
                steamTrade.setup({
                    sessionID: sessionID,
                    webCookie: newCookie,
                    APIKey: APIKey
                }, function() {
                    logger.success("Initialized Steam Trading!");
                    logger.info("Checking for new trade offers...");
                    handleTradeOffers();
                });
            });
        });
    } else {
        logger.error(logonResp);
    }
});

bot.on('error', function(error) {
    logger.error("Caught Steam error", error);
});

bot.on('loggedOff', function() {
    logger.error("Logged off from Steam");
    logger.info("Logging back in...");
    bot.logOn(logOnInfo);
});

// Save the sentry hash to a file for later use when we get one
bot.on('updateMachineAuth', function(buffer, callback) {
    logger.info("Sentry event fired - Writing sentry hash to file...");
    fs.writeFile(sentryFile + '.shasentryfile', buffer);
    callback({
        sha_file: getSHA1(sentry.bytes)
    });
});

steamClient.on('servers', function(servers) {
    fs.writeFile(serversFile, JSON.stringify(servers));
});

function sendWinnings() {

}

function fetchInventory(callback) {
    request("http://steamcommunity.com/profiles/" + params.botSteamId + "/inventory/json/730/2",
        function(error, response, body) {
            if (!error && response.statusCode == 200) {
                callback(JSON.parse(body));
            } else {
                logger.error("Failed to fetch bot's inventory.");
                setTimeout(function() {
                    logger.debug("Retrying...");
                    fetchInventory(callback);
                }, 10000);
            }
        })
}

function update() {
    request.post("http://" + params.host + "/php/bot-update.php", {
        form: {
            password: params.serverPassword
        }
    }, function(error, response, body) {
        if (!error && response.statusCode == 200) {
            responseData = JSON.parse(body).data;
            if (responseData.potOver) {
                var itemsToGive = responseData.tradeItems;
                var itemsToKeep = responseData.profitItems;
                var roundId = responseData.roundId;
                var winnerTradeToken = responseData.winnerTradeToken;
                var winnerSteamID = responseData.winnerSteamId;
                logger.debug("Attempting to send to " + winnerTradeToken);
                request('https://steamcommunity.com/id/yungrichnigga/inventory/json/730/2',
                    function(err, response, items) {
                        if (err) {
                            logger.error(err);
                        }
                        rgInventory = JSON.parse(items).rgInventory;
                        itemsFromMe = [];
                        alreadyAddedToWinnerTrade = [];
                        for (var a = 0; a < itemsToGive.length; a++) {
                            itemToGive = itemsToGive[a];
                            var classId = itemToGive.classId;
                            var instanceId = itemToGive.instanceId;
                            var assetId = 0;
                            for (var key in rgInventory) {
                                if (rgInventory.hasOwnProperty(key)) {
                                    inventoryItem = rgInventory[key];
                                    var tAssetId = inventoryItem.id;
                                    var tClassId = inventoryItem.classid;
                                    var tInstanceId = inventoryItem.instanceid;
                                    if (tInstanceId === instanceId && tClassId === classId) {
                                        if (alreadyAddedToWinnerTrade.indexOf(tAssetId) != -1) {
                                            continue;
                                        }
                                        assetId = tAssetId;
                                        break;
                                    }
                                }
                            }
                            if (assetId != 0) {
                                itemsFromMe.push({
                                    "appid": 730,
                                    "contextid": 2,
                                    "amount": 1,
                                    "assetid": assetId
                                });
                                alreadyAddedToWinnerTrade.push(assetId);
                            }
                        }
                        if (itemsFromMe.length > 0) {
                            winnerMessage = "Congratulations, you have won on " + params.siteName + "! Here are your items. Round ID: " + roundId;

                            function toSteamId(accountId) {
                                return new Long(parseInt(accountId, 10), 0x1100001).toString();
                            }
                            sendTradeOffer(winnerSteamID, winnerTradeToken, itemsFromMe, winnerMessage);
                        } else {
                            logger.error("No items to give!");
                        }
                        setTimeout(update, 200);
                    });
            } else {
                setTimeout(update, 200);
            }
        } else {
            logger.error("Could not update bot!");
            logger.debug(error);
        }
    })
}
update();

function sendTradeOffer(steamId, tradeToken, items, msg) {
    steamTrade.makeOffer({
        partnerAccountId: steamId,
        accessToken: tradeToken,
        itemsFromThem: [],
        itemsFromMe: items,
        message: msg
    }, function(err, response) {
        if (err) {
            logger.error("Error! Retrying in 2 seconds...");
            logger.debug(err);
            setTimeout(function() {
                sendTradeOffer(steamId, tradeToken, items, msg);
            }, 2000);
        } else {
            logger.success("Sent Trade Offer!")
        }
    });
}

function handleTradeOffers() {
    steamTrade.getOffers({
        get_received_offers: 1,
        active_only: 1
    }, function(error, body) {
        if (error) {
            setTimeout(handleTradeOffers, 200);
            return;
        }
        if (body.response.trade_offers_received) {
            body.response.trade_offers_received.forEach(function(offer) {
                shouldAccept = true;
                if (offer.trade_offer_state == 2) {
                    logger.info("Steam trade request...");
                    if (offer.items_to_give != undefined && params.admins.indexOf(offer.steamid_other) == -1) {
                        logger.error("Declined trade because user wanted items!");
                        logger.debug("Steam ID: " + offer.steamid_other);
                        shouldAccept = false;
                    }
                    if (offer.items_to_receive) {
                        offer.items_to_receive.forEach(function(item) {
                            if (item.appid !== '730') {
                                logger.error("Declined trade because an item was not for CS:GO!");
                                logger.debug("App ID: " + item.appid);
                                shouldAccept = false;
                            }
                        }, this);
                    }

                    if (offer.items_to_receive && offer.items_to_receive.length > 10) {
                        logger.error("Declined trade because of over 10 items!");
                        logger.debug("# of Items: " + offer.items_to_receive.length);
                    }

                    if (!shouldAccept) {
                        logger.error("Declining... " + offer.tradeofferid)
                        steamTrade.declineOffer({
                            tradeOfferId: offer.tradeofferid
                        });
                        return;
                    }
                    if (params.admins.indexOf(offer.steamid_other) > -1 && offer.items_to_receive == undefined) {
                        steamTrade.acceptOffer({
                            tradeOfferId: offer.tradeofferid
                        });
                        return;
                    }
                    request.post("http://" + params.host + "/php/check-items.php", {
                        form: {
                            items: offer.items_to_receive,
                            password: params.serverPassword,
                            owner: offer.steamid_other
                        }
                    }, function(error, response, body) {
                        if (!error && response.statusCode == 200) {
                            json = JSON.parse(body);

                            if (json.success === 0) {
                                logger.error("Profile is private!");
                                return;
                            }
                            jsonData = json.data;
                            if (jsonData.minDeposit == 1) {
                                logger.success("Offer verified! Accepting...");
                                steamTrade.acceptOffer({
                                    tradeOfferId: offer.tradeofferid
                                }, function() {
                                    request.post("http://" + params.host + "/php/deposit.php", {
                                        form: {
                                            items: jsonData.allItems,
                                            password: params.serverPassword,
                                            owner: offer.steamid_other
                                        }
                                    }, function(error, response, body) {
                                        if (!error && response.statusCode == 200) {
                                            logger.debug("Successfully entered in pot!");
                                        } else {
                                            logger.debug("Error!", error);
                                        }
                                    });
                                });
                            } else {
                                logger.error("Not minimum deposit... " + offer.tradeofferid);
                                steamTrade.declineOffer({
                                    tradeOfferId: offer.tradeofferid
                                });
                            }
                        }
                    });
                }
            });
        }
    });
}

bot.on('tradeOffers', function(number) {
    if (number > 0) {
        handleTradeOffers();
    }
});

Bot.loadItems = function(callback) {}

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

module.exports = Bot;