'use strict';

/** TODO when recieving offer check prices and use prices that we determine,
    also check if their name has "csbot" in it, if so add 2% to all of their rates for items they give me,
    also check why offers from the admin arent being accepted
*/
const SteamApi= require('steam-api');
const SteamUser = require('steam-user');
const SteamCommunity = require('steamcommunity');
const SteamTotp = require('steam-totp');
const Config = require('./botcfg.js'); // for logging in configuration
const fs = require('fs');
const TradeOfferManager = require('steam-tradeoffer-manager');
const SteamlyticsAPI = require("node-steamlytics").API;

const Winston = require('winston'); // for logging
const env = process.env.NODE_ENV || 'development'; // for logging
const logDir = 'log'; // for logging
const community = new SteamCommunity();

// Create the log directory if it does not exist
if (!fs.existsSync(logDir)) {
    fs.mkdirSync(logDir);
}

const tsFormat = () => (new Date()).toLocaleTimeString();
const logger = new (Winston.Logger)({
transports: [
    // colorize the output to the console
    new (Winston.transports.Console)({
        timestamp: tsFormat,
        colorize: true,
        level: 'info'
    }),
new (require('winston-daily-rotate-file'))({
    filename: `${logDir}/-results.log`,
    timestamp: tsFormat,
    datePattern: 'yyyy-MM-dd',
    prepend: true,
    level: env === 'development' ? 'verbose' : 'info'
    })
]
});



// testing logger output
logger.debug('Debugging info');
logger.verbose('Verbose info');
logger.info('Hello world');
logger.warn('Warning message');
logger.error('Error info');

const client = new SteamUser();
var offers = new TradeOfferManager({
    steam:        client,
    community: community,
    domain:       Config.domain,
    language:     "en", // English item descriptions
    pollInterval: 10000, // (Poll every 10 seconds (10,000 ms)
    cancelTime:   300000 // Expire any outgoing trade offers that have been up for 5+ minutes (300,000 ms)
});

var hasList=false;
var list;

var steamlytics = new SteamlyticsAPI(Config.steamlyticsAPIKey, (api, account) => {
    logger.info("Connected to SteamLytics");
    if(!hasList){
        api.csgo.pricelist(function(items){
            logger.info("Got v2 pricelist from steamlytics, used one API call");
            list=items;
            hasList=true;
        });
    }
});




var appid = {
    TF2:   440,
    DOTA2: 570,
    CSGO:  730,
    Steam: 753
};

var timeOffset;
//getting offset for log in
SteamTotp.getTimeOffset(function(error, offset, latentcy){
    timeOffset=offset;
});

client.logOn({
    accountName: Config.username,
    password: Config.password,
    twoFactorCode: SteamTotp.getAuthCode(Config.shared_secret, timeOffset)
});

client.on('loggedOn', () => {
    logger.info('Logged into steam as' +  " " + Config.username);
});

//checking for errors
client.on('error', function (e) {
    // Some error occurred during logon.  ENums found here:
    // https://github.com/SteamRE/SteamKit/blob/SteamKit_1.6.3/Resources/SteamLanguage/eresult.steamd
    logger.error(e);
    process.exit(1);
});

client.on('webSession', function (sessionID, cookies) {
    logger.info("Got web session");
    // Set our status to "Online" (otherwise we always appear offline)
    client.setPersona(SteamUser.Steam.EPersonaState.Online);
    client.gamesPlayed(Config.nonSteamGame); //The gamesPlayed method takes one parameter – a Steam game's appid or a string for a non-Steam game.
    offers.setCookies(cookies);
    community.setCookies(cookies);
    community.startConfirmationChecker(10000, Config.identity_secret);
    manageOffers();
});

//new items recieved
client.on('newItems', function (count) {
    logger.info(count + " new items in our inventory");
});

