import { crack } from "crack.js";
/** @param {NS} ns */
function printHelp(ns) {
    ns.tprint(
        "This is a core script which handles basic node (or server/host) operations.\n" +
        "Some functions are available via an API, some are only available through\n" +
        "the command line interface.\n\n" +
        "API REFERENCE:\n" + 
        "isHackable(ns, node): boolean\n"
    );
}

/** @param {NS} ns */
export async function totalAvailableThreads(ns, script) {
    var nodes = await getNodes(ns);
    var threads = 0;

    nodes.forEach(function(node) {
        threads += Math.floor(ns.getServerMaxRam(node) / ns.getScriptRam(script));
    });

    return threads;
}

/** @param {NS} ns */
export function isHackable(ns, node) {
    if(node == "" || node == "\n" || node == "home" || node == "darkweb") {
        return false;
    }

    if(node.slice(0, 6) == "server-") {
        return true;
    }

    // Skip servers I cannot hack.
    if(ns.getHackingLevel() < ns.getServerRequiredHackingLevel(node)) {
        return false;
    }

    // Crack if I don't have root access.
    if(!ns.hasRootAccess(node)) {
        if(!crack(ns, node)) {
            return false;
        }
    }
    
    return true;
}

/** @param {NS} ns */
export async function getNodesByRam(ns) {
    let nodes = (await ns.read("nodes.txt")).split("\n");
    const n = nodes.length;

    for (let i = 0; i < n - 1; i++) {
        let swapped = false; // Flag to optimize: if no swaps occur, the array is sorted
    
        for (let j = 0; j < n - i - 1; j++) {
            if (ns.getServerMaxRam(nodes[j]) > ns.getServerMaxRam(nodes[j + 1])) {
                // Swap arr[j] and arr[j+1]
                [nodes[j], nodes[j + 1]] = [nodes[j + 1], nodes[j]]; // Array destructuring for swap
                swapped = true;
            }
        }
    
        // If no two elements were swapped in inner loop, the array is sorted
        if (swapped === false) {
            break;
        }
    }
    nodes = nodes.reverse();
    while(ns.getServerMaxRam(nodes[nodes.length - 1]) == 0) {
        nodes.pop();
    }

    return nodes;
}

/** @param {NS} ns */
export async function getNodesByPriority(ns) {
    const nodes = (await ns.read("nodes.txt")).split("\n");
    const n = nodes.length;

    for (let i = 0; i < n - 1; i++) {
        let swapped = false; // Flag to optimize: if no swaps occur, the array is sorted
    
        for (let j = 0; j < n - i - 1; j++) {
            if (ns.getServerMaxMoney(nodes[j]) > ns.getServerMaxMoney(nodes[j + 1])) {
                // Swap arr[j] and arr[j+1]
                [nodes[j], nodes[j + 1]] = [nodes[j + 1], nodes[j]]; // Array destructuring for swap
                swapped = true;
            }
        }
    
        // If no two elements were swapped in inner loop, the array is sorted
        if (swapped === false) {
            break;
        }
    }
    return nodes.reverse();
}

/** @param {NS} ns */
async function getNodesByHackable(ns) {
    const nodes = (await ns.read("nodes.txt")).split("\n");
    var hackableNodes = [];

    for (let i = 0; i < nodes.length; i++) {
        if(isHackable(ns, nodes[i])) {
            hackableNodes.push(nodes[i]);
        }
    }

    return hackableNodes;
}

/** @param {NS} ns */
export async function getNodes(ns) {
    const nodes = await ns.read("nodes.txt");
    return nodes.split("\n");
}

/** @param {NS} ns */
export function getIdealNode(ns) {
	var nodes = ['home']
	for (var i = 0; i < nodes.length; i++) {
		var node = ns.scan(nodes[i]);
		for (var j = 0; j < node.length; j++) {
			if (nodes.indexOf(node[j]) === -1 && isHackable(ns, node[j])) {
				nodes.push(node[j]);
			}
		}
	}

    var idealNode = "n00dles";
    nodes.forEach(function(n) {
        if(ns.getServerMaxMoney(n) > ns.getServerMaxMoney(idealNode)) {
            idealNode = n;
        }
    });

    return idealNode;
}

/** @param {NS} ns */
async function write(ns, nodes) {
    await ns.write("nodes.txt", "", "w");

    var hackableNodes = [];
    for(var i = 0; i < nodes.length; i++) {
        if(isHackable(ns, nodes[i])) {
            hackableNodes.push(nodes[i]);
        }
    }

    for(var i = 0; i < hackableNodes.length; i++) {
        let text = hackableNodes[i];
        if(i != hackableNodes.length - 1) {
            text += "\n";
        }

        await ns.write("nodes.txt", text, "a");
    }
}

/** @param {NS} ns */
export async function main(ns) {
    var nodes = ['home']
    for (var i = 0; i < nodes.length; i++) {
        var node = ns.scan(nodes[i]);
        for (var j = 0; j < node.length; j++) {
            if (nodes.indexOf(node[j]) === -1) {
                nodes.push(node[j]);
            }
        }
    }

    if(ns.args.length == 0) {
        ns.tprint(nodes);
    } else if(ns.args[0] == "--update" || ns.args[0] == "-u") {
        await write(ns, nodes);

    // Get the ideal node to target.
    } else if(ns.args[0] == "--priority" || ns.args[0] == "-p") {
        ns.tprint("nodes by priority: " + await getNodesByPriority(ns));

    } else if(ns.args[0] == "--hackable" || ns.args[0] == "-ha") {
        var hackableNodes = await getNodesByHackable(ns);
        ns.tprint(hackableNodes.length + " hackable nodes: " + hackableNodes);

    } else if(ns.args[0] == "--help" || ns.args[0] == "-h") {
        printHelp(ns);
        exit();

    // Kill all scripts except on home.
    } else if(ns.args[0] == "--killall" || ns.args[0] == "-k") {
        var nodes = await getNodes(ns);
        nodes.forEach(function(n) {
            ns.killall(n);
        });
    }

    return nodes;
}