/*
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/>.
*/
import { modinv, modpow, modsqrt, ord } from "./math.js";

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;
}

export { compute };