//-------------- Time Token --------------//

// kita panggil nilai yang berubah per waktu sebagai time token. yes.
// kenapa ini dibuat? Karena countdown playfab sucks.

// -------- yang ini nanti tertulis di title data user pas manggil useTimeToken.
var TT_PREFIX = "TT_";

// // isi dari token
// var TIMETOKEN_VALUE_PREFIX = "TTValue_";
// // terakhir kali si token dipakai
// var TIMETOKEN_TIME_PREFIX = "TTTime_";
// // terakhir kali si token nge-regenerate
// var TIMETOKEN_LASTREGEN_PREFIX = "TTLastRegen_";


// ------- yang ini mah tulis manual di title data, bukan di user, tapi di app.
// banyaknya waktu (dalam detik) yang diperlukan untuk merecharge
var TIMETOKEN_RECHARGETIME_PREFIX = "TTRechargeTime_";
// nilai maksimum dimiliki token
var TIMETOKEN_MAXVALUE_PREFIX = "TTMax_";


var TIMETOKEN_ERR_NOKEY = "NO_KEY";

var TIMETOKEN_KEY_TIME = "Time";  //for current time
var TIMETOKEN_KEY_LASTREGEN = "LastRegen";

var TIMETOKEN_KEY_CURRENTVALUE = "CurrentValue";
var TIMETOKEN_KEY_RECHARGETIME = "RechargeTime";
var TIMETOKEN_KEY_RECHARGEMAX  = "RechargeMax";
var TIMETOKEN_KEY_SECONDSTORECHARGE = "SecondsToRecharge";
var TIMETOKEN_KEY_ERROR = "Error";

function createToken(timeTokenId, value)
{
  log.info("create token:" + timeTokenId + " by " + value);
  var dataKey = TT_PREFIX + timeTokenId;
  // var timeTokenValue = TIMETOKEN_VALUE_PREFIX + timeTokenId;
  // var timeTokenTime = TIMETOKEN_TIME_PREFIX + timeTokenId;
  // var timeTokenLastRegen = TIMETOKEN_LASTREGEN_PREFIX + timeTokenId;

  var currentTime = new Date();

  var writeToServer = { };

  var data = {};
  data[TIMETOKEN_KEY_CURRENTVALUE] = value;
  data[TIMETOKEN_KEY_TIME] = currentTime;
  data[TIMETOKEN_KEY_LASTREGEN] = currentTime;

  writeToServer[dataKey] = JSON.stringify(data);

  // writeToServer[timeTokenValue] = value;
  // writeToServer[timeTokenTime] = currentTime;
  // writeToServer[timeTokenLastRegen] = currentTime;

  // server.UpdateUserReadOnlyData({"PlayFabId" : currentPlayerId, "Data" : writeToServer, "Permission":"Private"});
  server.UpdateUserReadOnlyData({"PlayFabId" : currentPlayerId, "Data" : writeToServer, "Permission":"Private"});
}

