import { getGrowThreads, getSetting } from "myLibrary.js";

/** @param {NS} ns */
export async function main(ns) {
  //Arguments
  const nArgs = ns.args.length
  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
  const bTail = ns.args[3]; //if true the script will run even if estimated RAM is too low

  //host and script info
  //const sThisRunner = ns.getHostname();
  //const sThisScript = ns.getScriptName();
  if (bTail === true) { ns.tail(); }

  //logs
  ns.disableLog("ALL");

  //Settings
  const sHackScript = "RMhack.js";
  const sGrowScript = "RMgrow.js";
  const sWeakenScript = "RMweaken.js";

  //const nHackThreads = 50;   //1
  const nHackThreads = getSetting(ns, "batchHacks");   //1

  const nHackScriptRAM = 1.75;
  const nGrowScriptRAM = 1.7;
  const nWeakenScriptRAM = 1.75;


  //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 = 1000; }

  //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; }

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

  let nBonusWeaken = 0;
  let nBonusGrow = 0;

  /*if (nCurrentSecurity > nMinSecurity + 3) {
    nBonusWeaken = 4;
  }
  if (nCurrentMoney <= nMaxMoney * 0.8) {
    nBonusGrow = 9;
  }*/

  let nGrowThreads = Math.max(12 + nBonusGrow, getGrowThreads(ns, sTarget, nHackThreads));
  let nGrowThreadsINT = Math.ceil(nGrowThreads);

  //25 hacks or 12.5 grows
  let nWeakenThreads = Math.max(1 + nBonusWeaken, (nHackThreads / 25) + (nGrowThreads / 12.5));
  let nWeakenThreadsINT = Math.ceil(nWeakenThreads);

  //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 nCores = oRunner.cpuCores;

  //const sRunner = ns.getHostname(); //hostname string of the server running the script
  let nMaxRAM = ns.getServerMaxRam(sRunner);
  let nUsedRAM = ns.getServerUsedRam(sRunner);
  let nFreeRam = nMaxRAM - nUsedRAM;
  //const sScriptName = ns.getScriptName();
  //const nScriptSize = ns.getScriptRam(sScriptName, sRunner);
  //let nMoney = ns.getServerMoneyAvailable(sTarget);
  let nHomeServerReserve = Math.min(nMaxRAM / 8, 64);

  if (sRunner !== "home") {
    nHomeServerReserve = 0;
  }

/*
  let nWeakenPower = ns.weakenAnalyze(1, nCores); // default 0.05 (always?)
  ns.tprint("nWeakenPower = " + nWeakenPower + " with " + nCores + " nCores");

  let nHackSecurity = ns.hackAnalyzeSecurity(1, sTarget); // default 0.002
  ns.tprint("nHackSecurity = " + nHackSecurity + " on " + sTarget + " sTarget");

  let nGrowSecurity = ns.growthAnalyzeSecurity(1, "", nCores);// default 0.004 (always?)
  ns.tprint("nGrowSecurity = " + nGrowSecurity + " on " + "_" + " sTarget" + " with " + nCores + " nCores");
*/
  while (true) {

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

    nBonusWeaken = 0;
    if (nCurrentSecurity > nMinSecurity + 3) {
      nBonusWeaken = 4;
    }
    nBonusGrow = 0;
    if (nCurrentMoney <= nMaxMoney * 0.8) {
      nBonusGrow = 11;
    }


    nGrowThreads = Math.max(1 + nBonusGrow, getGrowThreads(ns, sTarget, nHackThreads));
    nGrowThreadsINT = Math.ceil(nGrowThreads);

    //25 hacks or 12.5 grows
    nWeakenThreads = Math.max(1 + nBonusWeaken, (nHackThreads / 25) + (nGrowThreads / 12.5));
    nWeakenThreadsINT = Math.ceil(nWeakenThreads);

    //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);

    nMaxRAM = ns.getServerMaxRam(sRunner);
    nUsedRAM = ns.getServerUsedRam(sRunner);
    nFreeRam = nMaxRAM - nUsedRAM;

    while (nFreeRam <= (nWeakenScriptRAM * nWeakenThreads) + nHomeServerReserve + 6) {
      await ns.sleep(100);
      nMaxRAM = ns.getServerMaxRam(sRunner);
      nUsedRAM = ns.getServerUsedRam(sRunner);
      nFreeRam = nMaxRAM - nUsedRAM;
    }

    if (nFreeRam > (nWeakenScriptRAM * nWeakenThreads) + nHomeServerReserve + 6) {
      //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);
      ns.print("Weakening with " + nWeakenThreadsINT + " threads on " + sTarget);
      let nWeakenPID = ns.run(sWeakenScript, nWeakenThreadsINT, sTarget);
      if (nWeakenPID === 0) { ns.print("Weaken Failed..."); }
    }

    nMaxRAM = ns.getServerMaxRam(sRunner);
    nUsedRAM = ns.getServerUsedRam(sRunner);
    nFreeRam = nMaxRAM - nUsedRAM;

    while (nFreeRam <= (nGrowScriptRAM * nGrowThreads) + nHomeServerReserve + 6) {
      await ns.sleep(100);
      nMaxRAM = ns.getServerMaxRam(sRunner);
      nUsedRAM = ns.getServerUsedRam(sRunner);
      nFreeRam = nMaxRAM - nUsedRAM;

    }

    if (nCurrentSecurity <= (nMinSecurity + 1) && nFreeRam > (nGrowScriptRAM * nGrowThreads) + nHomeServerReserve + 6) {

      //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);
      ns.print("Growing with " + nGrowThreadsINT + " threads on " + sTarget);
      let nGrowPID = ns.run(sGrowScript, nGrowThreadsINT, sTarget);
      if (nGrowPID === 0) { ns.print("Grow Failed..."); }


      nMaxRAM = ns.getServerMaxRam(sRunner);
      nUsedRAM = ns.getServerUsedRam(sRunner);
      nFreeRam = nMaxRAM - nUsedRAM;

      while (nFreeRam <= (nHackScriptRAM * nHackThreads) + nHomeServerReserve + 6) {
        await ns.sleep(100);
        nMaxRAM = ns.getServerMaxRam(sRunner);
        nUsedRAM = ns.getServerUsedRam(sRunner);
        nFreeRam = nMaxRAM - nUsedRAM;

      }

      if (nCurrentMoney >= nMaxMoney * 0.8 && nFreeRam > (nHackScriptRAM * nHackThreads) + nHomeServerReserve + 6) {

        //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.print("Hacking with " + nHackThreads + " threads on " + sTarget);
        let mHackPID = ns.run(sHackScript, nHackThreads, sTarget);
        if (mHackPID === 0) { ns.print("Hack Failed..."); }

      }

    }
    await ns.sleep(nFrequency);
    ns.print("-------------------------------------------------------------------------");
  }

}