/** @param {NS} ns**/
export async function main(ns) {
ns.disableLog('ALL');

//Welcome to the Auto Farm part 2: Electric Boogaloo - Advanced Edition
//This script is a little more complicated to explain easily, it dedicates high RAM servers to attack high profit servers
//This is also set and forget, your EXEs and hacking level are reacquired each second, so new servers are added without needing to reboot it
//Well I hope this brings you ideas, knowledge and or profits :D

var files = ['grow.script', 'weak.script', 'hack.script'];
await ns.write(files[0], 'grow(args[0])', 'w'); await ns.write(files[1], 'weaken(args[0])', 'w'); await ns.write(files[2], 'hack(args[0])', 'w');

var exclude = [''] //Servers names that won't be used as hosts or deleted

var servers; var hosts; var targets; var exes; var tarIndex; var loop; var hType; var tmp; var act;
var netManager = false; var serverManager = false;
var cycle = [0, '▄', '█', '▀', '█'];
if (false) { brutessh(); ftpcrack(); relaysmtp(); httpworm(); sqlinject() }

const checkM = (c, d) => eval(c < ns.getPlayer().money / d)
const arraySort = (arr) => arr.sort((a, b) => b[0] - a[0])
function str(s) { if (s.length > 14) { return s.substring(0, 14) + '...' } else { return s } }
function info(t, s) {
if (t == 'MM') { return ns.getServerMaxMoney(s) }
if (t == 'MA') { return ns.getServerMoneyAvailable(s) }
if (t == 'MR') { return ns.getServerMaxRam(s) }
if (t == 'UR') { return ns.getServerUsedRam(s) }
if (t == 'NPR') { return ns.getServerNumPortsRequired(s) }
if (t == 'RHL') { return ns.getServerRequiredHackingLevel(s) }
if (t == 'SL') { return ns.getServerSecurityLevel(s) }
if (t == 'MSL') { return ns.getServerMinSecurityLevel(s) }
}

async function scanExes() { for (let hack of ['brutessh', 'ftpcrack', 'relaysmtp', 'sqlinject', 'httpworm']) { if (ns.fileExists(hack + '.exe')) { exes.push(hack) } } }

function log() {
if (cycle[0] >= 4) { cycle[0] = 0 }; cycle[0]++; ns.clearLog();
ns.print('╔═══╦════════════════════════════════════╗')
tmp = targets.slice(0, 12)
ns.print(`║ ${cycle[cycle[0]]} ║ HIGH PROFIT BALANCE ║`)
for (let t of tmp) {
ns.print(`║ ${act[t[1]]} ║ ${str(t[1])}` + `${ns.nFormat(info('MA', t[1]), '0a')} / ${ns.nFormat(info('MM', t[1]), '0a')} : ${ns.nFormat(info('MA', t[1]) / info('MM', t[1]), '0%')} ║`.padStart(36 - str(t[1]).length))
}
ns.print('╠═══╩════════════════════════════════════╝')
ns.print(`║ EXE ${exes.length}/5 ║ HOSTS ${hosts.length} ║ TARGETS ${targets.length}`)
ns.print('╠═════════════════════════════════════════')

if (netManager || serverManager) {
tmp = '║ MANAGER'
if (netManager) { tmp += ' ║ HN-Nodes ' + ns.hacknet.numNodes() }
if (serverManager) { tmp += ' ║ P-Servers ' + ns.getPurchasedServers().length }
ns.print(tmp + '\n╠═════════════════════════════════════════')
}
}

async function scanServers(host, current) {//Combined scan and check
for (let server of ns.scan(current)) {
if ((ns.getPurchasedServers().includes(server) || info('NPR', server) <= exes.length) && host != server) {
if (!ns.getPurchasedServers().includes(server)) { for (let hack of exes) { ns[hack](server) }; ns.nuke(server) }
if (info('MM', server) != 0 && info('RHL', server) <= ns.getHackingLevel() && info('MSL', server) < 100) {
targets.push([Math.floor(info('MM', server) / info('MSL', server)), server]); targets = arraySort(targets)
}
if (info('MR', server) > 4 && !exclude.includes(server)) { hosts.push([info('MR', server), server]); hosts = arraySort(hosts) }
servers.push(server)
await ns.scp(files, 'home', server)
await scanServers(current, server)
}
}
}

async function hackAll() {//Dedicates high RAM servers to high value ones
for (let host of hosts) {
if (tarIndex > targets.length - 1) { tarIndex = 0; loop = true };
let target = targets[tarIndex][1];
function fRam() { return info('MR', host[1]) - info('UR', host[1]) }
if (info('MA', target) < info('MM', target) * .80) { hType = 0 }
else if (info('SL', target) > info('MSL', target) + 5 || loop) {
hType = 1;
if (fRam() / info('MR', host[1]) > .13 && fRam() > 4) {
tmp = Math.floor(fRam() / 1.75); if (tmp > 0) { ns.exec(files[1], host[1], tmp, target) }
}
} else {
hType = 2; for (let h of hosts) { if (ns.isRunning(files[2], h[1], target) && h[1] != host[1]) { hType = 0; break } }
if (hType == 2 && !ns.scriptRunning(files[2], host[1])) {
if (fRam() < 2) { ns.killall(host[1]) }
tmp = [1, Math.floor(fRam() / 1.7)]; while (ns.hackAnalyze(target) * tmp[0] < .7 && tmp[0] < tmp[1]) { tmp[0]++ }
ns.exec(files[2], host[1], tmp[0], target)
}
}
if ((hType == 0 || hType == 2) && fRam() > 3.9) {
tmp = [Math.ceil(info('MR', host[1]) / 1.75 * .14), Math.floor(info('MR', host[1]) / 1.75 * .79)]
if (tmp[1] > 0 && fRam() / info('MR', host[1]) >= .80) { ns.exec(files[0], host[1], tmp[1], target) }
if (tmp[0] > 0 && fRam() / info('MR', host[1]) >= .15) { ns.exec(files[1], host[1], tmp[0], target) }
}
if (!loop) { if (hType == 0) { act[target] = 'G' }; if (hType == 1) { act[target] = 'W' }; if (hType == 2) { act[target] = 'H' }; }
tarIndex++;
}
}
//MODULES BELOW HERE
netManager = await ns.prompt('Activate Hacknet Manager?');
async function hnManager() {
if (checkM(ns.hacknet.getPurchaseNodeCost(), 20)) { ns.hacknet.purchaseNode() }
for (let i = 0; i < ns.hacknet.numNodes(); i++) {
for (let part of ['Level', 'Ram', 'Core']) {
if (checkM(ns.hacknet['get' + part + 'UpgradeCost'](i), 20)) {
ns.hacknet['upgrade' + part](i);
}
}
}
}
serverManager = await ns.prompt('Activate Player Server Manager?');
async function pServerManager() {
let ram = 0; let ramList = [8]; for (let num of ramList) {
if (num <= 1048576 && checkM(ns.getPurchasedServerCost(num), 20)) { ramList.push(num * 2); ram = num; } else { break };
}
function buyServer(r) { ns.purchaseServer('SERVER-' + ns.nFormat(r * 1000000000, '0.0b'), r) }
if (ns.getPurchasedServers().length < 25 && ram > 0) { buyServer(ram) }
for (let i = ns.getPurchasedServers().length - 1; i >= 0; i--) {
tmp = ns.getPurchasedServers()[i]
if (info('MR', tmp) < ram && checkM(ns.getPurchasedServerCost(ram), 20) && !exclude.includes(tmp)) {
ns.killall(tmp); ns.deleteServer(tmp); buyServer(ram);
}
}
}
//MODULES ABOVE HERE
ns.tail()
while (true) {//Keeps everything running once per second
servers = []; targets = []; hosts = [[Math.max(info('MR', 'home') - 50, 0), 'home']]; exes = []
tarIndex = 0; loop = false; act = {}
await scanExes()
await scanServers('', 'home')
await hackAll()
if (netManager) { await hnManager() }
if (serverManager) { await pServerManager() }
log()
await ns.asleep(1000)
}}

