server.js

export async function main(ns) {

	/*
	First generate the number of servers to buy from the current vs the maxium. 

	Next get how much money the player has and divide that by how many servers are needed to buy. 

	Then take that number and find the highest tier of server the player can afford and buy 1 of it.

	Repeat the first step if not at maximum. 

	If at maximum, find the lowest ram server and check if a higher tier server can be purchased.

	If a higher tier server can be purchased, delete the lowest ram server.

	Repeat the first step
	*/
	ns.print("Starting...")
	ns.disableLog("disableLog")
	ns.disableLog("sleep");
	ns.disableLog("getPurchasedServerLimit")
	ns.disableLog("getPurchasedServerCost")
	ns.disableLog("getServerMaxRam")
	ns.disableLog("getPurchasedServers")
	ns.disableLog("purchaseServer");
	ns.disableLog("deleteServer");
	
	function ramPrintString(server){
		const ram = ns.getServerMaxRam(server)
		const cost = ns.getPurchasedServerCost(ram)
		return `Server ${server} has ${ns.nFormat(ram * 1000000, '0.00b') } RAM worth ${ns.nFormat(cost, '($ 0.00 a)')}`

	}

	function serversToBuy(servers) {
		const owned_servers_count = servers.length;

		const max_servers_count = ns.getPurchasedServerLimit();

		return max_servers_count - owned_servers_count;
	}

	function ramToPurchase(numberOfServers) {
		const player_money = ns.getPlayer().money;
		const spend_per_server = player_money / numberOfServers;
		let ramTier = 1

		while (spend_per_server > ns.getPurchasedServerCost(Math.pow(2, ramTier))) {
			ramTier++
		}
		ramTier--
		if (ns.getPurchasedServerCost(Math.pow(2, ramTier)) > spend_per_server) {
			ramTier--
		}
		return ramTier
	}

	function serverDeleteCheck(servers) {
		const player_money = ns.getPlayer().money
		const spend_per_server = player_money / ns.getPurchasedServerLimit()
		
		for (let i = 0; i < servers.length; i++) {
			if (ns.getPurchasedServerCost(ns.getServerMaxRam(servers[i])) <= spend_per_server) {
				
				return true;
				
			}
		}
		return false
	}

	function lowestRAMServer(servers) {
		if( servers.every(val => ns.getServerMaxRam(val) === ns.getServerMaxRam(servers[0]))){
			return servers[0]
		}
		const ramArr = servers.map(server => ns.getServerMaxRam(server))
        const lowestRAM = Math.min(...ramArr)
		const index = ramArr.indexOf(lowestRAM)
		ns.print(`Deleting at index ${index}:  ${ramPrintString(servers[index])}`)
		return servers[index];
	}

	let purchases = 0;
	let delflag = false;
	ns.clearLog()
	while (true) {
	
		const owned_servers = ns.getPurchasedServers()

		const num_servers = serversToBuy(owned_servers);

		const ramTier = ramToPurchase(num_servers);
		



		if(serverDeleteCheck(owned_servers) && (num_servers === 0)){
			ns.killall(lowestRAMServer(owned_servers));
			ns.deleteServer(lowestRAMServer(owned_servers));
			delflag = true
		}

		if(delflag || num_servers > 0){
			ns.purchaseServer(`Server${purchases}`, Math.pow(2, ramTier));
			if (ns.serverExists(`Server${purchases}`)) {
				ns.print(`Purchased: ${ramPrintString(`Server${purchases}`)}`)
				purchases++
			}
		}
		


		await ns.sleep(1000);
		delflag = false;
	}



}