/*
Welcome to part 2. I'll only be commenting on things that have changed from the previous part, so if there's something
confusing, be sure to go back and look at part 1 for more detailed explanations.

For part 2, we'll be making a protobatcher. Essentially that means we'll be running our previous version in a constant loop.
To facilitate this, and because otherwise there wouldn't really be much to this part, we're going to refine the way our
scripts communicate with each other using ports.
*/

import { getServers, copyScripts, checkTarget, isPrepped, prep } from "/S2utils.js";

const TYPES = ["hack", "weaken1", "grow", "weaken2"];
const WORKERS = ["S2tHack.js", "S2tWeaken.js", "S2tGrow.js"];
const SCRIPTS = { hack: "S2tHack.js", weaken1: "S2tWeaken.js", grow: "S2tGrow.js", weaken2: "S2tWeaken.js" };
const COSTS = { hack: 1.7, weaken1: 1.75, grow: 1.75, weaken2: 1.75 };
const OFFSETS = { hack: 0, weaken1: 1, grow: 2, weaken2: 3 };

/*
Most of the changes are in the main function, so I've moved it up top. I generally prefer having the main function at the
top of the file anyway.
*/
/** @param {NS} ns */
export async function main(ns) {
  await ns.sleep(500);
	// Moving most of our active feeback to the tail window so that batches finishing don't get swept away.
	ns.disableLog("ALL");
	ns.tail();

	// Stick the whole script in a loop. That's it, see you in part 3.
	// Just kidding, there's a bit more to it.
	let batchCount = 0;
	while (true) {
		// Register a port using the script's unique handle.
		// I like to keep ports strictly coupled to a specific script, but you can use whatever number you like.
		const dataPort = ns.getPortHandle(ns.pid);
		dataPort.clear() // Make sure there's no random data left in the port.

		let target = "n00dles";
		const servers = getServers(ns, (server) => {
			// Don't worry if you don't have Formulas, it's not needed at all here.
			target = checkTarget(ns, server, target, ns.fileExists("Formulas.exe", "home"));
			copyScripts(ns, server, WORKERS, true);
			return ns.hasRootAccess(server);
		});
    //target = "n00dles";
		const ramNet = new RamNet(ns, servers);
		const metrics = new Metrics(ns, target);
		if (!isPrepped(ns, target)) await prep(ns, metrics, ramNet);
		optimizeBatch(ns, metrics, ramNet); // The same optimization algorithm works just fine for protobatching.
		metrics.calculate(ns);

		const batch = [];
		batchCount++;
		for (const type of TYPES) {
			// We've removed the buffer. You'll see why later.
			metrics.ends[type] = Date.now() + metrics.wTime + metrics.spacer * OFFSETS[type];
			const job = new Job(type, metrics);
			job.batch = batchCount; // This is a bit of a hack. We'll do it better in the next part.
			if (!ramNet.assign(job)) {
				ns.print(`ERROR: Unable to assign ${type}. Dumping debug info:`);
				ns.print(job);
				ns.print(metrics);
				ramNet.printBlocks(ns);
				return;
			}
			batch.push(job);
		}

		// We do a bit more during deployment now.
		for (const job of batch) {
			job.end += metrics.delay;
			const jobPid = ns.exec(SCRIPTS[job.type], job.server, { threads: job.threads, temporary: true }, JSON.stringify(job));
			if (!jobPid) throw new Error(`Unable to deploy ${job.type}`); // If the exec fails for any reason, error out.
			/*
			If a worker deploys late, it will communicate back how late it was, so that the other scripts can adjust.
			Note that for this we use the *worker's* port instead of our controller's port. It's good practice to make
			sure your ports have a very narrow focus.
			*/
			const tPort = ns.getPortHandle(jobPid);
			await tPort.nextWrite();
			metrics.delay += tPort.read();
		}

		const timer = setInterval(() => {
			ns.clearLog();
			ns.print(`Hacking \$${ns.formatNumber(metrics.maxMoney * metrics.greed)} from ${metrics.target}`)
			ns.print(`Running batch: ETA ${ns.tFormat(metrics.ends.weaken2 - Date.now())}`);
		}, 1000);
		ns.atExit(() => {
			clearInterval(timer);
		});
		// Wait for the weaken2 worker to report back. For now I've just hardcoded the Job class to tell only
		// weaken2 to report. This behavior will change later.
		await dataPort.nextWrite();
		dataPort.clear(); // For now we don't actually need the information here, we're just using it for timing.
		clearInterval(timer);
	}
}

class Job {
	constructor(type, metrics, server = "none") {
		this.type = type;
		this.end = metrics.ends[type];
		this.time = metrics.times[type];
		this.target = metrics.target;
		this.threads = metrics.threads[type];
		this.cost = this.threads * COSTS[type];
		this.server = server;
		this.report = this.type === "weaken2"; // For now, only w2 jobs report.
		this.port = metrics.port; // This lets the workers know which port to write to.
		this.batch = 0; // We'll keep track of how many we've run, just because we can.
	}
}

