// In-app dialog tests: the shared alert/confirm/prompt modal, its promise
// queue and the native fallback.  Mirrors the ram_batch harness (extractFunc
// from index.html, a sandbox built with new Function, an els map and a
// document stub).

const { test } = require('node:test');
const assert = require('node:assert');
const fs = require('node:fs');
const path = require('node:path');

const html = fs.readFileSync(path.join(__dirname, '..', 'index.html'), 'utf8');

function extractFunc(src, name) {
	const re = new RegExp('function\\s+' + name + '\\s*\\([^)]*\\)\\s*\\{');
	const m = re.exec(src);
	if (!m) throw new Error('function ' + name + ' not found');
	let i = m.index + m[0].length - 1;
	let depth = 0;
	for (; i < src.length; i++) {
		if (src[i] === '{') depth++;
		else if (src[i] === '}') {
			depth--;
			if (depth === 0) break;
		}
	}
	return src.slice(m.index, i + 1);
}

let code = '';
for (const fn of ['pysimAlert', 'pysimConfirm', 'pysimPrompt', '_pysimDialogShow',
	'_pysimDialogNow', '_pysimDialogRun', 'pysimDialogAnswer', '_pysimDialogKeydown']) {
	code += extractFunc(html, fn) + '\n';
}

const els = {};
function setEl(id, value) {
	els[id] = {
		id: id, value: value === undefined ? '' : value, textContent: '', innerHTML: '',
		disabled: false, style: {}, focused: false, selected: false,
		classes: {},
		classList: {
			add(c) { els[id].classes[c] = true; },
			remove(c) { delete els[id].classes[c]; },
			toggle(c, on) { if (on) els[id].classes[c] = true; else delete els[id].classes[c]; },
			contains(c) { return !!els[id].classes[c]; },
		},
		focus() { els[id].focused = true; },
		select() { els[id].selected = true; },
	};
	return els[id];
}
function clearEls() {
	for (const k of Object.keys(els)) delete els[k];
}
// The five elements the dialog touches.
function setDialogEls() {
	for (const id of ['pysim-dialog-modal', 'pysim-dialog-message', 'pysim-dialog-input',
		'pysim-dialog-cancel', 'pysim-dialog-ok']) setEl(id, '');
}

// The document stub records the keydown listener, so the tests exercise the
// open/close wiring instead of calling the handler directly.
const listeners = {};
const documentStub = {
	getElementById: id => els[id] || null,
	activeElement: null,
	addEventListener: (type, fn) => { (listeners[type] = listeners[type] || []).push(fn); },
	removeEventListener: (type, fn) => {
		const a = listeners[type] || [];
		const i = a.indexOf(fn);
		if (i >= 0) a.splice(i, 1);
	},
};
function pressKey(key, extra) {
	const ev = Object.assign({ key: key, preventDefault() {} }, extra || {});
	for (const fn of (listeners['keydown'] || []).slice()) fn(ev);
}
const tick = () => new Promise(r => setImmediate(r));

const app = new Function('els', 'document', `
	var sandbox = { alerts: [], confirms: [], prompts: [], confirmAnswer: true, promptAnswer: '' };
	var alert = m => sandbox.alerts.push(String(m));
	var confirm = m => { sandbox.confirms.push(String(m)); return sandbox.confirmAnswer; };
	var prompt = (m, v) => { sandbox.prompts.push([String(m), v]); return sandbox.promptAnswer; };
	var _pysimDialogQueue = Promise.resolve();
	var _pysimDialogResolve = null;
	var _pysimDialogKind = null;
	var _pysimDialogOpenedAt = 0;
	${code}
	sandbox.pysimAlert = pysimAlert;
	sandbox.pysimConfirm = pysimConfirm;
	sandbox.pysimPrompt = pysimPrompt;
	sandbox.pysimDialogAnswer = pysimDialogAnswer;
	sandbox.getOpenedAt = () => _pysimDialogOpenedAt;
	return sandbox;
`)(els, documentStub);

test('pysimAlert sets the message, hides Cancel and resolves on OK', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	const p = app.pysimAlert('Hello');
	await tick();
	assert.strictEqual(els['pysim-dialog-message'].textContent, 'Hello');
	assert.ok(els['pysim-dialog-modal'].classes['hidden'] === undefined);
	assert.ok(els['pysim-dialog-cancel'].classes['hidden']);      // an alert has no Cancel
	assert.ok(els['pysim-dialog-input'].classes['hidden']);       // and no input
	assert.strictEqual((listeners.keydown || []).length, 1);      // the keydown listener is armed
	app.pysimDialogAnswer(true);
	assert.ok(els['pysim-dialog-modal'].classes['hidden']);
	assert.strictEqual(await p, undefined);
});

