import { isHackable, getNodesByPriority, getNodesByRam } from "getNodes.js";
import { formatMoney } from "formatMoney.js";

var nodes = [];
var workerNodes = [];
var targetIndex = 0;

/**
 * @param {NS} ns
 * @param {string[]} workerNodes
 * @param {string} targetNode
 * @param {string} script
*/
async function distribute(ns, script) {
    /*
    if(script == "hack.js") {
        var hackAmount = ns.hackAnalyze(nodes[targetIndex]); 
        var totalHackAmount = 0;
        for(var i = 0; i < workerNodes.length; i++) {
            var availableThreads = Math.floor(ns.getServerMaxRam(workerNodes[i]) / ns.getScriptRam(script));
            totalHackAmount += hackAmount * availableThreads;

            // This is to ensure that I do not over-hack the target.
            if(totalHackAmount < .5) {
                ns.killall(workerNodes[i]);

                ns.scp(script, workerNodes[i]);
                ns.exec(script, workerNodes[i], availableThreads, nodes[targetIndex]);
            } else {
                if(targetIndex == nodes.length) {
                    ns.tprint("Something really bad has happened...ran out of nodes to hack!");
                    exit();
                }
            }
        }
    } else {
    */
        // Use maximum RAM on all worker nodes.
        for(var i = 0; i < workerNodes.length; i++) {
            ns.killall(workerNodes[i]);
        
            var availableThreads = Math.floor(ns.getServerMaxRam(workerNodes[i]) / ns.getScriptRam(script));
        
            ns.scp(script, workerNodes[i]);
            ns.exec(script, workerNodes[i], availableThreads, nodes[targetIndex]);
        }
    
        // Use 80% of the home server's RAM to execute the script.
        var availableThreads = Math.floor((ns.getServerMaxRam("home") / ns.getScriptRam(script)) * 0.8);
        ns.scriptKill("weaken.js", "home");
        ns.scriptKill("grow.js", "home");
        ns.scriptKill("hack.js", "home");
        ns.run(script, availableThreads, nodes[targetIndex]);
    //}
}

/**
 * @param {NS} ns
*/
async function grow(ns) {
    ns.tprint("distributing grow.js...");
    distribute(ns, "grow.js");
    
    var growTime = ns.getGrowTime(nodes[targetIndex]);
    ns.alert("growing for " + Math.ceil(growTime / 60000) + " minutes");
    await ns.sleep(growTime + 1000);
    ns.alert("finished growing " + nodes[targetIndex] + "\nnow at " + formatMoney(ns.getServerMoneyAvailable(nodes[targetIndex])));
}

/**
 * @param {NS} ns
*/
async function weaken(ns) {
    ns.tprint("distributing weaken.js...");
    distribute(ns, "weaken.js");
    
    var weakenTime = ns.getWeakenTime(nodes[targetIndex]);
    ns.alert("weakening for " + Math.ceil(weakenTime / 60000) + " minutes");
    await ns.sleep(weakenTime + 1000);
    ns.alert("finished weakening " + nodes[targetIndex]);
}

/**
 * @param {NS} ns
 * @param {string[]} workerNodes
 * @param {string} targetNode
*/
async function hack(ns) {
    ns.tprint("distributing hack.js...");
    distribute(ns, "hack.js");
    
    var hackTime = ns.getHackTime(nodes[targetIndex]);
    ns.alert("hacking for " + Math.ceil(hackTime / 60000) + " minutes");
    await ns.sleep(hackTime + 1000);
    ns.alert("finished hacking " + nodes[targetIndex]);
}

/** @param {NS} ns */
export async function main(ns) {
    nodes = await getNodesByPriority(ns);
    workerNodes = await getNodesByRam(ns);

    // Override the default target node to use a user provided one instead.
    if(ns.args.length == 2) {
        if(ns.args[0] == "--target-node" || ns.args[0] == "-tn") {
            if(nodes.indexOf(ns.args[1]) != -1 && isHackable(ns, nodes[ns.args[1]])) {
                targetIndex = nodes.indexOf(ns.args[1]);
            }
        }
    }

    /*
    while(!isHackable(ns, nodes[targetIndex])) {
        targetIndex++;

        if(targetIndex == nodes.length) {
            ns.tprint("No hackable nodes!");
            exit();
        }
    }
    */
    
    // @ignore-infinite
    while(true) {
        nodes = await getNodesByPriority(ns);
        workerNodes = await getNodesByRam(ns);
        let targetNode = nodes[0];

        if(ns.getServerMoneyAvailable(targetNode) != ns.getServerMaxMoney(targetNode)) {
            await grow(ns);
        } else if(ns.getServerSecurityLevel(targetNode) > ns.getServerMinSecurityLevel(targetNode)) {
            await weaken(ns);
        } else {
            await hack(ns);
        }
    }
}