import { distributeScript, getGrowThreads, getSetting, sortJsonArrayByKey } from "../Library";

/** @param {NS} ns */
export async function main(ns) {
    ns.tail();
    ns.disableLog("scp");
    const sTarget = ns.args[0]; // target server
    const sHackScript = "RMhack.js";
    const sGrowScript = "RMgrow.js";
    const sWeakenScript = "RMweaken.js";
    const sServerListFile = "serverList.txt";
    const sDistScript = "testdistribute.js";
    const sRunScript = "lowram/Lowrun.js";
    const aFiles = [sHackScript, sGrowScript, sWeakenScript, sServerListFile];

    const nHackScriptRAM = 1.75;
    const nGrowScriptRAM = 1.7;
    const nWeakenScriptRAM = 1.75;

    //target server info
    const nMinSecurity = ns.getServerMinSecurityLevel(sTarget);
    const nMaxMoney = ns.getServerMaxMoney(sTarget);

    const nHomeReserve = getSetting(ns, "homeRAMReserve");

    let bLoop = true;
    while (bLoop) {

        let nWeakenTime = ns.getWeakenTime(sTarget);

        let oServerlist = JSON.parse(ns.read(sServerListFile));
        let sortedList = sortJsonArrayByKey(oServerlist, "serverCores", "maxRam").reverse();

        let nMaxThreads = 0;
        sortedList.forEach((entry) => {
            if (entry.rootAccess && entry.maxRam >= 1) {
                if (entry.serverName !== "home") {
                    ns.scp(aFiles, entry.serverName, "home");
                }
                nMaxThreads += entry.maxRam / 1.75;
            }
        })
        let nMaxThreadsINT = Math.floor(nMaxThreads - 64);
        ns.print("nMaxThreadsINT = " + nMaxThreadsINT);


        let nCurrentSecurity = ns.getServerSecurityLevel(sTarget);
        let nCurrentMoney = ns.getServerMoneyAvailable(sTarget);
        let nGrowBonus = 0;
        if (nCurrentMoney <= nMaxMoney * 0.8) {
            nGrowBonus = 100;
        }
        let nTempHackThreads = 1;
        let nTempGrowThreads = nGrowBonus + getGrowThreads(ns, sTarget, nTempHackThreads, 1);
        let nTempWeakenThreads = 1 + (nTempHackThreads / 25) + (nTempGrowThreads / 12.5);

        //let nBatchSize = nTempHackThreads + nTempGrowThreadsINT + nTempWeakenThreadsINT;
        let nBatchWeight = nTempHackThreads + nTempGrowThreads + nTempWeakenThreads;
        ns.print("nBatchWeight = " + nBatchWeight);

        let nHackWeight = (nTempHackThreads / nBatchWeight);
        let nHGrowWeight = (nTempGrowThreads / nBatchWeight);
        let nWeakenWeight = (nTempWeakenThreads / nBatchWeight);

        ns.print("nHackWeight = " + nHackWeight);
        ns.print("nHGrowWeight = " + nHGrowWeight);
        ns.print("nWeakenWeight = " + nWeakenWeight);

        let nTempHackThreadsINT = Math.ceil(nMaxThreadsINT * nHackWeight);
        let nTempGrowThreadsINT = Math.ceil(nMaxThreadsINT * nHGrowWeight);
        let nTempWeakenThreadsINT = Math.ceil(nMaxThreadsINT * nWeakenWeight);

        ns.print("nTempHackThreadsINT = " + nTempHackThreadsINT);
        ns.print("nTempGrowThreadsINT = " + nTempGrowThreadsINT);
        ns.print("nTempWeakenThreadsINT = " + nTempWeakenThreadsINT);

        ns.print("nWeakenTime = " + nWeakenTime / 1000);

        let nHackThreads = Math.max(1, Math.ceil(nTempHackThreadsINT / (nWeakenTime / 5000)));
        let nGrowThreads = Math.max(1, Math.ceil(nTempGrowThreadsINT / (nWeakenTime / 5000)));
        let nWeakenThreads = Math.max(1, Math.ceil(nTempWeakenThreadsINT / (nWeakenTime / 5000)));

        let nGrowTime = nWeakenTime * 0.8;
        let nHackTime = nWeakenTime / 4;

        let nGrowDelay = nWeakenTime - nGrowTime;
        let nHackDelay = nWeakenTime - nHackTime;

        let nPID1 = ns.run(sDistScript, 1, sHackScript, nHackThreads, sTarget, false, nHackDelay - 100);
        let nPID2 = ns.run(sDistScript, 1, sGrowScript, nGrowThreads, sTarget, false, nGrowDelay - 50);
        let nPID3 = ns.run(sDistScript, 1, sWeakenScript, nWeakenThreads, sTarget, false, 0);
        if (nPID1 === 0 || nPID2 === 0 || nPID3 === 0) { bLoop = false; }

        ns.print("Cash: " + (Math.floor(nCurrentMoney * 1000) / 1000) + " / " + nMaxMoney);
        ns.print("Security: " + (Math.floor(nCurrentSecurity * 1000) / 1000) + " / " + nMinSecurity);

        await ns.sleep(5000);
    }
    await ns.sleep(10000);
    ns.spawn(sRunScript, { threads: 1, spawnDelay: 0 }, sTarget);
}