test('pysimConfirm resolves true on OK and false on Cancel/Escape', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	let p = app.pysimConfirm('Sure?');
	await tick();
	assert.ok(els['pysim-dialog-cancel'].classes['hidden'] === undefined);
	app.pysimDialogAnswer(true);
	assert.strictEqual(await p, true);
	// the Cancel button
	p = app.pysimConfirm('Sure?');
	await tick();
	app.pysimDialogAnswer(false);
	assert.strictEqual(await p, false);
	// Escape cancels
	p = app.pysimConfirm('Sure?');
	await tick();
	pressKey('Escape');
	assert.strictEqual(await p, false);
	// Enter accepts
	p = app.pysimConfirm('Sure?');
	await tick();
	pressKey('Enter');
	assert.strictEqual(await p, true);
});

test('pysimPrompt prefills the default, returns the typed value or null', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	let p = app.pysimPrompt('Name?', 'default');
	await tick();
	assert.ok(els['pysim-dialog-input'].classes['hidden'] === undefined);
	assert.strictEqual(els['pysim-dialog-input'].value, 'default');
	assert.ok(els['pysim-dialog-input'].focused);                 // the input is focused
	assert.ok(els['pysim-dialog-input'].selected);                // with its text selected
	els['pysim-dialog-input'].value = 'typed';
	app.pysimDialogAnswer(true);
	assert.strictEqual(await p, 'typed');
	// Cancel discards the typed value
	p = app.pysimPrompt('Name?', 'default');
	await tick();
	els['pysim-dialog-input'].value = 'typed';
	app.pysimDialogAnswer(false);
	assert.strictEqual(await p, null);
	// Escape is a cancel too
	p = app.pysimPrompt('Name?', 'x');
	await tick();
	pressKey('Escape');
	assert.strictEqual(await p, null);
});

test('overlapping calls queue in order (one dialog at a time)', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	let firstDone = false;
	let secondDone = false;
	const p1 = app.pysimAlert('first');
	p1.then(() => { firstDone = true; });
	const p2 = app.pysimConfirm('second');
	p2.then(() => { secondDone = true; });
	await tick();
	// only the first is open; the second waits
	assert.strictEqual(els['pysim-dialog-message'].textContent, 'first');
	assert.ok(els['pysim-dialog-cancel'].classes['hidden']);
	assert.ok(!firstDone && !secondDone);
	app.pysimDialogAnswer(true);
	await tick();
	// the second opens now, with its own message and Cancel
	assert.strictEqual(els['pysim-dialog-message'].textContent, 'second');
	assert.ok(els['pysim-dialog-cancel'].classes['hidden'] === undefined);
	assert.ok(firstDone && !secondDone);
	app.pysimDialogAnswer(false);
	assert.strictEqual(await p2, false);
});

test('a second answer after the dialog resolved is a no-op', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	const p = app.pysimConfirm('once');
	await tick();
	app.pysimDialogAnswer(true);
	app.pysimDialogAnswer(false);          // must not change the settled result
	assert.strictEqual(await p, true);
	// the keydown listener is removed when the dialog closes
	assert.strictEqual((listeners.keydown || []).length, 0);
});

test('without the modal the native dialogs are used', async () => {
	clearEls();                            // no #pysim-dialog-modal in the els map
	listeners.keydown = [];
	app.alerts = [];
	app.confirms = [];
	app.prompts = [];
	app.confirmAnswer = true;
	app.promptAnswer = 'native';
	assert.strictEqual(await app.pysimAlert('A'), undefined);
	assert.deepStrictEqual(app.alerts, ['A']);
	assert.strictEqual(await app.pysimConfirm('C'), true);
	assert.deepStrictEqual(app.confirms, ['C']);
	app.confirmAnswer = false;
	assert.strictEqual(await app.pysimConfirm('C2'), false);
	assert.strictEqual(await app.pysimPrompt('P', 'def'), 'native');
	assert.deepStrictEqual(app.prompts, [['P', 'def']]);
	assert.strictEqual((listeners.keydown || []).length, 0);
});

test('Enter with the Cancel button focused cancels', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = els['pysim-dialog-cancel'];
	const p = app.pysimConfirm('Cancel focus?');
	await tick();
	pressKey('Enter');
	assert.strictEqual(await p, false);
	documentStub.activeElement = null;
});

test('a repeated Enter does not answer a queued dialog', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = null;
	const p1 = app.pysimConfirm('first');
	const p2 = app.pysimConfirm('second');
	await tick();
	pressKey('Enter', { repeat: true });          // a held key: ignored
	pressKey('Enter', { repeat: true });
	assert.strictEqual(els['pysim-dialog-message'].textContent, 'first');
	assert.ok(els['pysim-dialog-modal'].classes['hidden'] === undefined);
	pressKey('Enter');                            // a real press answers it
	await tick();
	assert.strictEqual(await p1, true);
	assert.strictEqual(els['pysim-dialog-message'].textContent, 'second');
	app.pysimDialogAnswer(true);
	assert.strictEqual(await p2, true);
});