/** @param {NS} ns */
class Metrics {
	constructor(ns, server) {
		this.target = server;
		this.maxMoney = ns.getServerMaxMoney(server);
		this.money = Math.max(ns.getServerMoneyAvailable(server), 1);
		this.minSec = ns.getServerMinSecurityLevel(server);
		this.sec = ns.getServerSecurityLevel(server);
		this.prepped = isPrepped(ns, server);
		this.chance = 0;
		this.wTime = 0;
		this.delay = 0; // The cumulative delays caused by late jobs.
		this.spacer = 5;
		this.greed = 0.1;
		this.depth = 0; // Still not using this.

		this.times = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };
		this.ends = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };
		this.threads = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };

		this.port = ns.pid;
	}

	calculate(ns, greed = this.greed) {
		const server = this.target;
		const maxMoney = this.maxMoney;
		this.money = ns.getServerMoneyAvailable(server);
		this.sec = ns.getServerSecurityLevel(server);
		this.wTime = ns.getWeakenTime(server);
		this.times.weaken1 = this.wTime;
		this.times.weaken2 = this.wTime;
		this.times.hack = this.wTime / 4;
		this.times.grow = this.wTime * 0.8;
		this.depth = this.wTime / this.spacer * 4;

		const hPercent = ns.hackAnalyze(server);
		const amount = maxMoney * greed;
		const hThreads = Math.max(Math.floor(ns.hackAnalyzeThreads(server, amount)), 1);
		const tGreed = hPercent * hThreads;
		const gThreads = Math.ceil(ns.growthAnalyze(server, maxMoney / (maxMoney - maxMoney * tGreed)));
		this.threads.weaken1 = Math.max(Math.ceil(hThreads * 0.002 / 0.05), 1);
		this.threads.weaken2 = Math.max(Math.ceil(gThreads * 0.004 / 0.05), 1);
		this.threads.hack = hThreads;
		this.threads.grow = gThreads;
		this.chance = ns.hackAnalyzeChance(server);
	}
}

/** @param {NS} ns */
class RamNet {
	#blocks = [];
	#minBlockSize = Infinity;
	#maxBlockSize = 0;
	#totalRam = 0;
	#maxRam = 0;
	#prepThreads = 0;
	#index = new Map();
	constructor(ns, servers) {
		for (const server of servers) {
			if (ns.hasRootAccess(server)) {
				const maxRam = ns.getServerMaxRam(server);
				const ram = maxRam - ns.getServerUsedRam(server);
				if (ram >= 1.60) {
					const block = { server: server, ram: ram };
					this.#blocks.push(block);
					if (ram < this.#minBlockSize) this.#minBlockSize = ram;
					if (ram > this.#maxBlockSize) this.#maxBlockSize = ram;
					this.#totalRam += ram;
					this.#maxRam += maxRam;
					this.#prepThreads += Math.floor(ram / 1.75);
				}
			}
		}
		this.#sort();
		this.#blocks.forEach((block, index) => this.#index.set(block.server, index));
	}

	#sort() {
		this.#blocks.sort((x, y) => {
			if (x.server === "home") return 1;
			if (y.server === "home") return -1;

			return x.ram - y.ram;
		});
	}

	getBlock(server) {
		if (this.#index.has(server)) {
			return this.#blocks[this.#index.get(server)];
		} else {
			throw new Error(`Server ${server} not found in RamNet.`);
		}
	}

	get totalRam() {
		return this.#totalRam;
	}

	get maxRam() {
		return this.#maxRam;
	}

	get maxBlockSize() {
		return this.#maxBlockSize;
	}

	get prepThreads() {
    		return this.#prepThreads;
  	}

	assign(job) {
		const block = this.#blocks.find(block => block.ram >= job.cost);
		if (block) {
			job.server = block.server;
			block.ram -= job.cost;
			this.#totalRam -= job.cost;
			return true;
		} else return false;
	}

	finish(job) {
		const block = this.getBlock(job.server);
		block.ram += job.cost;
		this.#totalRam += job.cost;
	}

	cloneBlocks() {
		return this.#blocks.map(block => ({ ...block }));
	}

	printBlocks(ns) {
		for (const block of this.#blocks) ns.print(block);
	}
}

/**
 * @param {NS} ns
 * @param {Metrics} metrics
 * @param {RamNet} ramNet
 */
export function optimizeBatch(ns, metrics, ramNet) {
	const maxThreads = ramNet.maxBlockSize / 1.75;
	const maxMoney = metrics.maxMoney;
	const hPercent = ns.hackAnalyze(metrics.target);

	const minGreed = 0.001;
	const stepValue = 0.001;
	let greed = 0.99;
	while (greed > minGreed) {
		const amount = maxMoney * greed;
		const hThreads = Math.max(Math.floor(ns.hackAnalyzeThreads(metrics.target, amount)), 1);
		const tGreed = hPercent * hThreads;
		const gThreads = Math.ceil(ns.growthAnalyze(metrics.target, maxMoney / (maxMoney - maxMoney * tGreed)));

		if (Math.max(hThreads, gThreads) <= maxThreads) {
			const wThreads1 = Math.max(Math.ceil(hThreads * 0.002 / 0.05), 1);
			const wThreads2 = Math.max(Math.ceil(gThreads * 0.004 / 0.05), 1);

			const threadCosts = [hThreads * 1.7, wThreads1 * 1.75, gThreads * 1.75, wThreads2 * 1.75];

			const pRam = ramNet.cloneBlocks();
			let found;
			for (const cost of threadCosts) {
				found = false;
				for (const block of pRam) {
					if (block.ram < cost) continue;
					found = true;
					block.ram -= cost;
					break;
				}
				if (found) continue;
				break;
			}
			if (found) {
				metrics.greed = greed;
				metrics.threads = { hack: hThreads, weaken1: wThreads1, grow: gThreads, weaken2: wThreads2 };
				return true;
			}
		}
		greed -= stepValue;
	}
	throw new Error("Not enough ram to run even a single batch. Something has gone seriously wrong.");
}