// Read aloud's routes (server/speak.ts) through the Hono app, over a
// throwaway vault, with a FAKE engine standing in for the Python child: the
// language is detected and reported, the engine is chosen per language, a
// second ask is a cache hit, nothing installed is a 409 that names what to
// install, and a visitor is heard only with "Readers may listen" on, only on
// a published note, and only for words that are on that page.

import assert from "node:assert/strict";
import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
import path from "node:path";
import { after, before, describe, it } from "node:test";
import { Hono } from "hono";
import { initAuth } from "../server/auth.ts";
import { initIndexer } from "../server/indexer.ts";
import { initSite } from "../server/site.ts";
import { initVault, type VaultError } from "../server/vault.ts";
import { api } from "../server/api.ts";
import { getSettings, patchSettings } from "../server/settings.ts";
import { fetchVoice, setFakeEngine, toneWav, type SpeakJob } from "../server/speakEngine.ts";
import { foldForMatch } from "../server/speak.ts";
import { makeDir, makeVault, note, removeVault } from "./helpers/vault.ts";
import type { SpeakStatus } from "../shared/speech.ts";

const VAULT: Record<string, string> = {
  "Carnet.md": note({ lang: "fr" }, "# Carnet\n\nLa grenouille saute dans le jardin.\n"),
  "Public.md": note({ publish: "true" }, "# Public\n\nThe **quick** brown fox reads the [[Paper|evening paper]].\n"),
  "Private.md": note({ publish: "false" }, "# Private\n\nA secret sentence.\n"),
};

const data = makeDir();
const root = makeVault(VAULT);
const app = new Hono();
app.route("/api", api);
const asked: SpeakJob[] = [];
const speak = (body: unknown) =>
  app.request("/api/speak", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });

before(async () => {
  initAuth({}); // local mode: the owner at their own machine
  initSite({ ASTROLABE_DATA: data });
  initVault(root);
  await initIndexer();
  setFakeEngine(async (job) => {
    asked.push(job);
    return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
  }, ["light", "natural"]);
});

after(() => {
  setFakeEngine(null);
  initAuth({});
  removeVault(root);
  removeVault(data);
});