test('an event answer inside the grace window is ignored, a later one is accepted', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = null;
	const p = app.pysimConfirm('grace');
	await tick();
	// a pointer answer within the grace window: ignored (a double-click's 2nd
	// click on the freshly opened dialog)
	app.pysimDialogAnswer(true, { type: 'click', timeStamp: app.getOpenedAt() + 50 });
	assert.ok(els['pysim-dialog-modal'].classes['hidden'] === undefined);
	// a programmatic answer without an event is never ignored
	app.pysimDialogAnswer(true);
	assert.strictEqual(await p, true);
	// a keyboard answer is never grace-checked (a deliberate Enter must work)
	const p2 = app.pysimConfirm('keyboard');
	await tick();
	app.pysimDialogAnswer(false, { type: 'keydown', timeStamp: app.getOpenedAt() + 5 });
	assert.strictEqual(await p2, false);
	// a pointer answer outside the window: accepted
	const p3 = app.pysimConfirm('later');
	await tick();
	app.pysimDialogAnswer(false, { type: 'click', timeStamp: app.getOpenedAt() + 600 });
	assert.strictEqual(await p3, false);
});

// The dialog's own controls, in tab order; the trap must cycle them.
const FOCUS_IDS = ['pysim-dialog-cancel', 'pysim-dialog-input', 'pysim-dialog-ok'];
function resetFocus() { for (const id of FOCUS_IDS) if (els[id]) els[id].focused = false; }
function focusedIds() { return FOCUS_IDS.filter(id => els[id] && els[id].focused); }
function tab(extra) {
	resetFocus();
	let prevented = false;
	pressKey('Tab', Object.assign({ preventDefault: () => { prevented = true; } }, extra || {}));
	return prevented;
}

test('Tab cycles the dialog controls and cannot leave the modal', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = null;
	const p = app.pysimConfirm('trap');
	await tick();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-ok']);   // the default focus
	// the browser's own focus move is suppressed
	assert.ok(tab(), 'Tab must be handled, not left to the browser');
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-cancel']);  // wraps to the first
	documentStub.activeElement = els['pysim-dialog-cancel'];
	assert.ok(tab());
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-ok']);
	// Shift+Tab walks back
	documentStub.activeElement = els['pysim-dialog-ok'];
	assert.ok(tab({ shiftKey: true }));
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-cancel']);
	// a focus that escaped the dialog is pulled back in
	documentStub.activeElement = null;
	assert.ok(tab());
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-cancel']);
	documentStub.activeElement = null;
	assert.ok(tab({ shiftKey: true }));
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-ok']);
	app.pysimDialogAnswer(true);
	await p;
});

test('the trap follows the dialog kind (alert: OK only, prompt: Cancel/input/OK)', async () => {
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = null;
	// an alert has a single control: Tab stays on it
	let p = app.pysimAlert('only ok');
	await tick();
	documentStub.activeElement = els['pysim-dialog-ok'];
	tab();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-ok']);
	app.pysimDialogAnswer(true);
	await p;
	// a prompt: Cancel -> input -> OK -> Cancel
	clearEls();
	setDialogEls();
	listeners.keydown = [];
	documentStub.activeElement = null;
	p = app.pysimPrompt('q', 'v');
	await tick();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-input']);
	documentStub.activeElement = els['pysim-dialog-input'];
	tab();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-ok']);
	documentStub.activeElement = els['pysim-dialog-ok'];
	tab();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-cancel']);
	documentStub.activeElement = els['pysim-dialog-cancel'];
	tab();
	assert.deepStrictEqual(focusedIds(), ['pysim-dialog-input']);
	app.pysimDialogAnswer(true);
	await p;
});

test('a missing inner element falls back to the native dialog', async () => {
	clearEls();
	// the modal and every element but the OK button exist
	for (const id of ['pysim-dialog-modal', 'pysim-dialog-message', 'pysim-dialog-input',
		'pysim-dialog-cancel']) setEl(id, '');
	listeners.keydown = [];
	app.alerts = [];
	app.confirms = [];
	app.confirmAnswer = false;
	assert.strictEqual(await app.pysimConfirm('C'), false);
	assert.deepStrictEqual(app.confirms, ['C']);
	assert.strictEqual(await app.pysimAlert('A'), undefined);
	assert.deepStrictEqual(app.alerts, ['A']);
	assert.strictEqual((listeners.keydown || []).length, 0);
});

