6b/sec

import find from './find';
const DEFAULT_STEAL_MAX = 0.8;
/** @param {NS} ns */
export async function main(ns) {
  ns.clearLog();
  ns.disableLog('ALL');
  const serverName = ns.args[1] || 'n00dles';
  const stealMax = ns.args[0] || DEFAULT_STEAL_MAX;
  const res = [];
  find(ns, 'home', res);
  const all = res.map(d => d.name).filter(item => {
    if (ns.getServerRequiredHackingLevel(item) > ns.getHackingLevel()) {
      return false;
    }
    if (ns.getServerMaxRam(item) < 1024 * 5) {
      return false;
    }
    return true;
  })

  let buffer;
  let i = 1;

  const hacking = ns.formulas.hacking;

  async function getHome() {
    function needwait(home) {
      const maxRam = ns.getServerMaxRam(home);
      const threashHold = 5 * 1024;
      if (ns.getServerUsedRam(home) > maxRam - threashHold) {
        return true;
      }
      return false;
    }

    for (const home of all) {
      if (!needwait(home)) {
        return home;
      }
    }

    await ns.sleep(100);
    return await getHome();
  }

  while (true) {
    const home = await getHome();
    if (home) {
      const cores = ns.getServer(home).cpuCores;
      batch(home, cores);
      if (i > 1e11) {
        i = 1;
      }
    }
  }

  function batch(home, cores) {
    buffer = i * 1e-6;
    const server = ns.getServer(serverName);
    const player = ns.getPlayer();
    const hackTime = hacking.hackTime(server, player);
    const growTime = hacking.growTime(server, player);
    const weakenTime = hacking.weakenTime(server, player);
    const hackingPercent = hacking.hackPercent(server, player) || 1;

    const hackThreads = Math.ceil(stealMax / hackingPercent) || 1
    const increasedSecurityByHack = ns.hackAnalyzeSecurity(hackThreads);
    const weakenThreadsByHack = Math.ceil(increasedSecurityByHack / 0.05) || 1;

    const hackWillGetMoney = ns.hackAnalyze(serverName) * hackThreads * server.moneyMax;
    const growThreads = hacking.growThreads({ ...server, moneyAvailable: server.moneyMax - hackWillGetMoney }, player, server.moneyMax, cores) || 1;
    const increasedSecurityByGrow = ns.growthAnalyzeSecurity(growThreads);
    const weakenThreadsByGrow = Math.ceil(increasedSecurityByGrow / 0.05) || 1;

    const hack_offset = weakenTime - hackTime + buffer;
    const grow_offset = weakenTime - growTime + buffer;

    ns.exec('hackonce.js', home, hackThreads, serverName, hack_offset);
    ns.exec('weakenonce.js', home, weakenThreadsByHack, serverName, buffer);
    ns.exec('growonce.js', home, growThreads, serverName, grow_offset);
    ns.exec('weakenonce.js', home, weakenThreadsByGrow, serverName, buffer);
    i++;
  }

}