//checking limitations
client.on('accountLimitations', function (limited, communityBanned, locked, canInviteFriends) {
    if (limited) {
        // More info: https://support.steampowered.com/kb_article.php?ref=3330-IAGK-7663
        logger.warn("Our account is limited. We cannot send friend invites, use the market, open group chat, or access the web API.");
    }
    if (communityBanned){
        // More info: https://support.steampowered.com/kb_article.php?ref=4312-UOJL-0835
        // http://forums.steampowered.com/forums/showpost.php?p=17054612&postcount=3
        logger.warn("Our account is banned from Steam Community");
        // I don't know if this alone means you can't trade or not.
    }
    if (locked){
        // Either self-locked or locked by a Valve employee: http://forums.steampowered.com/forums/showpost.php?p=17054612&postcount=3
        logger.error("Our account is locked. We cannot trade/gift/purchase items, play on VAC servers, or access Steam Community.  Shutting down.");
        process.exit(1);
    }
    if (!canInviteFriends){
        // This could be important if you need to add users.  In our case, they add us or just use a direct tradeoffer link.
        logger.warn("Our account is unable to send friend requests.");
    }
});

// On startup check our friends list
client.on('relationships', function(){
    var friendcount = 0;
    // For every friend we have...
    for (steamID in client.myFriends) {
        friendcount++;
        // If the status is a new friend request...
        if (client.myFriends[steamID] === SteamUser.Steam.EFriendRelationship.RequestRecipient) {
            logger.info("Friend request while offline from: "+steamID);
            // Accept friend requests from when we were offline
            client.addFriend(steamID);
            client.chatMessage(steamID, "Hi thanks for adding me. Send me a trade offer for some cool items");
        }
    }
    logger.info("We have "+friendcount+" friends.");
    if (friendcount > 200) {
        // We might be able to find old friends after using client.friends.requestFriendData([steamids])
        // but seishun will have to add support for it. Right now you can't see how long you've been friends through SteamFriends.
        // This is the only data available using requestFriendData function:
        // https://github.com/SteamRE/SteamKit/blob/master/Resources/Protobufs/steamclient/steammessages_clientserver.proto#L446-L469
        logger.warn("We're approaching the default friends limit.  Maybe we need to purge old friends?");
    }
});

// Friend requests while we're online
client.on('friendRelationship', (steamid, relationship) => {
    if (relationship === 2) {
        client.addFriend(steamid);
        client.chatMessage(steamid, 'Hello there! Thanks for adding me!');
    }
});

// When messaged
client.on('friendMessage', function (senderID, message) {
    logger.info('[' + senderID + '] MSG: ' + message);
    client.chatMessage(senderID, Config.greetMsg);
});

// When we get a new offer...
offers.on('newOffer', function (offer) {
    logger.info("New offer #"+ offer.id +" from "+ offer.partner.getSteam3RenderedID());
    manageOffer(offer);
});


// When an offer sent by someone else changes   s
offers.on('receivedOfferChanged', function (offer, oldState) {
    logger.info(offer.partner.getSteam3RenderedID() +" Offer #" + offer.id + " changed: " + TradeOfferManager.ETradeOfferState[oldState] + " -> " + TradeOfferManager.ETradeOfferState[offer.state]);

    // Alert us when we accept an offer
    if (offer.state == TradeOfferManager.ETradeOfferState.Accepted) {
        logger.info("Offer accepted from" + offer.partner.getSteam3RenderedID())
        offer.getReceivedItems(function (err, items) {
    if (err) {
        logger.error("Couldn't get received items: " + err);
} else {
    var names = items.map(function(item) {
        return item.name;
    });
    // Log a comma-separated list of items received
    logger.info("Received: " + names.join(', '));
    }
        });
    }
});

// When one of our offers changes states
offers.on('sentOfferChanged', function (offer, oldState) {
    // Alert us when one of our offers is accepted
    if (offer.state == TradeOfferManager.ETradeOfferState.Accepted) {
        logger.info("Our sent offer #"+ offer.id + " has been accepted.");
    }
});

