/**
 * models/engine/legacyToUnicode.ts — legacy Odia encoding → Unicode Odia.
 *
 * Copyright (C) the OdiaWikimedia/Converter authors: Manoj Sahukar, Subhashish
 * Panigrahi, Shitikantha Dash, Benjamin Varghese (BenVar). Inspired by the Rebati
 * converter by Srujanika.
 * Modifications Copyright (C) 2026 INKDEW.
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3 of the License. This program is distributed in the hope
 * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details: /licence/gpl-3.0 on this site, or
 * https://www.gnu.org/licenses/gpl-3.0.html.
 *
 * UPSTREAM: https://github.com/OdiaWikimedia/Converter, commit
 * 76664f0705c254d43e30f8faa4be447be7c60e54 (2023-05-24). Files used:
 *   "Akruti-Sarala - Unicode Converter.htm", "Aprant - Unicode Converter.htm",
 *   "ORTT-Sarala - Unicode Converter.htm", "Shreelipi - Unicode Odia Converter.htm".
 *
 * INKDEW MODIFICATIONS (2026-11-11), none of which change the output:
 *   1. The upstream browser code read and wrote <textarea> elements through
 *      `document`. Here the same algorithm is a pure function of a string, so it
 *      can run on the server.
 *   2. Upstream relied on undeclared globals (`idx`, `input_symbol_idx`), which a
 *      strict-mode module forbids; they are now local variables.
 *   3. The mapping arrays and post-processing regular expressions were moved,
 *      unchanged and in order, into tables.ts as data.
 *   4. Upstream's "replace the first occurrence, then search again from the start"
 *      loop is kept, but each search resumes at the earliest position where a new
 *      match could begin. This is exactly equivalent (no match can start earlier,
 *      because the text before it is unchanged and had no match) and turns a
 *      quadratic loop into a fast one for book-length text.
 *   5. Long text is processed line by line. No upstream mapping, replacement or
 *      rule can match across a line feed (checked by lineSafe() at start-up), so
 *      this is also exactly equivalent.
 *   6. A loop guard stops a pathological input instead of hanging the server.
 * Equivalence with the unmodified upstream script is checked at every start-up
 * (see registry.ts, runSelfTest()).
 */

import type { LegacyTable } from "./tables";

const LOOP_LIMIT = 5_000_000;

function replaceRepeatedly(s: string, pat: string, rep: string): string {
  let from = 0;
  let guard = 0;
  for (;;) {
    const p = s.indexOf(pat, from);
    if (p === -1) return s;
    s = s.slice(0, p) + rep + s.slice(p + pat.length);
    from = Math.max(0, p - pat.length + 1);
    if (++guard > LOOP_LIMIT) throw new Error("conversion-loop-limit");
  }
}

type Compiled = { table: LegacyTable; rules: [RegExp, string][] };
const cache = new Map<LegacyTable, Compiled>();

function compile(table: LegacyTable): Compiled {
  let c = cache.get(table);
  if (!c) {
    c = { table, rules: table.rules.map(([src, flags, rep]) => [new RegExp(src, flags), rep] as [RegExp, string]) };
    cache.set(table, c);
  }
  return c;
}

function convertLine(c: Compiled, s: string): string {
  if (s === "") return s;
  for (const [legacy, uni] of c.table.pairs) {
    if (legacy !== "" && s.includes(legacy)) s = replaceRepeatedly(s, legacy, uni);
  }
  for (const [re, rep] of c.rules) s = s.replace(re, rep);
  return s;
}

function convertChunk(c: Compiled, s: string): string {
  if (s === "") return s;
  if (s.length > 2000 && s.includes("\n")) return s.split("\n").map((line) => convertLine(c, line)).join("\n");
  return convertLine(c, s);
}

/** Convert legacy-encoded text to Unicode Odia with the given upstream table. */
export function legacyToUnicode(table: LegacyTable, input: string): string {
  const c = compile(table);
  if (!table.chunkSize) return convertChunk(c, input);
  let out = "";
  for (let i = 0; i < input.length; i += table.chunkSize) out += convertChunk(c, input.slice(i, i + table.chunkSize));
  return out;
}

/** True when no mapping or rule can match across a line feed, so per-line processing is exact. */
export function lineSafe(table: LegacyTable): boolean {
  if (table.pairs.some(([a, b]) => a === "" || a.includes("\n") || b.includes("\n"))) return false;
  return table.rules.every(([src, , rep]) => !/\\s|\\n|\\W|\\D|\[\^|(^|[^\\])\./.test(src) && !rep.includes("\n"));
}

/** Characters in the input that no mapping key covers (reported as warnings, never removed). */
export function unmappedChars(table: LegacyTable, input: string): string[] {
  const known = new Set<string>();
  for (const [a] of table.pairs) for (const ch of a) known.add(ch);
  const seen = new Set<string>();
  for (const ch of input) {
    const cp = ch.codePointAt(0) ?? 0;
    if (cp < 0x80 || known.has(ch) || /\s/.test(ch)) continue;
    if (cp >= 0x0b00 && cp <= 0x0b7f) continue; // already Unicode Odia
    seen.add(ch);
  }
  return [...seen].slice(0, 20);
}