describe("POST /api/speak (the owner)", () => {
  it("speaks, reports the language and the engine, and closes a bare word", async () => {
    asked.length = 0;
    const res = await speak({ text: "図書館" });
    assert.equal(res.status, 200);
    assert.equal(res.headers.get("content-type"), "audio/wav");
    assert.equal(res.headers.get("x-speak-lang"), "ja");
    assert.equal(res.headers.get("x-speak-engine"), "natural");
    assert.equal(res.headers.get("x-speak-cache"), "miss");
    const bytes = new Uint8Array(await res.arrayBuffer());
    assert.equal(String.fromCharCode(...bytes.subarray(0, 4)), "RIFF");
    assert.equal(asked[0].text, "図書館。");
    assert.equal(asked[0].voice, "jf_alpha");
  });

  it("the same words again are a cache hit, and the engine is not asked", async () => {
    asked.length = 0;
    const res = await speak({ text: "図書館" });
    assert.equal(res.headers.get("x-speak-cache"), "hit");
    assert.equal(asked.length, 0);
  });

  it("Arabic goes to Piper whatever the choice; French to the choice", async () => {
    patchSettings({ speak: { engine: "natural" } });
    try {
      const ar = await speak({ text: "المكتبة العامة" });
      assert.equal(ar.headers.get("x-speak-engine"), "light");
      const fr = await speak({ text: "Les enfants ont appris leurs leçons en une heure." });
      assert.equal(fr.headers.get("x-speak-lang"), "fr");
      assert.equal(fr.headers.get("x-speak-engine"), "natural");
    } finally {
      patchSettings({ speak: null });
    }
  });

  it("a lone word takes the note's own lang, then the sentence around it", async () => {
    const byNote = await speak({ text: "jardin", path: "Carnet.md" });
    assert.equal(byNote.headers.get("x-speak-lang"), "fr");
    const byContext = await speak({ text: "grenouille", context: "La grenouille saute dans le jardin de la maison." });
    assert.equal(byContext.headers.get("x-speak-lang"), "fr");
    const bare = await speak({ text: "window" });
    assert.equal(bare.headers.get("x-speak-lang"), "en");
  });

  it("an explicit lang wins, and the owner's voice and rate reach the engine", async () => {
    patchSettings({ speak: { engine: "natural", rate: 0.8, voices: { en: "am_michael" } } });
    try {
      asked.length = 0;
      const res = await speak({ text: "Bonjour", lang: "en" });
      assert.equal(res.headers.get("x-speak-lang"), "en");
      assert.equal(asked[0].voice, "am_michael");
      assert.equal(asked[0].speed, 0.8);
    } finally {
      patchSettings({ speak: null });
    }
  });

  it("refuses empty and oversized text", async () => {
    assert.equal((await speak({ text: "  " })).status, 400);
    assert.equal((await speak({ text: "a".repeat(1001) })).status, 413);
  });

  it("nothing installed that speaks the language is a 409 naming what to install", async () => {
    setFakeEngine(async (job) => ({ audio: toneWav(job.text), mime: "audio/wav", ms: 1 }), ["light"]);
    try {
      const res = await speak({ text: "ありがとう" });
      assert.equal(res.status, 409);
      const body = (await res.json()) as { code: string; lang: string; needs: string };
      assert.deepEqual([body.code, body.lang, body.needs], ["speakNotInstalled", "ja", "natural"]);
    } finally {
      setFakeEngine(async (job) => {
        asked.push(job);
        return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
      }, ["light", "natural"]);
    }
  });

  it("an engine failure is a 502 with its code, and the next request is served", async () => {
    setFakeEngine(async () => {
      throw Object.assign(new Error("boom"), { code: "engine" });
    }, ["light", "natural"]);
    const res = await speak({ text: "A fresh failing sentence." });
    assert.equal(res.status, 502);
    assert.equal(((await res.json()) as { code: string }).code, "engine");
    setFakeEngine(async (job) => ({ audio: toneWav(job.text), mime: "audio/wav", ms: 1 }), ["light", "natural"]);
    assert.equal((await speak({ text: "A fresh failing sentence." })).status, 200);
  });
});

