var steam = require("steam"),
  util = require("util"),
  fs = require("fs"),
  SteamApi = require('steam-api'),
  SteamID = require('steamid'),
  crypto = require("crypto"),
  dota2 = require("dota2"),
  steamClient = new steam.SteamClient(),
  steamUser = new steam.SteamUser(steamClient),
  steamFriends = new steam.SteamFriends(steamClient),
  Dota2 = new dota2.Dota2Client(steamClient, true);

var request = require("request");
var moment = require("moment");

global.config = require("./config/config");

function newBlankPlayer() {
  return {
    name: undefined,
    steam_id: undefined,
    status: 0,
  };
}


global.userList = {};

function getUserList() {
  var url = "http://miragefarm.tk/json.php";

  request({
    url: url,
    json: true
  }, function(error, response, body) {

    if (!error && response.statusCode === 200) {
      global.userList = body;
    }
  })
}

function timeRemaining(date) {
  var currDate = moment(new Date()).format("YYYY-MM-DD");
  var banDate = moment(new Date(date * 1000)).format("YYYY-MM-DD");

  var remainingTime = moment(banDate).diff(currDate, 'hours');

  return remainingTime;
}

/*global.userList = {
  "57312074": {
    "alias": "HAWGT",
    "bannedUntil": 0,
    "verifiedHost": true,
    "admin": true,
    "botowner": true,
  },
  "154189930": {
    "alias": "SP",
    "bannedUntil": 0,
    "verifiedHost": true,
    "admin": true,
    "botowner": false,
  },
};*/