// Kalau mau pakai time token gunakan fungsi ini
function addTimeTokenValue(timeTokenId, value)
{
  var dataKey = TT_PREFIX + timeTokenId;

  // var timeTokenValue = TIMETOKEN_VALUE_PREFIX + timeTokenId;
  // var timeTokenTime = TIMETOKEN_TIME_PREFIX + timeTokenId;
  // var timeTokenLastRegen = TIMETOKEN_LASTREGEN_PREFIX + timeTokenId;

  var data = {};

  var returnValue = {};
  var timeTokenInfo = getTimeTokenInfo(timeTokenId);

  if (timeTokenInfo[TIMETOKEN_KEY_ERROR] == null){

    var prevValue = parseInt(timeTokenInfo[TIMETOKEN_KEY_CURRENTVALUE]);

    var totalValue = prevValue + parseInt(value);
    // jangan melebihi nilai max
    if (totalValue > timeTokenInfo[TIMETOKEN_KEY_RECHARGEMAX]) {
      totalValue = timeTokenInfo[TIMETOKEN_KEY_RECHARGEMAX];
    }


    var currentTime = new Date();
    var writeToServer = {};

    // kalau yang sebelumnya udah max, anggap regennya baru diambil sekarang
    // supaya nggak langsung diregenerate
    // misal: mainnya kemarin, padahal udah max, dan baru mainnya sekarang
    // jadi pas main kedua gak ngambil last regenerate hari kemarin, tapi dari terakhir kali dipakai
    // (jadi baru countdown regenerate pas ada nilai yang perlu diregenerate)
    if (prevValue >= timeTokenInfo[TIMETOKEN_KEY_RECHARGEMAX] ) {
      // writeToServer[timeTokenLastRegen] = new Date();
      data[TIMETOKEN_KEY_LASTREGEN] = new Date();
    }else{
      data[TIMETOKEN_KEY_LASTREGEN] = timeTokenInfo[TIMETOKEN_KEY_LASTREGEN];
    }

    // writeToServer[timeTokenValue] = totalValue;
    // writeToServer[timeTokenTime] = currentTime;
    data[TIMETOKEN_KEY_CURRENTVALUE] = totalValue;
    data[TIMETOKEN_KEY_TIME] = currentTime;

    writeToServer[dataKey] = JSON.stringify(data);
    server.UpdateUserReadOnlyData({"PlayFabId" : currentPlayerId, "Data" : writeToServer, "Permission":"Private"});

    var addedTimeTokenInfo = getTimeTokenInfo(timeTokenId);
    returnValue[TIMETOKEN_KEY_CURRENTVALUE] = addedTimeTokenInfo[TIMETOKEN_KEY_CURRENTVALUE];
    returnValue[TIMETOKEN_KEY_RECHARGETIME] = addedTimeTokenInfo[TIMETOKEN_KEY_RECHARGETIME];
    returnValue[TIMETOKEN_KEY_RECHARGEMAX]  = addedTimeTokenInfo[TIMETOKEN_KEY_RECHARGEMAX];
    returnValue[TIMETOKEN_KEY_SECONDSTORECHARGE]  = addedTimeTokenInfo[TIMETOKEN_KEY_SECONDSTORECHARGE];
    returnValue[TIMETOKEN_KEY_ERROR] = addedTimeTokenInfo[TIMETOKEN_KEY_ERROR];
  }else{
    returnValue[TIMETOKEN_KEY_CURRENTVALUE] = null;
    returnValue[TIMETOKEN_KEY_RECHARGETIME] = null;
    returnValue[TIMETOKEN_KEY_RECHARGEMAX]  = null;
    returnValue[TIMETOKEN_KEY_SECONDSTORECHARGE] = null;
    returnValue[TIMETOKEN_KEY_ERROR] = TIMETOKEN_ERR_NOKEY;
  }
  return returnValue;
}

function setRegenToken(timeTokenId, currentValue, lastRegen, lastUsedTime) {
  var dataKey = TT_PREFIX + timeTokenId;
  // var timeTokenValue = TIMETOKEN_VALUE_PREFIX + timeTokenId;
  // var timeTokenLastRegen = TIMETOKEN_LASTREGEN_PREFIX + timeTokenId;

  var timeTokenObj = {};
  timeTokenObj[TIMETOKEN_KEY_CURRENTVALUE] = currentValue;
  timeTokenObj[TIMETOKEN_KEY_LASTREGEN] = lastRegen;
  timeTokenObj[TIMETOKEN_KEY_TIME] = lastUsedTime;


  var writeToServer = {};
  writeToServer[dataKey] = JSON.stringify(timeTokenObj);
  server.UpdateUserReadOnlyData({"PlayFabId" : currentPlayerId, "Data" : writeToServer, "Permission":"Private"});
}

function deleteTimeToken(timeTokenId)
{
  var dataKey = TT_PREFIX + timeTokenId;

  server.UpdateUserReadOnlyData({"PlayFabId": currentPlayerId,
                                 "KeysToRemove":
                                 [dataKey]
                                });
}

