/** @param {NS} ns */
export async function main(ns) {
  //Arguments
  const sTarget = ns.args[0]; // target server
  let nFrequency = ns.args[1]; // frequency to run the Hack / Grow / Weaken
  const bIgnoreRAM = ns.args[2]; //if true the script will run even if estimated RAM is too low

  //Settings
  const sWeakenScript = "Ramses-weaken.js";
  const sGrowScript = "Ramses-grow.js";
  const sHackScript = "Ramses-hack.js";
  const nWeakenThreads = 5;
  const nGrowThreads = 10;
  const nHackThreads = 1;

  //logs
  ns.disableLog("getServerMaxRam");
  ns.disableLog("getServerUsedRam");
  ns.disableLog("getServerMinSecurityLevel");
  ns.disableLog("getServerMaxMoney");
  ns.disableLog("getServerSecurityLevel");
  ns.disableLog("getServerMoneyAvailable");


  //abort script if sTarget is undefined
  if (sTarget === undefined) {
    ns.tprint("1st arg sTarget is undefined");
    return false;
  }

  //how often do we run script in milliseconds
  if (nFrequency === undefined) {
    nFrequency = 20000;   //run every 20 seconds unless defined as the 2nd argument when calling the script
  }

  //target server info
  const nMinSecurity = ns.getServerMinSecurityLevel(sTarget);
  const nMaxMoney = ns.getServerMaxMoney(sTarget);

  //abort script if sTarget cant have money
  if (nMaxMoney <= 0) {
    ns.tprint("sTarget (" + sTarget + ") has no nMaxMoney");
    return false;
  }

  //main variables
  const oRunner = ns.getServer();   //which server object is running this script
  const sRunner = oRunner.hostname; //hostname string of the server running the script
  const nMaxRAM = ns.getServerMaxRam(sRunner);
  const nUsedRAM = ns.getServerUsedRam(sRunner);
  let nFreeRam = nMaxRAM - nUsedRAM;
  const sScriptName = ns.getScriptName();
  const nScriptSize = ns.getScriptRam(sScriptName, sRunner);
  const nCores = oRunner.cpuCores;

  const nWeakenScriptRAM = ns.getScriptRam(sWeakenScript, sRunner) * nWeakenThreads;
  const nGrowScriptRAM = ns.getScriptRam(sGrowScript, sRunner) * nGrowThreads;
  const nHackScriptRAM = ns.getScriptRam(sHackScript, sRunner) * nHackThreads;

  const nWeakenTime = ns.getWeakenTime(sTarget);
  const nGrowTime = ns.getGrowTime(sTarget);
  const nHackTime = ns.getHackTime(sTarget);

  ns.tprint(sScriptName + " nScriptSize = " + nScriptSize+"GB");

  const nMaxWeakenRAM = Math.ceil(nWeakenScriptRAM * ((nWeakenTime / 1000) / (nFrequency / 1000)));
  ns.tprint("nWeakenTime = " + nWeakenTime / 1000);
  ns.tprint("nFrequency = " + nFrequency / 1000);
  ns.tprint("nMaxWeakenRAM = " + nMaxWeakenRAM);

  const nMaxGrowRAM = Math.ceil(nGrowScriptRAM * ((nGrowTime / 1000) / (nFrequency / 1000)));
  ns.tprint("nGrowTime = " + nGrowTime / 1000);
  ns.tprint("nFrequency = " + nFrequency / 1000);
  ns.tprint("nMaxGrowRAM = " + nMaxGrowRAM);

  const nMaxHackRAM = Math.ceil(nHackScriptRAM * ((nHackTime / 1000) / (nFrequency / 1000)));
  ns.tprint("nHackTime = " + nHackTime / 1000);
  ns.tprint("nFrequency = " + nFrequency / 1000);
  ns.tprint("nMaxHackRAM = " + nMaxHackRAM);

  const nTotalRAM = (nScriptSize + nMaxWeakenRAM + nMaxGrowRAM + nMaxHackRAM) * 1.07;
  ns.tprint("Total estimated required RAM = " + nTotalRAM+"GB");
  ns.tprint("Available RAM: " + nFreeRam+" / "+nMaxRAM+"GB");

  if (nTotalRAM < nFreeRam || bIgnoreRAM === true) {
    while (true) {

      //server stats
      let nCurrentSecurity = ns.getServerSecurityLevel(sTarget);
      let nCurrentMoney = ns.getServerMoneyAvailable(sTarget);

      //timestamp
      let currentDate = new Date();
      let nOffset;

      ns.print("Cash: " + (Math.floor(nCurrentMoney * 1000) / 1000) + " / " + nMaxMoney);
      ns.print("Security: " + (Math.floor(nCurrentSecurity * 1000) / 1000) + " / " + nMinSecurity);

      //Calculate estimate time of completion
      nOffset = ns.getWeakenTime(sTarget);
      let nWeakTime = new Date(currentDate.getTime() + nOffset);
      let sWeakTime = nWeakTime.toLocaleTimeString('sw-SV');  //swedish time

      //Print estimated time of completion
      ns.print("Weakening " + sTarget + " Estimated complete at " + sWeakTime);




      if (nCurrentSecurity <= (nMinSecurity + 5)) {

        //Calculate estimate time of completion
        nOffset = ns.getGrowTime(sTarget);
        let nGrowTime = new Date(currentDate.getTime() + nOffset);
        let sGrowTime = nGrowTime.toLocaleTimeString('sw-SV');  //swedish time

        //Print estimated time of completion
        ns.print("Growing " + sTarget + " Estimated complete at " + sGrowTime);



        if (nCurrentMoney >= nMaxMoney * 0.8) {

          //Calculate estimate time of completion
          nOffset = ns.getHackTime(sTarget);
          let nHackTime = new Date(currentDate.getTime() + nOffset);
          let sHackTime = nHackTime.toLocaleTimeString('sw-SV');  //swedish time

          //Print estimated time of completion
          ns.print("Hacking " + sTarget + " Estimated complete at " + sHackTime);

          ns.run(sHackScript, 1, sTarget);
        }
        ns.run(sGrowScript, 10, sTarget);
      }
      ns.run(sWeakenScript, 5, sTarget);
      nFreeRam = ns.getServerMaxRam(sRunner) - ns.getServerUsedRam(sRunner);

      await ns.sleep(nFrequency);
      ns.print("-------------------------------------------------------------------------");
    }
  }
  else {
    ns.tprint("Insufficient estimated required RAM... no scripts were started...");
  }

}