/** @param {NS} ns**/
export async function main(ns) {
ns.disableLog("ALL"); //Visual clarity

//Welcome to the Auto Farm part 2: Electric Boogaloo
//This script is a little more complicated to explain easily, it dedicates high RAM servers to attack high profit servers
//This is also set and forget, your EXEs and hacking level are reacquired each second, so new servers are added without needing to reboot it
//Well I hope this brings you ideas, knowledge and or profits :D

var files = ["grow.script", "weak.script", "hack.script"];//I advise against modifying the scripts
await ns.write(files[0], "grow(args)", "w"); await ns.write(files[1], "weaken(args)", "w"); await ns.write(files[2], "hack(args)", "w");

var serverList; var targetList; var hostList; var exes; var temp;
var netManager = false; var serverManager = false;
var cycle = [0, "▄", "█", "▀", "█"]; var latest = [["-", "-"], ["-", "-"], ["-", "-"]];
if (false) { brutessh(); ftpcrack(); relaysmtp(); httpworm(); sqlinject() } //Avoid RAM cost bypass error

var pServers = await ns.prompt("Use player servers as hosts?");

async function scanExes() {
exes = ["BruteSSH", "FTPCrack", "relaySMTP", "SQLInject", "HTTPWorm"];
for (let i = 0; i <= exes.length - 1; i++) { if (!ns.fileExists(exes[i] + ".exe")) { exes.splice(i, 1); i-- } }//Removes EXEs you don't have
}

function str(s) { if (s.length > 14) { return s.substring(0, 14) + "..." } else { return s } }//Truncate long strings
function checkM(c, d) { return eval(c < ns.getPlayer().money / d) }
function arraySort(array) { return array.sort(function (a, b) { return b[0] - a[0] }) }//Sorts nested arrays
function logBalance(server) {//For balance in display
return [ns.nFormat(ns.getServerMoneyAvailable(server), '0a')] + " / " + [ns.nFormat(ns.getServerMaxMoney(server), '0a')]
+ " : " + ns.nFormat(ns.getServerMoneyAvailable(server) / ns.getServerMaxMoney(server), '0%')
}

async function log() {//The display
if (cycle[0] >= 4) { cycle[0] = 0 }; cycle[0]++;//Bounce
ns.clearLog();
ns.print("╔═══╦═╣ HOST ╠════════════════╣ TARGET ╠═╗");
ns.print("║ G ║ " + str(latest[0][0]) + str(latest[0][1]).padStart(34 - str(latest[0][0]).length) + " ║")
ns.print("║ W ║ " + str(latest[1][0]) + str(latest[1][1]).padStart(34 - str(latest[1][0]).length) + " ║")
ns.print("║ H ║ " + str(latest[2][0]) + str(latest[2][1]).padStart(34 - str(latest[2][0]).length) + " ║")
ns.print("║ " + cycle[cycle[0]] + " ╠════════════════════════════════════╣")
if (targetList.length < 6) { ns.print("╚═══╝ ║") } else {
ns.print("╠═══╝ Priority Servers Balance ║")
for (let i = 0; i < 6; i++) {
temp = targetList[i][1];
ns.print("║ > " + temp + logBalance(temp).padStart(36 - temp.length) + " ║")
}
ns.print("╠════════════════════════════════════════╝")
ns.print("║ EXE " + exes.length + "/5 ║ HOSTS " + hostList.length + " ║ TARGETS " + targetList.length)
ns.print("╠═════════════════════════════════════════")
if (netManager) { ns.print("╠═════════╣ Managing " + ns.hacknet.numNodes() + " Hacknet Nodes") }
if (serverManager) { ns.print("╠═════════╣ Managing " + ns.getPurchasedServers().length + " Player Servers") }
}
}

async function scanServers() {//Finds all servers
serverList = ns.scan("home"); let serverCount = [serverList.length, 0]; let depth = 0; let checked = 0; let scanIndex = 0;
while (scanIndex <= serverCount[depth] - 1) {
let results = ns.scan(serverList[checked]); checked++;
for (let i = 0; i <= results.length - 1; i++) {
if (results[i] != "home" && !serverList.includes(results[i])) {
serverList.push(results[i]); serverCount[depth + 1]++
}
}
if (scanIndex == serverCount[depth] - 1) { scanIndex = 0; depth++; serverCount.push(0) } else { scanIndex++ };
}
}

async function checkServers() {//Sorts servers into lists based on RAM and money: hostList and targetList
targetList = []; hostList = [[ns.getServerMaxRam("home"), "home"]];
for (let i = 0; i <= serverList.length - 1; i++) {
let cTarget = serverList[i];
if (ns.getServerMaxMoney(cTarget) > 0 || ns.getServerMaxRam(cTarget) > 0) {
temp = ns.getPurchasedServers().includes(cTarget)
if ((ns.getServerNumPortsRequired(cTarget) <= exes.length && !temp) || (temp && pServers)) {
if (!temp) {
for (let i = 0; i <= exes.length - 1; i++) { ns[exes[i].toLowerCase()](cTarget) }//Runs all EXEs you have
ns.nuke(cTarget);//Ghandi.jpeg
}
temp = [Math.floor(ns.getServerMaxMoney(cTarget) / ns.getServerMinSecurityLevel(cTarget)), cTarget];
if (ns.getServerMaxMoney(cTarget) != 0 && ns.getServerRequiredHackingLevel(cTarget) <= ns.getHackingLevel() && ns.getServerMinSecurityLevel(cTarget) < 100) {
targetList.push(temp); targetList = arraySort(targetList);
}
temp = [ns.getServerMaxRam(cTarget), cTarget];
if (ns.getServerMaxRam(cTarget) > 4) {
hostList.push(temp); hostList = arraySort(hostList)
}
await ns.scp(files, "home", cTarget);
}
}
}
}

async function hackAll() {//Dedicates high RAM servers to high value ones
let tarIndex = 0; let loop = false; let hType; let threads; let freeRam;
for (let i = 0; i <= hostList.length - 1; i++) {
if (tarIndex > targetList.length - 1) { tarIndex = 0; loop = true };
let hHost = hostList[i][1]; let hTarget = targetList[tarIndex][1];
async function fRam() {
let f = ns.getServerMaxRam(hHost) - ns.getServerUsedRam(hHost)
if (hHost == "home") { freeRam = Math.max(f - 50, 0) } else { freeRam = f }
}
fRam();
if (ns.getServerMoneyAvailable(hTarget) < ns.getServerMaxMoney(hTarget) * .80) { hType = 0 }
else if (ns.getServerSecurityLevel(hTarget) > ns.getServerMinSecurityLevel(hTarget) + 5 || loop) { hType = 1 } else { hType = 2 }
threads = Math.floor(freeRam / ns.getScriptRam(files[hType]));
if (hType == 2 && !ns.scriptRunning(files[2], hHost)) {
temp = true;
for (let i = 0; i < hostList.length; i++) {
if (ns.isRunning(files[2], hostList[i][1], hTarget) && hostList[i][1] != hHost) { temp = false }
}
if (temp) {
ns.scriptKill(files[0], hHost); ns.scriptKill(files[1], hHost); fRam();
threads = Math.floor(freeRam / ns.getScriptRam(files[hType]));
while (parseFloat(ns.hackAnalyze(hTarget)) * threads > .5) { threads-- }
} else { hType = 0 }
}
if (hType == 0 && freeRam > 4) {
ns.exec(files[1], hHost, Math.ceil(0.17 * threads), hTarget);
threads = Math.floor(0.83 * threads)
}
if (freeRam > 4) { ns.exec(files[hType], hHost, threads, hTarget); latest[hType][0] = hHost; latest[hType][1] = hTarget; }
fRam();
if ((hType == 0 || hType == 1) && freeRam / ns.getServerMaxRam(hHost) > .5) {
ns.scriptKill(files[0], hHost); ns.scriptKill(files[1], hHost)
}
tarIndex++
}
}
//Put modules below here

//But above here
ns.tail()
while (true) {//Keeps everything running once per second
await scanExes()
await scanServers()
await checkServers()
await hackAll()
if (netManager) { await hnManager() }
if (serverManager) { await pServerManager() }
await log()
await ns.asleep(1000)
}
}