describe("a voice that downloads on choice (Light's Pierre), and a voice of the other engine", () => {
  const pierre = "fr_FR-upmc-medium#pierre";
  const post = (url: string, body: unknown) =>
    app.request(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
  const status = async (): Promise<SpeakStatus> => (await (await app.request("/api/speak/status")).json()) as SpeakStatus;

  before(() => {
    setFakeEngine(async (job) => {
      asked.push(job);
      return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
    }, ["light", "natural"]);
  });

  it("is listed as not here yet, with its size, and Install did not fetch it", async () => {
    const s = await status();
    assert.deepEqual(Object.keys(s.voices).sort(), ["fr_FR-upmc-medium#jessica", pierre]);
    assert.equal(s.voices[pierre].ready, false);
    assert.equal(s.voices[pierre].bytes, 76_733_615);
    assert.equal(s.fetch.phase, "idle");
  });

  it("chosen but not downloaded: the language's first voice speaks, and the download starts", async () => {
    patchSettings({ speak: { engine: "light", voices: { fr: pierre } } });
    try {
      asked.length = 0;
      const res = await speak({ text: "Bonjour, je suis Pierre et je lis le français." });
      assert.equal(res.headers.get("x-speak-voice"), "fr_FR-siwis-medium");
      assert.equal(asked[0].voice, "fr_FR-siwis-medium");
      // The route asked for the saved choice's model; join that download.
      assert.equal((await status()).fetch.phase, "downloading");
      await fetchVoice(pierre);
      const s = await status();
      assert.equal(s.voices[pierre].ready, true);
      assert.equal(s.fetch.voice, pierre);
      assert.equal(s.fetch.phase, "done");
      // Now Pierre speaks: the model file, and the male speaker's number.
      asked.length = 0;
      const again = await speak({ text: "Bonjour, je suis Pierre et je lis encore." });
      assert.equal(decodeURIComponent(again.headers.get("x-speak-voice") ?? ""), pierre);
      assert.equal(asked[0].voice, "fr_FR-upmc-medium");
      assert.equal(asked[0].speaker, 1);
    } finally {
      patchSettings({ speak: null });
    }
  });

  it("POST /api/speak/voice downloads the voice the Settings picker just chose", async () => {
    setFakeEngine(async (job) => {
      asked.push(job);
      return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
    }, ["light", "natural"]); // a fresh fake: nothing downloaded
    assert.equal((await status()).voices["fr_FR-upmc-medium#jessica"].ready, false);
    const res = await post("/api/speak/voice", { voice: "fr_FR-upmc-medium#jessica" });
    assert.equal(res.status, 202);
    const during = await status();
    assert.deepEqual([during.fetch.voice, during.fetch.phase], ["fr_FR-upmc-medium#jessica", "downloading"]);
    await fetchVoice("fr_FR-upmc-medium#jessica");
    assert.equal((await status()).voices["fr_FR-upmc-medium#jessica"].ready, true);
    // Refused: a voice that comes with Install, a Kokoro voice, nonsense.
    assert.equal((await post("/api/speak/voice", { voice: "fr_FR-siwis-medium" })).status, 400);
    assert.equal((await post("/api/speak/voice", { voice: "am_michael" })).status, 400);
    assert.equal((await post("/api/speak/voice", { voice: "../../etc" })).status, 400);
  });

  it("with Light not installed, asking for a Light voice is a 409 naming Light", async () => {
    setFakeEngine(async (job) => ({ audio: toneWav(job.text), mime: "audio/wav", ms: 1 }), ["natural"]);
    try {
      const res = await post("/api/speak/voice", { voice: pierre });
      assert.equal(res.status, 409);
      assert.equal(((await res.json()) as { needs: string }).needs, "light");
    } finally {
      setFakeEngine(async (job) => {
        asked.push(job);
        return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
      }, ["light", "natural"]);
    }
  });

  it("the settings take a Light voice for French under Natural, and Light speaks it", async () => {
    await post("/api/speak/voice", { voice: pierre });
    await fetchVoice(pierre);
    patchSettings({ speak: { engine: "natural", voices: { fr: pierre } } });
    try {
      assert.equal(getSettings().speak?.voices?.fr, pierre);
      asked.length = 0;
      const res = await speak({ text: "Je finis mon travail à dix-huit heures." });
      assert.equal(res.headers.get("x-speak-lang"), "fr");
      assert.equal(res.headers.get("x-speak-engine"), "light");
      assert.deepEqual([asked[0].engine, asked[0].voice, asked[0].speaker], ["light", "fr_FR-upmc-medium", 1]);
      // Japanese under the same settings is still Natural's.
      assert.equal((await speak({ text: "図書館へ行きます" })).headers.get("x-speak-engine"), "natural");
    } finally {
      patchSettings({ speak: null });
    }
  });

  it("a French lesson's heading, sent with its passage's language, is French", async () => {
    const plain = await speak({ text: "Décrire son quotidien." });
    assert.equal(plain.headers.get("x-speak-lang"), "en", "alone it has no French word — the bug");
    const withPassage = await speak({ text: "Décrire son quotidien.", passage: "fr" });
    assert.equal(withPassage.headers.get("x-speak-lang"), "fr");
  });
});

describe("GET /api/speak/status", () => {
  it("tells the owner what is installed and where the venv lives", async () => {
    const res = await app.request("/api/speak/status");
    const body = (await res.json()) as { engines: { light: { installed: boolean } }; venv: string; settings: { engine: string } };
    assert.equal(body.engines.light.installed, true);
    assert.match(body.venv, /tts[\\/]venv$/);
    assert.equal(body.settings.engine, "light");
  });
});

// ── Your own voices and the external speaker ───────────────────────────────

const voicesDir = makeDir();
const piperJson = (code: string, extra: Record<string, unknown> = {}) =>
  JSON.stringify({ audio: { sample_rate: 22050 }, phoneme_id_map: { _: [0] }, language: { code }, num_speakers: 1, speaker_id_map: {}, ...extra });
const upmc = path.join(voicesDir, "fr", "fr_FR", "upmc", "medium", "fr_FR-upmc-medium.onnx");
const davefx = path.join(voicesDir, "es_ES-davefx-medium.onnx");
const fakeSpeaker = path.join(voicesDir, "..", `speaker-${path.basename(voicesDir)}.sh`);

describe("your own voices (the voices folder)", () => {
  before(() => {
    mkdirSync(path.dirname(upmc), { recursive: true });
    writeFileSync(upmc, "onnx");
    writeFileSync(`${upmc}.json`, piperJson("fr_FR", { num_speakers: 2, speaker_id_map: { jessica: 0, pierre: 1 } }));
    writeFileSync(davefx, "onnx");
    writeFileSync(`${davefx}.json`, piperJson("es_ES"));
    writeFileSync(path.join(voicesDir, "en_US-ryan-high.onnx"), "onnx"); // no config: skipped
    setFakeEngine(async (job) => {
      asked.push(job);
      return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
    }, ["light", "natural"]);
  });
  after(() => {
    patchSettings({ speak: null });
    removeVault(voicesDir);
    rmSync(fakeSpeaker, { force: true });
  });

  it("refuses a folder that is relative, inside the vault, or not there — with a code the panel can say", () => {
    const refused = (dir: string): string => {
      try {
        patchSettings({ speak: { voicesDir: dir } });
      } catch (err) {
        return (err as VaultError).code ?? "";
      }
      return "accepted";
    };
    assert.equal(refused("piper-voices"), "speakDirRelative");
    assert.equal(refused(root), "speakDirInVault");
    assert.equal(refused(path.join(root, "voices")), "speakDirInVault");
    assert.equal(refused(path.join(voicesDir, "nowhere")), "speakDirMissing");
    assert.equal(refused(davefx), "speakDirNotDir");
    assert.equal(getSettings().speak, undefined, "a refused patch wrote nothing");
  });

  it("keeps the folder on this machine: in speak-local.json, never in settings.json", () => {
    const saved = patchSettings({ speak: { voicesDir } });
    assert.equal(saved.effective.speak.voicesDir, voicesDir);
    assert.doesNotMatch(readFileSync(path.join(data, "settings.json"), "utf8").toString(), /voicesDir/);
    assert.equal(JSON.parse(readFileSync(path.join(data, "speak-local.json"), "utf8")).voicesDir, voicesDir);
  });

  it("lists what the scan found per language, and what it skipped", async () => {
    const res = await app.request("/api/speak/voices/rescan", { method: "POST" });
    assert.equal(res.status, 200);
    const status = (await res.json()) as SpeakStatus;
    assert.equal(status.own.dir, voicesDir);
    assert.deepEqual(
      status.own.voices.map((v) => [v.lang, v.name]),
      [
        ["es", "Davefx"],
        ["fr", "Upmc · Jessica"],
        ["fr", "Upmc · Pierre"],
      ],
    );
    assert.deepEqual(status.own.skipped, [{ file: "en_US-ryan-high.onnx", reason: "noJson" }]);
    assert.equal(JSON.stringify(status).includes(upmc), false, "the status names voices, not the paths the worker loads");
  });

  it("a found voice picked for a language speaks it, loaded by path, with its speaker", async () => {
    patchSettings({ speak: { voices: { fr: "own:fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx#pierre" } } });
    asked.length = 0;
    const res = await speak({ text: "Le petit prince regarde les étoiles.", lang: "fr" });
    assert.equal(res.status, 200);
    assert.equal(res.headers.get("x-speak-engine"), "light");
    assert.equal(decodeURIComponent(res.headers.get("x-speak-voice") ?? ""), "own:fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx#pierre");
    assert.equal(asked[0].model, upmc);
    assert.equal(asked[0].config, `${upmc}.json`);
    assert.equal(asked[0].speaker, 1);
    // The same sentence again is a hit; the file replaced is spoken afresh.
    assert.equal((await speak({ text: "Le petit prince regarde les étoiles.", lang: "fr" })).headers.get("x-speak-cache"), "hit");
    const later = new Date(Date.now() + 60_000);
    utimesSync(upmc, later, later);
    assert.equal((await speak({ text: "Le petit prince regarde les étoiles.", lang: "fr" })).headers.get("x-speak-cache"), "miss");
  });

  it("a language only a found voice speaks is spoken on a Light-only machine", async () => {
    setFakeEngine(async (job) => {
      asked.push(job);
      return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
    }, ["light"]);
    try {
      asked.length = 0;
      const res = await speak({ text: "¿Dónde está la biblioteca?", lang: "es" });
      assert.equal(res.status, 200);
      assert.equal(asked[0].model, davefx);
      assert.equal(asked[0].engine, "light");
    } finally {
      setFakeEngine(async (job) => {
        asked.push(job);
        return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
      }, ["light", "natural"]);
    }
  });

  it("with no engine installed, the 409 names Light — the runtime the found voices need", async () => {
    setFakeEngine(async (job) => ({ audio: toneWav(job.text), mime: "audio/wav", ms: 1 }), []);
    try {
      const res = await speak({ text: "¿Qué hora es?", lang: "es" });
      assert.equal(res.status, 409);
      assert.equal(((await res.json()) as { needs: string }).needs, "light");
    } finally {
      setFakeEngine(async (job) => {
        asked.push(job);
        return { audio: toneWav(job.text), mime: "audio/wav", ms: 1 };
      }, ["light", "natural"]);
    }
  });

  it("while the operator has not allowed it (no SPEAK_EXTERNAL=on), an external speaker cannot be saved", async () => {
    delete process.env.SPEAK_EXTERNAL;
    let code = "";
    try {
      patchSettings({ speak: { external: { command: `"${fakeSpeaker}" {lang} {out}`, langs: ["fr"] } } });
    } catch (err) {
      code = (err as VaultError).code ?? "";
    }
    assert.equal(code, "speakExternalOff");
    const status = (await (await app.request("/api/speak/status")).json()) as SpeakStatus;
    assert.equal(status.externalAllowed, false);
    assert.equal(status.settings.external, null, "nothing was saved");
    // Clearing is always allowed.
    patchSettings({ speak: { external: null } });
  });

  it("the external speaker speaks the languages it was given, and says when it failed", async () => {
    process.env.SPEAK_EXTERNAL = "on";
    writeFileSync(fakeSpeaker, `#!/bin/sh\ncat > /dev/null\n[ "$1" = "fr" ] || exit 7\nprintf 'OggS-fake' > "$2"\n`);
    chmodSync(fakeSpeaker, 0o755);
    patchSettings({ speak: { external: { command: `"${fakeSpeaker}" {lang} {out}`, langs: ["fr", "ar"] } } });
    assert.equal(((await (await app.request("/api/speak/status")).json()) as SpeakStatus).externalAllowed, true);
    assert.doesNotMatch(readFileSync(path.join(data, "settings.json"), "utf8"), /external/);
    asked.length = 0;
    const fr = await speak({ text: "Une phrase pour le programme.", lang: "fr" });
    assert.equal(fr.status, 200);
    assert.equal(fr.headers.get("x-speak-engine"), "external");
    assert.equal(fr.headers.get("content-type"), "audio/ogg");
    assert.equal(asked.length, 0, "the app's engine was not asked");
    // English was not given to it.
    assert.equal((await speak({ text: "A sentence for the app.", lang: "en" })).headers.get("x-speak-engine"), "light");
    // Arabic was, and the program refuses it: a 502 the player names.
    const ar = await speak({ text: "جملة للبرنامج", lang: "ar" });
    assert.equal(ar.status, 502);
    assert.equal(((await ar.json()) as { code: string }).code, "speakExternal");
  });

  it("a command saved while allowed is never run once the operator turns the switch off", async () => {
    const ran = path.join(data, "ran-while-off.txt");
    writeFileSync(fakeSpeaker, `#!/bin/sh\ntouch "${ran}"\nprintf 'OggS-fake' > "$2"\n`);
    chmodSync(fakeSpeaker, 0o755);
    process.env.SPEAK_EXTERNAL = "on";
    patchSettings({ speak: { external: { command: `"${fakeSpeaker}" {lang} {out}`, langs: ["fr"] } } });
    process.env.SPEAK_EXTERNAL = "off";
    try {
      const fr = await speak({ text: "Une phrase que le programme ne lira pas.", lang: "fr" });
      assert.equal(fr.status, 200);
      assert.equal(fr.headers.get("x-speak-engine"), "light", "the app's own voice answered");
      assert.equal(existsSync(ran), false, "the program never ran");
    } finally {
      process.env.SPEAK_EXTERNAL = "on";
    }
  });


  it("refuses a command with no {out}, or with quotes that do not close", () => {
    assert.throws(() => patchSettings({ speak: { external: { command: "piper --model x.onnx", langs: ["fr"] } } }), /\{out\}/);
    assert.throws(() => patchSettings({ speak: { external: { command: 'piper "{out}', langs: ["fr"] } } }), /quotes/);
  });
});

describe("POST /api/speak (a visitor)", () => {
  before(() => {
    initAuth({
      ADMIN_PASSWORD_HASH: "$argon2id$v=19$m=65536,t=3,p=4$c2FsdHNhbHQ$aGFzaGhhc2hoYXNoaGFzaA",
      SESSION_SECRET: "relsecret0123456789abcdef0123456789",
    });
  });
  after(() => initAuth({}));

  it("is a 404 until the owner turns on Readers may listen", async () => {
    assert.equal((await speak({ text: "quick brown fox", path: "Public.md" })).status, 404);
    const status = (await (await app.request("/api/speak/status")).json()) as Record<string, unknown>;
    assert.deepEqual(status, { public: false });
  });

  it("with it on: the words of a published page, and nothing else", async () => {
    initAuth({});
    patchSettings({ speak: { public: true } });
    initAuth({
      ADMIN_PASSWORD_HASH: "$argon2id$v=19$m=65536,t=3,p=4$c2FsdHNhbHQ$aGFzaGhhc2hoYXNoaGFzaA",
      SESSION_SECRET: "relsecret0123456789abcdef0123456789",
    });
    try {
      const status = (await (await app.request("/api/speak/status")).json()) as Record<string, unknown>;
      assert.deepEqual(status, { public: true });
      // The rendered page's words: the link's label, no markup.
      assert.equal((await speak({ text: "The quick brown fox reads the evening paper.", path: "Public.md" })).status, 200);
      assert.equal((await speak({ text: "Say something the page never said.", path: "Public.md" })).status, 403);
      assert.equal((await speak({ text: "A secret sentence.", path: "Private.md" })).status, 404);
      assert.equal((await speak({ text: "quick brown fox" })).status, 404);
    } finally {
      initAuth({});
      patchSettings({ speak: null });
    }
  });

  it("never runs the owner's external speaker: a visitor hears the app's voices", async () => {
    initAuth({});
    process.env.SPEAK_EXTERNAL = "on"; // allowed, so what refuses it here is the visitor rule
    const program = path.join(data, "never-run.sh");
    const ran = path.join(data, "never-run.txt");
    writeFileSync(program, `#!/bin/sh\ntouch "${ran}"\nprintf 'OggS' > "$1"\n`);
    chmodSync(program, 0o755);
    patchSettings({ speak: { public: true, external: { command: `"${program}" {out}`, langs: ["en"] } } });
    initAuth({
      ADMIN_PASSWORD_HASH: "$argon2id$v=19$m=65536,t=3,p=4$c2FsdHNhbHQ$aGFzaGhhc2hoYXNoaGFzaA",
      SESSION_SECRET: "relsecret0123456789abcdef0123456789",
    });
    try {
      const res = await speak({ text: "The quick brown fox reads the evening paper.", path: "Public.md" });
      assert.equal(res.status, 200);
      assert.equal(res.headers.get("x-speak-engine"), "light");
      assert.equal(existsSync(ran), false, "the program never ran");
    } finally {
      initAuth({});
      patchSettings({ speak: null });
      delete process.env.SPEAK_EXTERNAL;
    }
  });

  it("folds text the way the page check does", () => {
    assert.equal(foldForMatch("The “quick”, brown — FOX!"), "thequickbrownfox");
    assert.equal(foldForMatch("الْمَكْتَبَةُ"), foldForMatch("الْمَكْتَبَةُ"));
  });
});