/*
Copyright (C) 2025 filifa

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
importScripts("./lexer.js", "parser.js", "./math.js")

addEventListener("message", (message) => {
	if (message.data.command === "evaluate") {
		const expr = message.data.expr;
		const modulus = BigInt(message.data.modulus);
		const result = evaluate(expr, modulus);
		postMessage(result);
	}
});

function evaluate(expr, m) {
	if (m <= 0n) {
		throw new Error("invalid modulus");
	}

	const tokens = tokenize(expr);
	console.log(tokens);
	const queue = shunt(tokens);
	console.log(queue);
	const result = compute(queue, m);
	return result;
}

function binaryOpPop(stack) {
	const b = stack.pop();
	const a = stack.pop();
	if (a === undefined || b === undefined) {
		throw new Error("invalid expression");
	}

	return [a, b];
}

function compute(queue, modulus) {
	const stack = [];
	for (const token of queue) {
		if (typeof token === "bigint") {
			stack.push(token);
		} else if (token === "+") {
			let [a, b] = binaryOpPop(stack);
			a %= modulus;
			b %= modulus;
			const c = (a + b) % modulus;
			stack.push(c);
		} else if (token === "-") {
			let [a, b] = binaryOpPop(stack);
			a %= modulus;
			b %= modulus;
			const c = (a - b) % modulus;
			stack.push(c);
		} else if (token === "*") {
			let [a, b] = binaryOpPop(stack);
			a %= modulus;
			b %= modulus;
			const c = (a * b) % modulus;
			stack.push(c);
		} else if (token === "/") {
			let [a, b] = binaryOpPop(stack);
			a %= modulus;
			b %= modulus;
			const binv = modinv(b, modulus);
			const c = (a * binv) % modulus;
			stack.push(c);
		} else if (token === "u") {
			let a = stack.pop();
			if (a === undefined) {
				throw new Error("invalid expression");
			}

			a *= -1n;
			stack.push(a);
		} else if (token === "^") {
			const [a, b] = binaryOpPop(stack);
			const c = modpow(a, b, modulus);
			stack.push(c);
		} else if (token === "sqrt") {
			const a = stack.pop();
			const s = modsqrt(a, modulus);
			stack.push(s);
		} else if (token === "ord") {
			const a = stack.pop();
			const r = ord(a, modulus);
			stack.push(r);
		}
	}

	if (stack.length !== 1) {
		throw new Error("error evaluating expression");
	}

	let result = stack[0] % modulus;
	if (result < 0n) {
		result += modulus;
	}

	return result;
}