controlHackScript

/** @param {NS} ns */
export async function main(ns) {
  let supportServers = ns.getPurchasedServers()
  let hackServers = [
    'harakiri-sushi',
    'joesguns',
    'hong-fang-tea',
    'phantasy',
    'the-hub',
    'crush-fitness',
    'silver-helix',
    'omega-net',
    'iron-gym',
    'zer0',
    'CSEC',
    'avmnite-02h',
    'max-hardware',
    //'computek',
    'johnson-ortho'
  ]
  //let hackPercentage = .2 //TODO:CHANGE!!!!!change based on hack level and hackServer security.
  let availableServerRam;

  let maxServerMoney;
  let currentServerMoney;

  let serverSecurityLevel;
  let securityMin;

  let serverStatus = {}; // Track thread usage per hack server

  for (let hackServer of hackServers) {
    if (!ns.hasRootAccess(hackServer)) {
      ns.exec('nukeit.js', 'home', 1, hackServer)
    }
    if (!serverStatus[hackServer]) {
      serverStatus[hackServer] = { growth: 0, weaken: 0, hack: 0 };
    }
  }
  await ns.sleep(1000)

  const basePort = 3000
  while (true) {
    for (let hackServer of hackServers) {

      let hackPercentage = getHackPercentage(ns, hackServer)
      let growPort = basePort + hackServers.indexOf(hackServer) * 3;
      let weakenPort = growPort + 1;
      let hackPort = growPort + 2;

      // Read results from ports dedicated to this hackServer
      let growResult = ns.readPort(growPort) || 'NULL PORT DATA';
      let weakenResult = ns.readPort(weakenPort) || 'NULL PORT DATA';
      let hackResult = ns.readPort(hackPort) || 'NULL PORT DATA';

      // Update used threads based on results
      if (growResult !== 'NULL PORT DATA') {
        serverStatus[hackServer].growth -= parseInt(growResult);
        ns.print(`Growth completed for ${hackServer} with ${growResult} threads used.`);
      }
      if (weakenResult !== 'NULL PORT DATA') {
        serverStatus[hackServer].weaken -= parseInt(weakenResult);
        ns.print(`Weaken completed for ${hackServer} with ${weakenResult} threads used.`);
      }
      if (hackResult !== 'NULL PORT DATA') {
        serverStatus[hackServer].hack -= parseInt(hackResult);
        ns.print(`Hack completed for ${hackServer} with ${hackResult} threads used.`);
      }
      maxServerMoney = ns.getServerMaxMoney(hackServer);
      currentServerMoney = ns.getServerMoneyAvailable(hackServer)

      serverSecurityLevel = ns.getServerSecurityLevel(hackServer);
      securityMin = ns.getServerMinSecurityLevel(hackServer) + 5;

      if (serverSecurityLevel > securityMin) {
        let totalWeakenThreadsNeeded = getWeakenThreads(ns, serverSecurityLevel, securityMin, supportServers);
        if (serverStatus[hackServer].weaken < totalWeakenThreadsNeeded) {
          let threadsToLaunch = totalWeakenThreadsNeeded - serverStatus[hackServer].weaken;
          DistributeWeaken(ns, hackServer, supportServers, threadsToLaunch, weakenPort);
        }
      }
      if (currentServerMoney < (maxServerMoney * hackPercentage)) {
        let totalGrowthThreadsNeeded = getGrowThreads(ns, maxServerMoney, currentServerMoney, supportServers, hackServer, hackPercentage);
        if (serverStatus[hackServer].growth < totalGrowthThreadsNeeded) {
          let threadsToLaunch = totalGrowthThreadsNeeded - serverStatus[hackServer].growth;
          DistributeGrow(ns, threadsToLaunch, hackServer, supportServers, growPort);
        }
      }
      if ((currentServerMoney >= maxServerMoney * hackPercentage) && ns.getServerRequiredHackingLevel(hackServer) < ns.getHackingLevel()) {
        let totalHackThreadsNeeded = getHackThreads(ns, hackServer, hackPercentage, maxServerMoney, currentServerMoney);

        if (serverStatus[hackServer].hack < totalHackThreadsNeeded) {
          let threadsToLaunch = totalHackThreadsNeeded - serverStatus[hackServer].hack;
          DistributeHack(ns, threadsToLaunch, hackServer, supportServers, hackPort, hackPercentage);
        }
      }
    }
    await ns.sleep(100);
  }



  //returns total threads needed to complete weakening hackServer
  function getWeakenThreads(ns, serverSecurityLevel, securityMin, supportServers) {
    let totalWeakenThreadsNeeded = 0;

    let securityDeficit = serverSecurityLevel - securityMin;

    for (let supportServer of supportServers) {
      let serverCores = getServerCores(ns, supportServer)
      let weakenAnalyze = ns.weakenAnalyze(1, serverCores);
      let weakenThreadsNeeded = Math.ceil(securityDeficit / weakenAnalyze);

      totalWeakenThreadsNeeded += weakenThreadsNeeded;
      securityDeficit -= weakenThreadsNeeded * weakenAnalyze;

      if (securityDeficit <= 0) break;  // If security is weakened enough, stop
    }
    return totalWeakenThreadsNeeded;
  }

  function DistributeWeaken(ns, hackServer, supportServers, totalWeakenThreads, weakenPort) {
    let remainingWeaknessThreads = totalWeakenThreads
    for (let supportServer of supportServers) {
      if (remainingWeaknessThreads > 0) {
        let availableThreads = getAvailableThreads(ns, supportServer)
        let weakenThreadsToUse = Math.min(availableThreads, remainingWeaknessThreads)
        if (weakenThreadsToUse > 0) {
          ns.scp('weaken.js', supportServer, 'home')
          ns.exec('weaken.js', supportServer, weakenThreadsToUse, hackServer, weakenThreadsToUse, weakenPort)
          ns.print(`[${supportServer}] is weakening ${hackServer} using ${weakenThreadsToUse} threads / ${remainingWeaknessThreads}`);
          remainingWeaknessThreads -= weakenThreadsToUse
          serverStatus[hackServer].weaken += weakenThreadsToUse
        }
      }
    }
  }

  function getGrowThreads(ns, maxServerMoney, currentServerMoney, supportServers, hackServer, hackPercentage) {
    let totalGrowthThreadsNeeded = 0;
    let growthTarget = maxServerMoney * hackPercentage;

    let growthDeficit = growthTarget / currentServerMoney;

    if (growthDeficit <= 1) {
      return 0;
    }

    for (let supportServer of supportServers) {
      let serverCores = getServerCores(ns, supportServer);

      let neededGrowthThreads = ns.growthAnalyze(hackServer, growthDeficit, serverCores);

      totalGrowthThreadsNeeded += Math.ceil(neededGrowthThreads);

      if (totalGrowthThreadsNeeded >= neededGrowthThreads) break;
    }

    return totalGrowthThreadsNeeded;
  }




  function DistributeGrow(ns, totalGrowthThreads, hackServer, supportServers, growPort) {
    let remainingGrowthThreads = totalGrowthThreads
    for (let supportServer of supportServers) {
      if (remainingGrowthThreads > 0) {
        let availableThreads = getAvailableThreads(ns, supportServer)
        let growthThreadsToUse = Math.min(availableThreads, remainingGrowthThreads)
        if (growthThreadsToUse > 0) {
          ns.scp('growth.js', supportServer, 'home')
          ns.exec('growth.js', supportServer, growthThreadsToUse, hackServer, growthThreadsToUse, growPort)
          ns.print(`[${supportServer}] is growing ${hackServer} using ${growthThreadsToUse} threads / ${remainingGrowthThreads}`);
          serverStatus[hackServer].growth += growthThreadsToUse
          remainingGrowthThreads -= growthThreadsToUse;
        }
      }
    }
  }

  function getHackThreads(ns, hackServer, hackPercentage, maxServerMoney, currentServerMoney) {
    let hackMoneyDelta = currentServerMoney - maxServerMoney * hackPercentage
    let neededHackThreads = ns.hackAnalyzeThreads(hackServer, hackMoneyDelta)
    return Math.ceil(neededHackThreads)
  }

  function DistributeHack(ns, totalHackThreads, hackServer, supportServers, hackPort, hackPercentage) {
    let remainingHackThreads = totalHackThreads
    for (let supportServer of supportServers) {
      if (remainingHackThreads > 0) {
        let availableThreads = getAvailableThreads(ns, supportServer)
        let hackThreadsToUse = Math.min(availableThreads, remainingHackThreads)
        if (hackThreadsToUse > 0) {
          ns.scp('hack.js', supportServer, 'home')
          ns.exec('hack.js', supportServer, hackThreadsToUse, hackServer, hackThreadsToUse, hackPort)
          ns.tprint(`[${supportServer}] is hacking ${hackServer} ${hackPercentage}% using ${hackThreadsToUse} threads / ${remainingHackThreads}`);
          serverStatus[hackServer].hack += hackThreadsToUse
          remainingHackThreads -= hackThreadsToUse;
        }
      }
    }
  }
  function getAvailableThreads(ns, supportServer) {
    availableServerRam = (ns.getServerMaxRam(supportServer) - ns.getServerUsedRam(supportServer))
    return Math.floor(availableServerRam / 1.75)
  }
  function getServerCores(ns, supportServer) {
    return ns.getServer(supportServer).cpuCores
  }
  function getHackPercentage(ns, hackServer) {
    let maxMoney = ns.getServerMaxMoney(hackServer);
    let currentMoney = ns.getServerMoneyAvailable(hackServer);
    let securityLevel = ns.getServerSecurityLevel(hackServer);
    let minSecurity = ns.getServerMinSecurityLevel(hackServer);
    let hackingLevel = ns.getHackingLevel();
    let requiredHackingLevel = ns.getServerRequiredHackingLevel(hackServer);
    let growthMultiplier = ns.getServerGrowth(hackServer);

    // Base percentage scales with how much money is available on the server
    let percentage = (currentMoney / maxMoney) * 0.5;

    // Adjust percentage based on security level (penalize if security is high)
    let securityFactor = Math.max(0, 1 - ((securityLevel - minSecurity) / minSecurity));
    percentage *= securityFactor;

    let levelFactor = Math.min(1, hackingLevel / (requiredHackingLevel * 1.5));
    percentage *= 1 + (levelFactor * 0.5);


    let growthFactor = Math.max(0.5, 100 / growthMultiplier);
    percentage *= growthFactor;

    percentage = Math.min(Math.max(percentage, 0.05), 0.8);

    return percentage;
  }

}