// mirip-mirip dengan fungsinya si playfab
function getTimeTokenInfo(timeTokenId)
{
  var dataKey = TT_PREFIX + timeTokenId;

  var returnValue= {};

  // user title data
  // var timeTokenValue = TIMETOKEN_VALUE_PREFIX + timeTokenId;
  // var timeTokenTime = TIMETOKEN_TIME_PREFIX + timeTokenId;
  // var timeTokenLastRegen = TIMETOKEN_LASTREGEN_PREFIX + timeTokenId;

  // title data
  // var timeTokenRechargeTime = TIMETOKEN_RECHARGETIME_PREFIX + timeTokenId;
  // var timeTokenMaxValue = TIMETOKEN_MAXVALUE_PREFIX + timeTokenId;

  var ttMaxValue = 0;
  var ttRechargeTime = 0;
  var secondsToRecharge = 0;

  // dapatkan informasi dari title data
  var titleParams = {};
  // titleParams.Keys = [timeTokenRechargeTime, timeTokenMaxValue];
  titleParams.Keys = [dataKey];
  var RawTitle = server.GetTitleData(titleParams);

  // cek kita punya informasi token ini di game title data
  if (RawTitle.Data.hasOwnProperty(dataKey)) {

    var timeTokenObj = JSON.parse(RawTitle.Data[dataKey]);

    // ttRechargeTime = parseInt(RawTitle.Data[timeTokenRechargeTime]);
    // ttMaxValue = parseInt(RawTitle.Data[timeTokenMaxValue]);
    ttRechargeTime = parseInt(timeTokenObj[TIMETOKEN_KEY_RECHARGETIME]);
    ttMaxValue = parseInt(timeTokenObj[TIMETOKEN_KEY_RECHARGEMAX]);

    var userToken = server.GetUserReadOnlyData({
      PlayFabId: currentPlayerId,
      Keys: [dataKey]
    });

    if (userToken.Data[dataKey] != null && userToken.Data[dataKey] != undefined) {

      var userTimeTokenObj = JSON.parse(userToken.Data[dataKey].Value);

      // var ttValue = parseInt(userToken.Data[timeTokenValue].Value);
      // var ttLastTime = userToken.Data[timeTokenTime].Value;
      // var ttLastRegen = userToken.Data[timeTokenLastRegen].Value;
      var ttValue = parseInt(userTimeTokenObj[TIMETOKEN_KEY_CURRENTVALUE]);
      var ttLastTime = userTimeTokenObj[TIMETOKEN_KEY_TIME];
      var ttLastRegen = userTimeTokenObj[TIMETOKEN_KEY_LASTREGEN];


      log.info("current value:" + ttValue);

      // ----------- update ngegenerate ----------- //

      // generate kalau nilai sekarang lebih kecil daripada max
      if (ttValue < ttMaxValue) {
        // hitung harus berapa banyak di regenerate
        var lastRegenElapsed = getTimeElapsed(ttLastRegen);
        log.info("last regen elapsed:" + lastRegenElapsed);
        var regenVal = parseInt(Math.floor(lastRegenElapsed/ttRechargeTime));

        // kalau udah lebih, kasih max valuenya aja
        if (regenVal >= ttMaxValue) {
          regenVal = ttMaxValue;
        }

        log.info("ttMaxValue:" + ttMaxValue);
        log.info("ttRecharge time:" + ttRechargeTime);
        log.info("regenVal:" + regenVal);
        if (regenVal > 0) {
          var regeneratedValue = ttValue + regenVal;

          // tambahkan regenerate, tapi jangan kelebihan
          if (regeneratedValue < ttMaxValue) {
            log.info("regenerated value:" + regeneratedValue);

            // set waktu pura-puranya di regen pas jam segitu
            var totalRegenSecond = ttRechargeTime * regenVal;
            log.info("total regen second:" + totalRegenSecond);
            var targetRegenTime = new Date(ttLastRegen);
            targetRegenTime.setSeconds(targetRegenTime.getSeconds() + totalRegenSecond);

            setRegenToken(timeTokenId, regeneratedValue, targetRegenTime, ttLastTime);

            log.info("last regen time:" + ttLastRegen);
            log.info("target regenerated time:" + targetRegenTime);
            log.info("now:" + new Date());

            ttValue = regeneratedValue;
          }else{
            // kalau kelebihan, set jadi max saja

            var prevUnregenerated = ttMaxValue - ttValue;
            log.info("prev unregen:" + prevUnregenerated);

            // set waktu pura-puranya di regen pas jam segitu
            var totalRegenSecond = ttRechargeTime * prevUnregenerated;
            log.info("total regen second:" + totalRegenSecond);
            var targetRegenTime = new Date(ttLastRegen);
            targetRegenTime.setSeconds(targetRegenTime.getSeconds() + totalRegenSecond);

            setRegenToken(timeTokenId, ttMaxValue, targetRegenTime, ttLastTime);

            log.info("last time:" + ttLastRegen);
            log.info("regenerated time:" + targetRegenTime);
            log.info("now:" + new Date());

            log.info("regenerated max:" + regeneratedValue + " to " + ttMaxValue);
            ttValue = ttMaxValue;
          }
        }

        // tunjukkan countdown kalau ada nilai yang perlu ditambah
        if (ttValue < ttMaxValue) {
          secondsToRecharge = ttRechargeTime-(lastRegenElapsed % ttRechargeTime);

          if (secondsToRecharge < 0)
            secondsToRecharge = 0;

          log.info("secondsToRecharge:" + secondsToRecharge);
        }else{
          secondsToRecharge = 0;
          log.info("secondsToRecharge:" + secondsToRecharge);
        }

      }else{

        //nilai sekarang lebih besar daripada max, tak ada waktu berikutnya

        secondsToRecharge = 0

        log.info("value maxed. secondsToRecharge:" + secondsToRecharge);
      }

      returnValue[TIMETOKEN_KEY_CURRENTVALUE] = ttValue;
      returnValue[TIMETOKEN_KEY_RECHARGETIME] = ttRechargeTime;
      returnValue[TIMETOKEN_KEY_RECHARGEMAX] = ttMaxValue;
      returnValue[TIMETOKEN_KEY_SECONDSTORECHARGE] = secondsToRecharge;
      returnValue[TIMETOKEN_KEY_ERROR] = null;

    }else{
      log.info("get but has no token, then create: " + timeTokenId + " by " + ttMaxValue);
      createToken(timeTokenId, ttMaxValue);

      // default value
      returnValue[TIMETOKEN_KEY_CURRENTVALUE] = ttMaxValue;
      returnValue[TIMETOKEN_KEY_RECHARGETIME] = ttRechargeTime;
      returnValue[TIMETOKEN_KEY_RECHARGEMAX] = ttMaxValue;
      returnValue[TIMETOKEN_KEY_ERROR] = null;


      // baru diisi, jadi beri saja nilai 0
      returnValue[TIMETOKEN_KEY_SECONDSTORECHARGE] = 0;
    }

    return returnValue;

  }else{
    // gak ada key ini di title data game

    log.info("ERROR no timetoken with key " + timeTokenId + " in title data");

    returnValue[TIMETOKEN_KEY_CURRENTVALUE] = null;
    returnValue[TIMETOKEN_KEY_RECHARGETIME] = null;
    returnValue[TIMETOKEN_KEY_RECHARGEMAX]  = null;
    returnValue[TIMETOKEN_KEY_SECONDSTORECHARGE] = null;
    returnValue[TIMETOKEN_KEY_ERROR] = TIMETOKEN_ERR_NOKEY;
    return returnValue;
  }


}


// dapatkan waktu
function getTimeElapsed(lastTimeStr)
{
  var currentTime = new Date();
  var lastTime = new Date(lastTimeStr);
  var timeDiff = currentTime.getTime() - lastTime.getTime();
  var timeDiff_seconds = timeDiff/1000;

  return timeDiff_seconds;
}

handlers.GetTimeTokenInfo = function (args, context)
{
  var timeTokenId = args.timeTokenId;

  return getTimeTokenInfo(timeTokenId);
}

handlers.AddTimeToken = function (args, context)
{
  var timeTokenId = args.timeTokenId;
  var value = args.value;
  return addTimeTokenValue(timeTokenId, value);

}





//-------------- End Time Token --------------//