import { tokenize } from "./modules/lexer.js";
import { shunt } from "./modules/parser.js";

function xgcd(a, b) {
	let [old_r, r] = [a, b];
	let [old_s, s] = [1n, 0n];
	let [old_t, t] = [0n, 1n];

	while (r !== 0n) {
		const quotient = old_r / r;
		[old_r, r] = [r, old_r - quotient * r];
		[old_s, s] = [s, old_s - quotient * s];
		[old_t, t] = [t, old_t - quotient * t];
	}

	return [old_r, old_s, old_t];
}

function modinv(x, modulus) {
	let [r, s, t] = xgcd(x, modulus);
	if (r !== 1n) {
		throw new Error(`no inverse exists - ${x} and ${modulus} are not coprime`);
	}

	if (s < 0n) {
		s += modulus;
	}

	return s;
}

function modpow(base, exponent, modulus) {
	if (exponent < 0n) {
		const p = modpow(base, -exponent, modulus);
		return modinv(p, modulus);
	}

	if (modulus === 1n) {
		return 0n;
	}

	let result = 1n;
	base %= modulus;

	while (exponent > 0) {
		if (exponent % 2n === 1n) {
			result *= base;
			result %= modulus;
		}

		exponent >>= 1n;
		base *= base;
		base %= modulus;
	}

	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 === "^") {
			// FIXME: not always valid - consider 2^3^4 mod 7
			// also 2^(3+4)
			// solution might be to change parser
			// might also be better to just mod once at the end
			// instead of with every op
			const [a, b] = binaryOpPop(stack);
			const c = modpow(a, b, modulus);
			stack.push(c);
		}
	}

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

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

	return result;
}

function calculate() {
	const expr = document.querySelector("#expr");
	const modulus = document.querySelector("#modulus");
	const m = BigInt(modulus.value);

	const tokens = tokenize(expr.value);
	console.log(tokens);

	const result = document.querySelector("#result");
	let queue = [];
	try {
		queue = shunt(tokens);
	} catch(e) {
		result.value = e;
		console.log(e);
		return;
	}

	console.log(queue);

	let r = 0;
	try {
		r = compute(queue, m);
	} catch(e) {
		result.value = e;
		console.log(e);
		return;
	}

	result.value = r;
}

let currentInput = null;
let selectionStart = null;
let selectionEnd = null;

function setCurrentInput() {
	currentInput = this;
	selectionStart = this.selectionStart;
	selectionEnd = this.selectionEnd;
}

function clear() {
	currentInput.value = "";
	currentInput.focus();
}

function keyPress(c) {
	// FIXME not working with modulus
	// errors in logs on each key press
	// wonder if it's an issue with it being a number type
	currentInput.focus();
	const begin = currentInput.value.slice(0, selectionStart);
	const end = currentInput.value.slice(selectionEnd);
	currentInput.value = begin + c + end;
	currentInput.setSelectionRange(selectionStart+1, selectionStart+1);
}

function backspace() {
	currentInput.focus();
	if (selectionEnd === 0) {
		return;
	}

	let begin = null;
	if (selectionStart === selectionEnd) {
		begin = currentInput.value.slice(0, selectionStart-1);
	} else {
		begin = currentInput.value.slice(0, selectionStart);
	}

	const end = currentInput.value.slice(selectionEnd);

	currentInput.value = begin + end;

	if (selectionStart === 0) {
		currentInput.setSelectionRange(0, 0);
	} else if (selectionStart === selectionEnd) {
		currentInput.setSelectionRange(selectionStart-1, selectionStart-1);
	} else {
		currentInput.setSelectionRange(selectionStart, selectionStart);
	}
}

document.querySelector("#expr").addEventListener("focus", setCurrentInput);
document.querySelector("#modulus").addEventListener("focus", setCurrentInput);

document.querySelector("#zero").addEventListener("click", () => keyPress("0"));
document.querySelector("#one").addEventListener("click", () => keyPress("1"));
document.querySelector("#two").addEventListener("click", () => keyPress("2"));
document.querySelector("#three").addEventListener("click", () => keyPress("3"));
document.querySelector("#four").addEventListener("click", () => keyPress("4"));
document.querySelector("#five").addEventListener("click", () => keyPress("5"));
document.querySelector("#six").addEventListener("click", () => keyPress("6"));
document.querySelector("#seven").addEventListener("click", () => keyPress("7"));
document.querySelector("#eight").addEventListener("click", () => keyPress("8"));
document.querySelector("#nine").addEventListener("click", () => keyPress("9"));

document.querySelector("#plus").addEventListener("click", () => keyPress("+"));
document.querySelector("#minus").addEventListener("click", () => keyPress("-"));
document.querySelector("#times").addEventListener("click", () => keyPress("*"));
document.querySelector("#divide").addEventListener("click", () => keyPress("/"));

document.querySelector("#lparen").addEventListener("click", () => keyPress("("));
document.querySelector("#rparen").addEventListener("click", () => keyPress(")"));

document.querySelector("#pow").addEventListener("click", () => keyPress("^"));

document.querySelector("#clear").addEventListener("click", clear);
document.querySelector("#enter").addEventListener("click", calculate);

document.querySelector("#backspace").addEventListener("click", backspace);

// TODO implement square root and inverse keys