myCalc

import * as helpers from "/apis/helpers.js"
import * as myForms from "/apis/myFormulas.js"
/** @param {NS} ns */
export async function main(ns) {
    let hackScript = "/newserver/hack.js";
    let weakenScript = "/newserver/weaken.js";
    let growScript = "/newserver/grow.js";
    let filterList = ["home", "MyServer", "darkweb"];
    let targetMoneyGainPercent = 0.5;
    let unfilteredList = [];

    let servers = await helpers.getAllServers(ns, filterList);
    //ns.tprint(servers);

    //let maxRam = ns.getServerMaxRam(ns.getHostname());
    let maxRam = 8192;
    ns.tprint("Getting ratios and more.")
    //for (let target of servers) {
    //  if (ns.hasRootAccess(target)) {
    //      unfilteredList.push(calcRatio(ns, ns.getServer(target), ns.getPlayer()));
    //  }

        /*
        //calculate how much money can be made in a hack per batch
        let maxMoney = ns.getServerMaxMoney(target);
        let targetMoneyGain = maxMoney * targetMoneyGainPercent;
        //get ratio of needed hack, weaken, grow, weaken
        let coreCount = ns.getServer(ns.getHostname()).cpuCores;
        let hackThreads = Math.ceil(ns.hackAnalyzeThreads(target, targetMoneyGain));
        let hAnalyze = ns.hackAnalyze(target) * hackThreads;
        let growthThreads = Math.ceil((ns.growthAnalyze(target, 2, coreCount)) * ((maxMoney - (hAnalyze * maxMoney)) / (maxMoney - hAnalyze * maxMoney)));
        let weaken1Threads = Math.ceil(hackThreads / 25);
        let weaken2Threads = Math.ceil(growthThreads / 12.5);

        //get total memory used in that ratio
        let scriptMemory = (ns.getScriptRam(hackScript) * hackThreads) +
            (ns.getScriptRam(growScript)* growthThreads) +
            (ns.getScriptRam(weakenScript) * (weaken1Threads + weaken2Threads));

        //figure out how many of those we can run with max memory
        let maxBatches = Math.floor(maxRam / scriptMemory);
        //calculate how much time is spent on the batch
        let hackTime = ns.getHackTime(target)
        let growTime = hackTime*3.2
        let weakenTime = hackTime*4
        //create a ratio of money/timeSpent
        let ratio = targetMoneyGain / hackTime * maxBatches;
        let threadsPerBatch = growthThreads + weaken1Threads + weaken2Threads + hackThreads;
        //ns.tprint("    " + target + " - " + targetMoneyGain + " / " + hackTime + " * " + maxBatches + " = " + ratio + " Total threads - " + threadsPerBatch);
        //return [server, ratio, [hackCount, weakenCount, growCount, weakenCount ]]
        if (hackThreads > 0){
            unfilteredList.push([target,ratio,[hackThreads,weaken1Threads, growthThreads, weaken2Threads, maxBatches]]);
        }
        */
    //}
    /*let sortFilter = [[1, 1]];
    let filteredList = await helpers.sortArray(unfilteredList, sortFilter);
    let data = [["Server", "Income /s", "Threads"]]
    for (let s of filteredList) {
        let name = s[0];
        let dividerA = "";
        data.push([name, s[1].toPrecision(5), s[2].toPrecision(5)]);
    }*/
    let sortFilter = [[1,1],[2, 1]];
    let data = getBestValues(sortFilter,ns);
    //ns.tprint(data);
    columnize(ns, data, 2);
    //@param {Formulas} formulas
}

/** @param {NS} ns @param {Server} server @param {Player} player*/
function calcRatio(ns, server, player) {
    let hackThreads = 1;
    let weakenTime = myForms.weakenTime(server, player);
    //get how much money one thread of hack would get us
    let hackPercent = myForms.hackPercent(server, player);
    let moneyStolen = server.moneyMax * hackPercent;
    //figure out how many grow threads it would take to recover
    let growPercent = myForms.growPercent(server, 1, player, 1);
    let moneyGrown = (server.moneyMax - moneyStolen) * growPercent;
    let growthThreads = moneyStolen / moneyGrown;
    //figure out how many weaken Threads are needed.
    let weakenThreads = (hackThreads / 25) + (growthThreads / 1.25);
    let totalThreads = hackThreads + growthThreads + weakenThreads;
    let incomePerSecond = moneyStolen / (weakenTime / 1000) * myForms.hackChance(server, player);

    return [server.hostname, incomePerSecond, totalThreads, weakenThreads, growthThreads]



}
//Takes an array of arrays and prints them in columns with spacing in between
//example input Array:
/*
    [
        ["Col A", "Col B"],
        ["Something", 23],
        ["More", 999999],
    ]
*/
/** @param {NS} ns @param {Server} server @param {Player} player*/
function columnize(ns, array, spacing) {
    let cols = array[0].length;
    let longest = [];
    //initialize longest for each column as 0
    for (let i = 0; i < cols; i++) {
        longest[i] = 0;
    }
    //ns.tprint(cols);
    for (let s of array) {
        //look for the longest string in each column
        for (let i = 0; i < cols; i++) {
            let entryLength = s[i].toString().length;
            if (entryLength > longest[i]) longest[i] = entryLength;
        }
    }
    //ns.tprint(longest);
    for (let s of array){
        let str = " ";
        for (let i = 0; i < cols; i++) {
            str += s[i].toString();
            //add padding and spacing if not last entry
            if (i < cols - 1){
                let padding = longest[i] - s[i].toString().length;
                for (let p = 0; p < padding + spacing; p++){
                    str += " ";
                }
            }
        }
        ns.tprint(str);
    }
}
/** @param {NS} ns @param {Server} server @param {Player} player*/
function getBestValues(sortArray, ns){
    let servers = ["home"];
    let sInfo = [["Server", "Max Money", "Growth Rate", "Min Security", "Req Hack Level", "Weaken Time"]];
    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));
            if (ns.getServerGrowth(server) > 1){
                sInfo.push([
                    server,
                    ns.nFormat(ns.getServerMaxMoney(server)/2, "(0.00 a)"),
                    ns.getServerGrowth(server),
                    ns.nFormat(ns.getServerMinSecurityLevel(server), "(0.00)"),
                    ns.getServerRequiredHackingLevel(server),
                    ns.tFormat(ns.getHackTime(server) * 4)
                ]);
            }
        }
    }
    for (let sort of sortArray){
        let sortIndex = sort[0];
        let sortOrder = sort[1];
        sInfo = sInfo.sort((a,b) => (b[sortIndex] - a[sortIndex]) * sortOrder);
    }
    //sInfo = sInfo.sort((a,b) => b[4] - a[4]);
    //sort by growth
    //sInfo = sInfo.sort((a,b) => a[2] - b[2]);
    return sInfo
}