/** @param {NS} ns **/
export async function main(ns) {
  let target = ns.args[0];
  let moneyThresh = ns.getServerMaxMoney(target) * 0.75;
  let securityThresh = ns.getServerMinSecurityLevel(target) + 5;
  let servers = [];
  let ramPerThread = ns.getScriptRam("/shared/weaken.js");

  // This is required for later on where I want the targets money printed into the log and actually look nice.
  const formatter = new Intl.NumberFormat('en-US', {
    style: 'currency',
    currency: 'USD',

    // These options are needed to round to whole numbers if that's what you want.
    //minimumFractionDigits: 0, // (this suffices for whole numbers, but will print 2500.10 as $2,500.1)
    maximumFractionDigits: 0, // (causes 2500.99 to be printed as $2,501)
  });

  // This goes through every server, NUKE's it (if we own the needed exploits) and dumps our little
  // worker scripts so we can use them later on.
  let serversToScan = ns.scan("home");
  while (serversToScan.length > 0) {
    let server = serversToScan.shift();
    if (!servers.includes(server) && server !== "home") {
      servers.push(server);
      serversToScan = serversToScan.concat(ns.scan(server));
      await ns.scp([
        "/shared/weaken.js",
        "/shared/grow.js",
        "/shared/hack.js"
      ], server);

      let openPorts = 0;
      if (ns.fileExists("BruteSSH.exe")) {
        ns.brutessh(server);
        openPorts++;
      }
      if (ns.fileExists("FTPCrack.exe")) {
        ns.ftpcrack(server);
        openPorts++;
      }
      if (ns.fileExists("RelaySMTP.exe")) {
        ns.relaysmtp(server);
        openPorts++;
      }
      if (ns.fileExists("HTTPWorm.exe")) {
        ns.httpworm(server);
        openPorts++;
      }
      if (ns.fileExists("SQLInject.exe")) {
        ns.sqlinject(server);
        openPorts++;
      }
      if (ns.getServerNumPortsRequired(server) <= openPorts) {
        ns.nuke(server);
      }
    }
  }
  // Everything below is the real "Meat and potatoes" of the script
  if (ns.hasRootAccess(target)) {

    while (true) {
      let sleepTime = 3000;
      let activeScript = "";
      let targetCurrentMoney = ns.getServerMoneyAvailable(target);
      let targetMaxMoney = ns.getServerMaxMoney(target);
      let targetCurrentSecurity = ns.getServerSecurityLevel(target);
      let targetMaxSecurity = ns.getServerBaseSecurityLevel(target);
      var threadTotal = 0;
      var weakenActive = 0;
      var growActive = 0;
      var hackActive = 0;
      let hackingLevel = ns.getServerRequiredHackingLevel(target);

      // I really wanted to have the time the current attack was activated and would end so this means
      // we can use "time" to use later.
      const today = new Date();
      const time = today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds();

      for (let server of servers) {
        if (ns.hasRootAccess(server)) {
          let ramAvailable = ns.getServerMaxRam(server) - ns.getServerUsedRam(server);
          let threads = Math.floor(ramAvailable / ramPerThread);
          let weakenThreadTotal = Math.floor(ns.getServerSecurityLevel(target) / 0.05);
          let growThreadTotal = Math.floor(ns.getServerBaseSecurityLevel(target) / 0.004);
          let hackThreadTotal = Math.floor(ns.getServerBaseSecurityLevel(target) / 0.002);
          let weakenThread = weakenThreadTotal - threadTotal;
          let growThread = growThreadTotal - threadTotal;
          let hackThread = hackThreadTotal - threadTotal;

          // Here we figure out which attack to execute but also make sure it only happens using the maximum number
          // of threads it needs so we can then attack other servers.
          if (threads > 0) {
            if (ns.getServerSecurityLevel(target) > securityThresh && threadTotal < weakenThread && growActive == 0 && hackActive == 0) {
              sleepTime = ns.getWeakenTime(target);
              if (weakenThreadTotal < threads) {
                ns.exec("/shared/weaken.js", server, weakenThreadTotal, target);
                threadTotal += weakenThreadTotal;
              } else if (weakenThread > threadTotal) {
                ns.exec("/shared/weaken.js", server, threads, target);
                threadTotal += threads;
              } else {
                ns.exec("/shared/weaken.js", server, weakenThread, target);
                threadTotal += weakenThread;
              }
              activeScript = "Weaken";
              weakenActive = 1;
            } else if (ns.getServerMoneyAvailable(target) < moneyThresh && threadTotal < growThread && weakenActive == 0 && hackActive == 0) {
              sleepTime = ns.getGrowTime(target);
              if (growThreadTotal < threads) {
                ns.exec("/shared/grow.js", server, growThreadTotal, target);
                threadTotal += growThreadTotal;
              } else if (growThread > threadTotal) {
                ns.exec("/shared/grow.js", server, threads, target);
                threadTotal += threads;
              } else {
                ns.exec("/shared/grow.js", server, growThread, target);
                threadTotal += growThread;
              }
              activeScript = "Grow";
              growActive = 1;
            } else if (ns.getServerSecurityLevel(target) < securityThresh && threadTotal < hackThread && weakenActive == 0 && growActive == 0) {
              sleepTime = ns.getHackTime(target);
              if (hackThreadTotal < threads) {
                ns.exec("/shared/hack.js", server, hackThreadTotal, target);
                threadTotal += hackThreadTotal;
              } else if (hackThread > threadTotal) {
                ns.exec("/shared/hack.js", server, threads, target);
                threadTotal += threads;
              } else {
                ns.exec("/shared/hack.js", server, hackThread, target);
                threadTotal += hackThread;
              }
              activeScript = "Hack";
              hackActive = 1;
            }
          }
        }
      }
      // This took me a while to figure out but it allows us to modify the time information from earlier so we
      // can then print out the time the script will finish. Handy for people that just like watching the
      // game run.
      function addSeconds(today, seconds) {
        today.setSeconds(today.getSeconds() + seconds);
        return today;
      }

      const finish = addSeconds(today, (sleepTime / 1000));
      const endTime = finish.getHours() + ":" + finish.getMinutes() + ":" + finish.getSeconds();

      // And this just wipes the log window and gives us all the relevant information that we actually care about.
      ns.clearLog();
      ns.print("Target Server:   " + target + " (" + hackingLevel + ")");
      ns.print("Server Money:    " + formatter.format(targetCurrentMoney) + "/" + formatter.format(targetMaxMoney));
      ns.print("Server Security: " + Math.floor(targetCurrentSecurity) + "/" + targetMaxSecurity + " (" + securityThresh + ")");
      ns.print("Active Script:   " + activeScript + " (" + threadTotal + ")");
      ns.print("Start/Finish:    " + time + "/" + endTime);
      await ns.sleep(sleepTime + 100);
    }
  }
}