// TagAlly Engine — Mehrsprachigkeit der Ausgabe-Texte (Prüfprotokoll,
// Struktur-Ansicht, Nachbesserungs-Meldungen).
//
// Bewusst getrennt von der Panel-Sprache: Das Prüfprotokoll ist der juristische
// Nachweis und muss die Sprache dessen sprechen, der ihn entgegennimmt — ein
// deutsches Studio liefert an eine französische Behörde ein französisches
// Protokoll, arbeitet aber weiter in deutscher Oberfläche.
//
// Neue Sprache: strings/<code>.js nach dem Muster von de.js anlegen und hier
// registrieren. Fehlende Schlüssel fallen automatisch auf Deutsch zurück.

const TABLES = {
  de: require("./strings/de.js"),
  en: require("./strings/en.js"),
  fr: require("./strings/fr.js"),
  es: require("./strings/es.js"),
  it: require("./strings/it.js"),
  nl: require("./strings/nl.js"),
  pt: require("./strings/pt.js"),
  pl: require("./strings/pl.js"),
  da: require("./strings/da.js"),
  sv: require("./strings/sv.js"),
  nb: require("./strings/nb.js")
};

// Rückfallsprache Englisch: Ein unübersetzter Schlüssel erscheint damit in der
// Sprache, die international am ehesten verstanden wird — nicht in Deutsch.
const FALLBACK = "en";

function normalize(lang) {
  const code = String(lang || "").toLowerCase().split(/[-_]/)[0];
  return TABLES[code] ? code : FALLBACK;
}

function available() {
  return Object.keys(TABLES);
}

// t(lang, key, vars) — unbekannte Schlüssel fallen erst auf Englisch,
// dann auf den Schlüsselnamen selbst zurück (nie „undefined" im Nachweis).
function t(lang, key, vars) {
  const code = normalize(lang);
  let s = TABLES[code][key];
  if (s === undefined) s = TABLES[FALLBACK][key];
  if (s === undefined) return key;
  if (vars) {
    for (const k of Object.keys(vars)) {
      s = s.split("{" + k + "}").join(String(vars[k]));
    }
  }
  return s;
}

// Bindet die Sprache einmal — spart das Durchreichen in jedem Aufruf.
function translator(lang) {
  const code = normalize(lang);
  const fn = (key, vars) => t(code, key, vars);
  fn.lang = code;
  fn.locale = t(code, "meta.locale");
  fn.htmlLang = t(code, "meta.htmlLang");
  return fn;
}

// Übersetzungen für die Java-Werkzeuge (TagAllyView/TagAllyFix) als
// .properties-Text. So bleibt EINE Übersetzungsquelle für alles — Java hält
// nur englische Notfall-Vorgaben im Code, falls die Datei mal fehlt.
// Platzhalter bleiben in {name}-Form; Java ersetzt sie selbst.
function javaProps(lang, prefixes) {
  const code = normalize(lang);
  const keys = Object.keys(TABLES[FALLBACK]).filter(
    (k) => prefixes.some((p) => k.indexOf(p) === 0)
  );
  const esc = (s) => String(s)
    .replace(/\\/g, "\\\\")
    .replace(/\n/g, "\\n")
    .replace(/\r/g, "");
  return keys
    .map((k) => k + "=" + esc(TABLES[code][k] !== undefined ? TABLES[code][k] : TABLES[FALLBACK][k]))
    .join("\n") + "\n";
}

// Sprache der Konsolen-Ausgaben: Umgebung zuerst, sonst die Systemeinstellung.
// TAGALLY_LANG erlaubt das Erzwingen einer Sprache, etwa zum Prüfen.
// Achtung: Das ist NICHT die Protokollsprache — die wählt der Nutzer im Panel.
function detect() {
  const env = process.env.TAGALLY_LANG || process.env.LC_ALL
           || process.env.LC_MESSAGES || process.env.LANG;
  if (env) return normalize(env);
  try {
    return normalize(Intl.DateTimeFormat().resolvedOptions().locale);
  } catch (e) {
    return FALLBACK;
  }
}

// Die wenigen Meldungen, die vor dem Start von Node fallen müssen, kann nur
// die Shell ausgeben. Damit es trotzdem EINE Übersetzungsquelle bleibt, werden
// sie hieraus als schlichte SCHLÜSSEL=Wert-Datei erzeugt (siehe
// gen-shell-strings.js). Kein Anführungszeichen, keine Maskierung: Beide
// Skripte lesen zeilenweise und trennen am ersten Gleichheitszeichen.
const SHELL_KEYS = {
  NODE_MISSING: "console.nodeMissing",
  NODE_MISSING_HINT: "console.nodeMissingHint",
  ENGINE_STOPPED: "console.engineStopped",
  PRESS_ENTER: "console.pressEnter",
};

function shellProps(lang) {
  const code = normalize(lang);
  return Object.entries(SHELL_KEYS)
    .map(([name, key]) => name + "=" + String(t(code, key)).replace(/[\r\n]+/g, " "))
    .join("\n") + "\n";
}

module.exports = { t, translator, normalize, available, javaProps, detect, shellProps };