netManager = await ns.prompt("Activate Hacknet Manager?");
async function hnManager() {
let mode = ["Level", "Ram", "Core"]
if (checkM(ns.hacknet.getPurchaseNodeCost(), 20)) { ns.hacknet.purchaseNode() }
for (let i = 0; i < ns.hacknet.numNodes(); i++) {
for (let n = 0; n < 3; n++) {
if (checkM(ns.hacknet["get" + mode[n] + "UpgradeCost"](i), 20)) {
ns.hacknet["upgrade" + mode[n]](i);
}
}
}
}

serverManager = await ns.prompt("Auto buy and upgrade player servers?");
async function pServerManager() {
let canAfford = 0; let ram = [8]; for (let i = 0; ram[i] < 1048576; i++) { ram.push(ram[i] * 2) }
for (let i = 0; checkM(ns.getPurchasedServerCost(ram[i]), 20) && i < ram.length; i++) { canAfford = ram[i] }
if (ns.getPurchasedServers().length < 25 && canAfford > 0) { ns.purchaseServer("SERVER-" + ns.nFormat(canAfford * 1000000000, "0.0b"), canAfford) }
for (let i = ns.getPurchasedServers().length - 1; i >= 0; i--) {
temp = ns.getPurchasedServers()[i]
if (ns.getServerMaxRam(temp) < canAfford && checkM(ns.getPurchasedServerCost(canAfford), 20)) {
ns.killall(temp); ns.deleteServer(temp); ns.purchaseServer("SERVER-" + ns.nFormat(canAfford * 1000000000, "0.0b"), canAfford);
}
}
}