test('the dialog markup and the helpers exist in index.html', () => {
	assert.match(html, /<div id="pysim-dialog-modal"[^>]*role="dialog"[^>]*aria-modal="true"[^>]*class="fixed inset-0 bg-black\/50 z-50 flex items-center justify-center hidden">/);
	assert.match(html, /id="pysim-dialog-message"/);
	assert.match(html, /id="pysim-dialog-input"[^>]*type="text"/);
	assert.match(html, /id="pysim-dialog-cancel"[^>]*onclick="pysimDialogAnswer\(false, event\)"[^>]*data-l10n="Cancel"/);
	assert.match(html, /id="pysim-dialog-ok"[^>]*onclick="pysimDialogAnswer\(true, event\)"[^>]*data-l10n="OK"/);
	for (const fn of ['pysimAlert', 'pysimConfirm', 'pysimPrompt', '_pysimDialogShow',
		'pysimDialogAnswer', '_pysimDialogKeydown']) {
		assert.ok(html.includes('function ' + fn), 'missing ' + fn);
	}
});

test('every dialog class exists in the prebuilt stylesheet', () => {
	// The stale-style trap: style.css is a prebuilt Tailwind output, so a
	// class used only in index.html has no rule until `npm run build` runs.
	// Tailwind escapes ':', '/' and the bracket characters in the selectors;
	// stripping the backslashes mirrors the class names as written.
	const css = fs.readFileSync(path.join(__dirname, '..', 'style.css'), 'utf8').replace(/\\/g, '');
	const start = html.indexOf('<div id="pysim-dialog-modal"');
	assert.ok(start > 0, 'the dialog markup is missing');
	const block = html.slice(start, html.indexOf('<script>', start));
	const classes = new Set();
	for (const m of block.matchAll(/class="([^"]+)"/g)) {
		for (const c of m[1].split(/\s+/)) if (c) classes.add(c);
	}
	assert.ok(classes.size >= 10, 'expected the dialog classes, got ' + classes.size);
	// Escape regex metacharacters and anchor the class end, so `.mx-4` cannot
	// be satisfied by a `.mx-40` rule (a substring check would accept it).
	const selRe = c => new RegExp('\\.' + c.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&') + '(?![\\w-])');
	for (const c of classes) {
		assert.match(css, selRe(c), 'missing stylesheet rule for .' + c);
	}
});

// A pure comment line is prose, not a call: "... with its prompt (v3.6.38)"
// must not trip the space-tolerant scan below.
function isCommentLine(line) {
	const t = line.trim();
	return t.startsWith('//') || t.startsWith('*') || t.startsWith('/*');
}

test('no native dialog call site is left outside the fallback branch', () => {
	// The sweep moved every alert/confirm/prompt call site onto the helpers.
	// Only the intentional native fallback inside _pysimDialogRun and the PWA
	// install prompt (deferredPrompt.prompt()) may remain; a future bare call
	// names its line in the failure message.
	const lines = html.split('\n');
	const start = lines.findIndex(l => l.includes('function _pysimDialogRun('));
	assert.ok(start > 0, '_pysimDialogRun is missing');
	const end = lines.findIndex((l, i) => i > start && /^function /.test(l));
	assert.ok(end > start, 'the end of _pysimDialogRun is missing');
	const fallback = lines.slice(start, end).join('\n');
	assert.match(fallback, /\balert\(/, 'the native alert fallback is missing');
	assert.match(fallback, /\bconfirm\(/, 'the native confirm fallback is missing');
	assert.match(fallback, /\bprompt\(/, 'the native prompt fallback is missing');
	// catch a qualified native (window.alert / globalThis.confirm) and a
	// space before '(' too
	const re = /(?<![\w.])(?:(?:window|globalThis)\.)?(alert|confirm|prompt)\s*\(/;
	const violations = [];
	const missingAwait = [];
	lines.forEach((line, i) => {
		if (re.test(line) && !(i >= start && i < end) &&
			!line.includes('deferredPrompt.prompt()') && !isCommentLine(line)) {
			violations.push((i + 1) + ': ' + line.trim());
		}
		// A missing await is the dangerous case: a Promise is always truthy,
		// so `if (pysimConfirm(x))` would silently never fire the guard.
		for (const fn of ['pysimConfirm', 'pysimPrompt']) {
			if (!new RegExp('\\b' + fn + '\\s*\\(').test(line)) continue;
			if (new RegExp('function\\s+' + fn + '\\s*\\(').test(line)) continue;
			if (new RegExp('await\\s+' + fn + '\\s*\\(').test(line)) continue;
			missingAwait.push((i + 1) + ': ' + line.trim());
		}
	});
	assert.deepStrictEqual(violations, [],
		'bare native dialog calls left outside _pysimDialogRun:\n' + violations.join('\n'));
	assert.deepStrictEqual(missingAwait, [],
		'pysimConfirm/pysimPrompt calls without await:\n' + missingAwait.join('\n'));
});