// Steam is down or the API is having issues
offers.on('pollFailure', function (err) {
    logger.error("Error polling for trade offers: "+err);
});

// When we receive new trade offer data, save it so we can use it after a crash/quit
offers.on('pollData', function (pollData) {
    fs.writeFile('polldata.json', JSON.stringify(pollData));
});

function manageOffers(){
    logger.info("checking offers...");
    offers.getOffers(1, function (err, sent, recieved) {
        var count=0;
        for (offer in recieved) {
            manageOffer(offer);
            count++;
        }
        if(count===0)
            logger.info("No offers while offline");
    });
}

//check prices
function manageOffer (offer){
    // Accept any trade offer from the bot administrator, or where we're getting free stuff.
    /*if (offer.partner.getSteamID64() === Config.admin || offer.itemsToGive.length === 0) {
        logger.info("User "+ offer.partner.getSteam3RenderedID() +" offered a valid trade.  Trying to accept offer.");
        offer.accept(function (err) {
        if (err) {
            logger.error("Unable to accept offer "+ offer.id +": " + err.message);
        }
        else if(offer.itemsToGive.length != 0) {
            community.acceptConfirmationForObject(Config.identity_secret, offer.id, function(err){
            if (err) {
                logger.error("Unable to accept offer "+ offer.id +": " + err.message);
             }
            else{
                 logger.info("Offer accepted");
            }
            });
        }
        else{
             logger.info("Offer accepted");
        }
    });
}
*/
    //else
    if(compareItems(offer)){
        logger.info("User "+ offer.partner.getSteam3RenderedID() +" offered a valid trade.  Trying to accept offer.");
        offer.accept(function (err) {
        if (err) {
            logger.error("Unable to accept offer "+ offer.id +": " + err.message);
        }
        else if(offer.itemsToGive.length != 0) {
            community.acceptConfirmationForObject(Config.identity_secret, offer.id, function(err){
            if (err) {
                logger.error("Unable to accept offer "+ offer.id +": " + err.message);
             }
            else{
                 logger.info("Offer accepted");
            }
            });
        }
        else{
             logger.info("Offer accepted");
        }
    });
    }
    else { // Otherwise deny it and message the user
         logger.info("User "+ offer.partner.getSteam3RenderedID() +" offered an invalid trade.  Declining offer.");
        offer.decline(function (err) {
            if (err) {
             logger.error("Unable to decline offer "+ offer.id +": " + err.message);
        } else {
            logger.info("Offer declined");
            // Message the user
        client.chatMessage(offer.partner.getSteamID64(), "Please send a trade that follows the rules. Feel free to check my pricing in my profile.");
            }
        });
    }
}

function compareItems(offer){
    var myItems=0;
    var yoItems=0;
    //need to get items "specialty" value and multiply by percent
    for (var item of offer.itemsToGive) {
        var x= item.market_hash_name;
        var price=list[x].safe_price;
        console.log(x);
        console.log(price);
        if(price!=0){
            myItems+=price;
            logger.info("Used v2 pricing");
        }
        else{
           // myItems+=list[x].7_days.average_price;
           steamlytics.csgo.prices(x, function(err, data){
               if(err)
                logger.error(err);
                else{
                    myItems+=data.median_price;
                    logger.info("Used regular price function");
                    console.log(data.median_price);
                }
           });
        }
    }
    for (var item of offer.itemsToGive) {
        var x= item.market_hash_name;
        var price=list[x].safe_price;
        console.log(x);
        console.log(price);
        if(price!=0){
            yoItems+=price;
            logger.info("Used v2 pricing");
        }
        else{
           // myItems+=list[x].7_days.average_price;
           steamlytics.csgo.prices(x, function(err, data){
               if(err)
                logger.error(err);
                else{
                    yoItems+=data.median_price;
                    logger.info("Used regular price function");
                    console.log(data.median_price);
                }
           });
        }
    }

    return myItems < yoItems;
}