// Rôle : vérifie la frontière entre médias différés, données vides et écritures concurrentes.
import { test } from "node:test";
import assert from "node:assert/strict";
import { DEFERRED_MODULE_DATA as deferred, getDeferredModuleKeys, mergeLoadedModuleData, splitModuleData } from "../website/src/features/toolboxes/storage/deferredModuleData.js";
import { createPersistenceQueue } from "../website/src/features/toolboxes/storage/persistenceQueue.js";

test("only images and annotations are deferred; alert and text tools remain available", () => {
  assert.deepEqual(getDeferredModuleKeys([{ id: "box", modules: [
    { id: "image", type: "images" }, { id: "map", type: "imageAnnotation" },
    { id: "timer", type: "timer" }, { id: "calendar", type: "calendar" },
    { id: "memos", type: "memos" }, { id: "notepad", type: "notepad" }
  ] }]), ["box:image", "box:map"]);
  assert.deepEqual(splitModuleData({ "box:image": deferred, "box:timer": { countdowns: [] } }), {
    stored: { "box:timer": { countdowns: [] } }, deferred: ["box:image"]
  });
});

test("loading never replaces edits or resurrects deleted module data", () => {
  const data = { pending: deferred, missing: deferred, edited: { images: ["new"] } };
  const loaded = mergeLoadedModuleData(data, ["pending", "missing", "edited", "deleted"], [
    { key: "pending", data: { image: "loaded" } }, { key: "edited", data: "old" }, { key: "deleted", data: "old" }
  ]);
  assert.deepEqual(loaded, { pending: { image: "loaded" }, edited: { images: ["new"] } });
  assert.equal(data.pending, deferred);
  assert.equal(data.missing, deferred);
});

for (const failDelete of [false, true]) {
  test(`a load queued during deletion follows its confirmed outcome (failure=${failDelete})`, async () => {
    let finish;
    const transaction = new Promise((resolve) => { finish = resolve; });
    const queue = createPersistenceQueue({ media: deferred }, () => {});
    const removal = queue.enqueue(() => ({}), async () => {
      await transaction;
      if (failDelete) throw new Error("abort");
    });
    const load = queue.enqueue((current) => mergeLoadedModuleData(current, ["media"], [{ key: "media", data: "kept" }]), () => {});
    finish();
    assert.equal(await removal, !failDelete);
    assert.equal(await load, true);
    assert.deepEqual(queue.getCurrent(), failDelete ? { media: "kept" } : {});
  });
}