var onSteamLogOn = function onSteamLogOn(logonResp) {
    if (logonResp.eresult == steam.EResult.OK) {
      steamFriends.setPersonaState(steam.EPersonaState.Offline);
      steamFriends.setPersonaName(global.config.steam_name);
      util.log("Logged on.");

      Dota2.launch();
      Dota2.on("ready", function() {
        util.log("Node-dota2 ready.");

        // CHAT

        global.chatChannel = "miragefarm";

        Dota2.joinChat(chatChannel);
        setTimeout(function() {
          //Dota2.sendMessage("I'm just a bot.", chatChannel);
        }, 1000);



      });

      Dota2.on("lobbyInviteUpdate", function(lobby) {
        util.log(lobby);

        var players = [];
        var hostId = lobby.sender_id.low;

        getUserList();

        for (var i = 0, len = lobby.members.length; i < len; i++) {
          players[i] = newBlankPlayer();
          players[i].name = lobby.members[i].name;
          players[i].steam_id = lobby.members[i].steam_id.low;

          var currDate = new Date();
          if (userList[players[i].steam_id]) {
            var banDate = new Date(userList[players[i].steam_id].bannedUntil * 1000);
          } else {
            var banDate = new Date(0);
          }
          if (userList[players[i].steam_id]) {
            players[i].status = 1;
            if (userList[players[i].steam_id].verifiedHost == true && currDate > banDate) {
              players[i].status = 2;
            } else if (currDate < banDate) {
              players[i].status = -1;
            }
          }

        }

        if (userList[hostId].verifiedHost == true && currDate > banDate) {

          Dota2.respondLobbyInvite(lobby.group_id, true);

          var lobbyName = "Lobby_" + lobby.group_id;

          Dota2.joinChat(lobbyName, 3);
          setTimeout(function() {

            for (var i = 0, len = players.length; i < len; i++) {

              if (players[i].status == 0) {

                Dota2.sendMessage(players[i].name + " isn't verified!" + " FID: " + players[i].steam_id, lobbyName, 3);
              } else if (players[i].status == -1) {
                var date = new Date(userList[players[i].steam_id].bannedUntil * 1000);
                Dota2.sendMessage(players[i].name + " is verified and banned! (For " + timeRemaining(date) + ")" + " FID: " + players[i].steam_id, lobbyName, 3);
              } else if (players[i].status == 1) {

                //Dota2.sendMessage(players[i].name + " is verified!" + " FID: " + players[i].steam_id, lobbyName, 3);
              } else if (players[i].status == 2) {

                //Dota2.sendMessage(players[i].name + " is a verified host!" + " FID: " + players[i].steam_id, lobbyName, 3);
              }

            }

            Dota2.leaveChat(lobbyName, 3);
            Dota2.leavePracticeLobby();

          }, 1000);
        } else {
          Dota2.respondLobbyInvite(lobby.group_id, false);
          //DEBUG
          util.log(userList[hostId].verifiedHost + "," + currDate.getTime() / 1000 + "," + banDate.getTime() / 1000);
        }
      });



      Dota2.on("unready", function onUnready() {
        util.log("Node-dota2 unready.");
      });

      Dota2.on("chatMessage", function(channel, personaName, message, raw) {
        util.log("[" + channel + "] " + personaName + ": " + message);
        util.log(raw);

        if (message == "!check") {
          getUserList();
          var id = raw.account_id;
          var currDate = new Date();
          var status = 0;
          if (userList[id]) {
            var banDate = new Date(userList[id].bannedUntil * 1000);
          } else {
            var banDate = new Date(0);
          }

          if (userList[id]) {
            status = 1;
            if (userList[id].verifiedHost == true && currDate > banDate) {
              status = 2;
            } else if (currDate < banDate) {
              status = -1;
            }
          }

          if (status == 0) {

            Dota2.sendMessage("You aren't verified!", chatChannel);
          } else if (status == -1) {
            var date = new Date(userList[players[i].steam_id].bannedUntil * 1000);
            Dota2.sendMessage("You are verified and banned! (For " + timeRemaining(date) + ")", chatChannel);
          } else if (status == 1) {

            Dota2.sendMessage("You are verified!", chatChannel);
          } else if (status == 2) {

            Dota2.sendMessage("You are a verified host!", chatChannel);
          }


        }
        if (message.length > 6) {
          if (message.substring(0, 6) == "!check") {
            var cmd = message.split(' ');
            if (cmd.length == 2) {
              getUserList();
              var id = cmd[1];
              var currDate = new Date();
              var status = 0;
              if (userList[id]) {
                var banDate = new Date(userList[id].bannedUntil * 1000);
              } else {
                var banDate = new Date(0);
              }

              if (userList[id]) {
                status = 1;
                if (userList[id].verifiedHost == true && currDate > banDate) {
                  status = 2;
                } else if (currDate < banDate) {
                  status = -1;
                }
              }

              if (status == 0) {

                Dota2.sendMessage("That player isn't verified!", chatChannel);
              } else if (status == -1) {
                var date = new Date(userList[players[i].steam_id].bannedUntil * 1000);
                Dota2.sendMessage("That player is verified and banned! (For " + timeRemaining(date) + ")", chatChannel);
              } else if (status == 1) {

                Dota2.sendMessage("That player is verified!", chatChannel);
              } else if (status == 2) {

                Dota2.sendMessage("That player a verified host!", chatChannel);
              }

            }
          }
        }

      });

      Dota2.on("unhandled", function(kMsg) {
        util.log("UNHANDLED MESSAGE " + dota2._getMessageName(kMsg));
      });
    }
  },
  onSteamServers = function onSteamServers(servers) {
    util.log("Received servers.");
    fs.writeFile('servers', JSON.stringify(servers), (err) => {
      if (err) {
        if (this.debug) util.log("Error writing ");
      } else {
        if (this.debug) util.log("");
      }
    });
  },
  onSteamLogOff = function onSteamLogOff(eresult) {
    util.log("Logged off from Steam.");
  },
  onSteamError = function onSteamError(error) {
    util.log("Connection closed by server.");
  };

steamUser.on('updateMachineAuth', function(sentry, callback) {
  var hashedSentry = crypto.createHash('sha1').update(sentry.bytes).digest();
  fs.writeFileSync('sentry', hashedSentry)
  util.log("sentryfile saved");

  callback({
    sha_file: hashedSentry
  });
});

var logOnDetails = {
  "account_name": global.config.steam_user,
  "password": global.config.steam_pass,
};
if (global.config.steam_guard_code) logOnDetails.auth_code = global.config.steam_guard_code;
if (global.config.two_factor_code) logOnDetails.two_factor_code = global.config.two_factor_code;

try {
  var sentry = fs.readFileSync('sentry');
  if (sentry.length) logOnDetails.sha_sentryfile = sentry;
} catch (beef) {
  util.log("Cannot load the sentry. " + beef);
}

steamClient.connect();

steamClient.on('connected', function() {
  steamUser.logOn(logOnDetails);
});

steamClient.on('logOnResponse', onSteamLogOn);
steamClient.on('loggedOff', onSteamLogOff);
steamClient.on('error', onSteamError);
steamClient.on('servers', onSteamServers);