hopefully better

/** @param {NS} ns */
export async function main(ns) {

  /**Settings definitions*/

  const securityThresh = 1.5;// if security level is more than value * minimum security level
  const moneyThresh = 0.8;// if available money is less than value * maximum money
  const percentTakenPerHack = 0.1;// sets the
  const maxScanDepth = 20;// Sets max depth(# of connections between this and home) to scan to
  const settings = { // groups settings together for passing between functions
    securityThresh: securityThresh,
    moneyThresh: moneyThresh,
    percentTakenPerHack: percentTakenPerHack,
    maxScanDepth: maxScanDepth
  };

  /**Variable declarations*/

  var allServers = getallservers(settings) // array of all servers and their ram capacity
  var scriptServers = allServers.filter(filterByRamCap);// filtered array of servers with enough ram to run scripts as objects
  var targetInfo = {   // scripts will be deployed based on this information
    name: ns.args[0],
    hackLvlReq: ns.getServerRequiredHackingLevel(ns.args[0]),
    maxMoney: ns.getServerMaxMoney(ns.args[0]),
    minSecurity: ns.getServerMinSecurityLevel(ns.args[0])
  };

  /**Preparing server environment*/

  await attackAllServers(...allServers);// gains root access to as many servers as possible

  /**Program logic*/

  while (true) {
    let scriptType = chooseScriptType(settings, targetInfo);// determines what operation the program should initiate
    // scriptType has properties(scriptName, cost, waitTime)
    for (let target of findRam(scriptType.scriptName, getNeededThreads(scriptType, targetInfo, settings), ...scriptServers)) {
      //getNeededThreads returns an integer
      //findRam returns an array of objects with properties(serverName, threadCount)
      ns.scp(scriptType.scriptName, target.serverName, "home");
      ns.exec(scriptType.scriptName, target.serverName, target.threadCount, targetInfo.name);
    };
    await ns.sleep(scriptType.waitTime);// waits for scripts to finish before proceeding
    await ns.sleep(1000);// prevents freezing from infinite looping
  }


  /**Filtering functions*/


  function filterByRamCap(serverObj) { // Return true if serverobj has more than the ram needed to run scripts
    if (serverObj.ramCap > 2) {  // else will return false
      return true;
    }
    return false;
  }


  /**Returning/Synched Functions*/


  function getallservers(settings) {
    // settings has properties( maxScanDepth, moneyThresh,percentTakenPerHack, securityThresh)
    let serverList = [{ name: "home", ramCap: ns.getServerMaxRam("home") }]; // Iterable list of server objects
    for (let i = 0; i < settings.maxScanDepth; i++) { // Causes scan to run recursively maxDepth times
      for (let serverObj of serverList) { // Scans serverList for connections not already listed.
        let moreServerObjs = ns.scan(serverObj.name);
        for (let moreServerObj of moreServerObjs) { // checks if found connections are already listed
          let testServerObj = { // temporary object made to test for redundancy
            name: moreServerObj,
            ramCap: ns.getServerMaxRam(moreServerObj)
          };
          if (!serverList.some(obj => obj.name === testServerObj.name)) {
            // runs if testServerObj does not share a name property with any index of serverList
            serverList.push(
              {
                name: moreServerObj,
                ramCap: ns.getServerMaxRam(moreServerObj)
              }
            );
          }
        }
      }
    }
    serverList.push(serverList.shift());// moves home server to final index so that it is not prioritized for ram
    return [...serverList];// returns full array of server objects
  }// returns an array of objects with properties(name, ramCap)


  function chooseScriptType(settings, targetInfo) {
    // settings has properties(maxScanDepth, moneyThresh, percentTakenPerHack, securityThresh)
    // targetInfo has properties (name, hackLvlReq, maxMoney, minSecurity)
    let securityLevel = ns.getServerSecurityLevel(targetInfo.name);
    let availableMoney = ns.getServerMoneyAvailable(targetInfo.name);
    if (securityLevel > (targetInfo.minSecurity * settings.securityThresh)) {
      // if security level is too high return weaken script
      return ({
        scriptName: "weaken.js",
        cost: ns.getScriptRam("weaken.js", "home"),
        waitTime: ns.getWeakenTime(targetInfo.name)
      });
    } else if (availableMoney < (targetInfo.maxMoney * settings.moneyThresh)) {
      // if too little money is left return grow script
      return ({
        scriptName: "grow.js",
        cost: ns.getScriptRam("grow.js", "home"),
        waitTime: ns.getGrowTime(targetInfo.name)
      });
    } else {
      // if both thresholds are met return hack script
      return ({
        scriptName: "hack.js",
        cost: ns.getScriptRam("hack.js", "home"),
        waitTime: ns.getHackTime(targetInfo.name)
      });
    }
  }// returns with properties(scriptName, cost, waitTime)


  function findRam(scriptCost, neededThreads, ...scriptServers) {
    // scriptServers is an array of objects with properties(name, ramCap)
    let threadsPerServer = []// array to be returned
    let threadsLeft = neededThreads;// keeps track of how many more threads are needed
    for (let scriptServer of scriptServers) {
      if (threadsLeft <= 0) {
        return [...threadsPerServer];
      }
      let threadsPossible = Math.floor((scriptServer.ramCap - ns.getServerUsedRam(scriptServer.name)) / scriptCost);
      // the maximum number of threads that can be run without exceeding ram capacity
      if (threadsLeft < threadsPossible) { // if the server can handle all remaining threads
        if (threadsPossible >= 1) {
          threadsPerServer.push({
            serverName: scriptServer.name,
            threadCount: threadsLeft
          });
        }
        return [...threadsPerServer];
      } else {
        if (threadsPossible >= 1) { // only adds server if it can run at least one thread to prevent ns.exec error
          threadsPerServer.push({
            serverName: scriptServer.name,
            threadCount: threadsPossible
          });
          threadsLeft -= threadsPossible;
        }
      }
    }
    ns.print("unable to find enough ram to run script");
    return [...threadsPerServer];
  }// returns an array of objects with properties(serverName, threadCount)


  function getNeededThreads(scriptType, targetInfo, settings) {
    // scriptType has properties(scriptName, cost, waitTime)
    // targetInfo has properties(name, hackLvlReq, maxMoney, minSecurity)
    // settings has properties(maxScanDepth, moneyThresh, percentTakenPerHack, securityThresh)
    let securityLevel = ns.getServerSecurityLevel(targetInfo.name);
    let availableMoney = ns.getServerMoneyAvailable(targetInfo.name);
    if (scriptType.scriptName == "weaken.js") {
      return (Math.ceil((securityLevel - targetInfo.minSecurity) / ns.weakenAnalyze(1)));
      // divides difference between current and minimum security by weakenanalyze to get result
    } else if (scriptType.scriptName == "grow.js") {
      return (Math.ceil(ns.growthAnalyze(targetInfo.name, (targetInfo.maxMoney / availableMoney))));
      // growthanalyze based on how much larger maximum money is than current money
    } else if (scriptType.scriptName == "hack.js") {
      return (Math.ceil(settings.percentTakenPerHack / ns.hackAnalyze(targetInfo.name)));
    } else {
      ns.alert("something went wrong in PID: " + ns.pid);
    }
  }// returns positive integer


  /**Nonreturning/Asynched functions*/


  async function attackAllServers(...targetList) {
    // targetList is an array of objects with properties(name, ramCap)
    for (let target of targetList) {
      if (target.name != "home" && target.name != "darkweb") {
        await attack(target.name);
      }
    }
  }


  async function attack(server) {
    var hacktoolnum = 0;
    if (!ns.hasRootAccess(server)) {
      ns.toast('Opening ports on ' + server);
      if (ns.fileExists('BruteSSH.exe', 'home')) {// attempt to open SSH port
        ns.brutessh(server);
        hacktoolnum++;
      }
      if (ns.fileExists('FTPCrack.exe', 'home')) {// attempt to open FTP port
        ns.ftpcrack(server);
        hacktoolnum++;
      }
      if (ns.fileExists('relaySMTP.exe', 'home')) {// attempt to opem SMTP port
        ns.relaysmtp(server);
        hacktoolnum++;
      }
      if (ns.fileExists('HTTPWorm.exe', 'home')) {// attempt to open HTTP port
        ns.httpworm(server);
        hacktoolnum++;
      }
      if (ns.fileExists('SQLInject.exe', 'home')) {// attempt to open SQL port
        ns.sqlinject(server);
        hacktoolnum++;
      }
    }
    if (ns.getServerNumPortsRequired(server) <= hacktoolnum && !ns.hasRootAccess(server)) {
      ns.toast("nuking " + server);
      ns.nuke(server);
    }
    if (!ns.hasRootAccess(server)) {
      ns.toast("unable to gain root to " + server, "error");
    }
  }
}