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

function load(brightness) {
  const source = fs.readFileSync(path.join(__dirname, '../src/main/index.ux'), 'utf8')
    .match(/<script>([\s\S]*?)<\/script>/)[1].replace('export default', 'module.exports =');
  const active = new Map();
  const callbacks = [];
  let next = 0;
  const context = { module: { exports: {} }, Promise, console,
    require: () => ({ default: brightness }),
    setInterval(fn) { callbacks.push(fn); active.set(++next, fn); return next; },
    clearInterval(id) { active.delete(id); } };
  vm.runInNewContext(source, context);
  const page = context.module.exports;
  Object.assign(page, page.data);
  return { page, active, callbacks };
}

test('repeated shows own one renewal; hide and destroy prevent queued wakeups', () => {
  const calls = [];
  const { page, active, callbacks } = load({
    setKeepScreenOn: value => calls.push(['keep', value]),
    wakeScreenOn: value => calls.push(['wake', value.screenOn]) });
  page.onShow(); page.onShow();
  assert.equal(active.size, 1);
  assert.deepEqual(calls, [['keep', true], ['wake', true]]);
  callbacks[0]();
  page.onHide();
  assert.equal(active.size, 0);
  const afterHide = calls.length;
  callbacks[0]();
  assert.equal(calls.length, afterHide);
  page.onShow();
  assert.equal(active.size, 1);
  page.onDestroy();
  assert.equal(active.size, 0);
  const afterDestroy = calls.length;
  for (const callback of callbacks) callback();
  assert.equal(calls.length, afterDestroy);
  assert.deepEqual(calls.at(-1), ['keep', false]);
});

test('destroy releases a visible page even without hide', () => {
  const calls = [];
  const { page, active } = load({ setKeepScreenOn: value => calls.push(value), wakeScreenOn() {} });
  page.onShow(); page.onDestroy();
  assert.deepEqual(calls, [true, false]);
  assert.equal(active.size, 0);
});

test('late rejection cannot overwrite the new visible generation', async () => {
  let rejectOld;
  let first = true;
  const { page } = load({ setKeepScreenOn() {}, wakeScreenOn() {
    if (first) { first = false; return new Promise((_, reject) => { rejectOld = reject; }); }
  } });
  page.onShow(); page.onHide(); page.onShow();
  const status = page.screenStatus;
  rejectOld(new Error('old request'));
  await Promise.resolve(); await Promise.resolve();
  assert.equal(page.screenStatus, status);
  page.onDestroy();
});

test('a missing wake API is reported and does not start renewal', () => {
  const { page, active } = load({ setKeepScreenOn() {} });
  page.onShow();
  assert.equal(active.size, 0);
  assert.equal(page.screenStatus, '固件缺少亮屏接口');
  page.onDestroy();
});

test('a rejected wake stops renewal and remains visible as a failure', async () => {
  const { page, active } = load({ setKeepScreenOn() {},
    wakeScreenOn: () => Promise.reject(new Error('unsupported')) });
  page.onShow();
  await Promise.resolve(); await Promise.resolve();
  assert.equal(active.size, 0);
  assert.equal(page.screenStatus, '固件未接受亮屏');
  page.onDestroy();
});