/**
 * pdf.js - Schlanker PDF-Erzeuger für Textseiten mit eingebetteten Dateien.
 *
 * Warum selbst geschrieben statt einer fertigen Bibliothek: Eine
 * Erweiterung soll nichts nachladen, und ein mitgeliefertes pdf-lib wäre
 * rund ein Megabyte für einen Bruchteil seiner Fähigkeiten. Hier werden
 * nur Text und Anhänge gebraucht.
 *
 * Erzeugt wird PDF 1.7 mit den eingebauten Schriften Helvetica und
 * Helvetica-Bold. Die sind in jedem Betrachter vorhanden und müssen nicht
 * eingebettet werden.
 *
 * AUSDRÜCKLICH KEIN PDF/A. Dafür wären eingebettete Schriftschnitte, ein
 * Farbprofil und XMP-Metadaten nötig - und vor allem eine Prüfung mit
 * veraPDF, die hier niemand durchführen kann. Ein Dokument als PDF/A zu
 * bezeichnen, ohne es geprüft zu haben, wäre eine leere Behauptung.
 */

/** Millimeter in Punkte. Ein Punkt ist 1/72 Zoll. */
export function mm(wert) {
  return (Number(wert) || 0) * 72 / 25.4;
}

/**
 * Papierformate in Millimetern.
 *
 * A4 ist ausserhalb Nordamerikas der Regelfall, Letter und Legal dort.
 * A5 ist selten, aber bei kurzen Nachrichten sparsam im Ausdruck.
 */
export const FORMATE = {
  a4:     { name: "A4",     breite: 210,   hoehe: 297 },
  a5:     { name: "A5",     breite: 148,   hoehe: 210 },
  letter: { name: "Letter", breite: 215.9, hoehe: 279.4 },
  legal:  { name: "Legal",  breite: 215.9, hoehe: 355.6 }
};

// Rückwärtskompatible Vorgaben in Punkten
export const SEITE_BREITE = mm(FORMATE.a4.breite);
export const SEITE_HOEHE = mm(FORMATE.a4.hoehe);

// Zeichenbreiten der Standardschriften, in Tausendstel der Schriftgröße.
// Aus den AFM-Dateien von Adobe. Sie werden nur zum Umbrechen gebraucht -
// eine kleine Abweichung verschiebt den Umbruch, verfälscht aber nichts.
const BREITE_HELVETICA = {
  " ": 278, "!": 278, '"': 355, "#": 556, $: 556, "%": 889, "&": 667,
  "'": 191, "(": 333, ")": 333, "*": 389, "+": 584, ",": 278, "-": 333,
  ".": 278, "/": 278, ":": 278, ";": 278, "<": 584, "=": 584, ">": 584,
  "?": 556, "@": 1015, "[": 278, "\\": 278, "]": 278, "^": 469, _: 556,
  "`": 333, "{": 334, "|": 260, "}": 334, "~": 584,
  A: 667, B: 667, C: 722, D: 722, E: 667, F: 611, G: 778, H: 722, I: 278,
  J: 500, K: 667, L: 556, M: 833, N: 722, O: 778, P: 667, Q: 778, R: 722,
  S: 667, T: 611, U: 722, V: 667, W: 944, X: 667, Y: 667, Z: 611,
  a: 556, b: 556, c: 500, d: 556, e: 556, f: 278, g: 556, h: 556, i: 222,
  j: 222, k: 500, l: 222, m: 833, n: 556, o: 556, p: 556, q: 556, r: 333,
  s: 500, t: 278, u: 556, v: 500, w: 722, x: 500, y: 500, z: 500,
  "0": 556, "1": 556, "2": 556, "3": 556, "4": 556, "5": 556, "6": 556,
  "7": 556, "8": 556, "9": 556,
  "ä": 556, "ö": 556, "ü": 556, "Ä": 667, "Ö": 778, "Ü": 722, "ß": 556,
  "é": 556, "è": 556, "à": 556, "ç": 500, "–": 556, "—": 1000, "€": 556
};

const BREITE_FETT = {
  ...BREITE_HELVETICA,
  A: 722, B: 722, C: 722, D: 722, E: 667, F: 611, G: 778, H: 722, I: 278,
  J: 556, K: 722, L: 611, M: 833, N: 722, O: 778, P: 667, Q: 778, R: 722,
  S: 667, T: 611, U: 722, V: 667, W: 944, X: 667, Y: 667, Z: 611,
  a: 556, b: 611, c: 556, d: 611, e: 556, f: 333, g: 611, h: 611, i: 278,
  j: 278, k: 556, l: 278, m: 889, n: 611, o: 611, p: 611, q: 611, r: 389,
  s: 556, t: 333, u: 611, v: 556, w: 778, x: 556, y: 556, z: 500,
  "'": 238, "-": 333, ":": 333, ";": 333, "(": 333, ")": 333
};

const BREITE_ERSATZ = 556;

/**
 * Zeichen, die in WinAnsiEncoding an anderer Stelle stehen als in
 * Latin-1. PDF-Betrachter erwarten diese Belegung; ohne die Umsetzung
 * erschiene etwa das Eurozeichen als Steuerzeichen.
 */
const WINANSI_SONDER = {
  "\u20AC": 0x80, "\u201A": 0x82, "\u0192": 0x83, "\u201E": 0x84,
  "\u2026": 0x85, "\u2020": 0x86, "\u2021": 0x87, "\u02C6": 0x88,
  "\u2030": 0x89, "\u0160": 0x8A, "\u2039": 0x8B, "\u0152": 0x8C,
  "\u017D": 0x8E, "\u2018": 0x91, "\u2019": 0x92, "\u201C": 0x93,
  "\u201D": 0x94, "\u2022": 0x95, "\u2013": 0x96, "\u2014": 0x97,
  "\u02DC": 0x98, "\u2122": 0x99, "\u0161": 0x9A, "\u203A": 0x9B,
  "\u0153": 0x9C, "\u017E": 0x9E, "\u0178": 0x9F
};

/** Breite einer Zeichenkette in Punkten. */
export function textbreite(text, groesse, fett = false) {
  const tabelle = fett ? BREITE_FETT : BREITE_HELVETICA;
  let summe = 0;
  for (const z of String(text)) {
    summe += tabelle[z] ?? BREITE_ERSATZ;
  }
  return (summe * groesse) / 1000;
}

/**
 * Zeichenkette in eine PDF-Literalzeichenkette überführen.
 *
 * Zeichen ausserhalb von WinAnsi werden durch ein Fragezeichen ersetzt.
 * Das betrifft in der Praxis fast nur Emojis - dafür wäre eine
 * eingebettete Schrift nötig.
 */
function pdfText(text) {
  const bytes = [];
  for (const z of String(text)) {
    let code;
    if (WINANSI_SONDER[z] !== undefined) {
      code = WINANSI_SONDER[z];
    } else {
      const cp = z.codePointAt(0);
      code = cp <= 0xFF ? cp : 0x3F;      // Fragezeichen
    }
    if (code === 0x28 || code === 0x29 || code === 0x5C) {
      bytes.push(0x5C);                    // Rückstrich voranstellen
    }
    bytes.push(code);
  }
  return bytes;
}

/** Text in Zeilen umbrechen, die in die angegebene Breite passen. */
export function umbrechen(text, breite, groesse, fett = false) {
  const zeilen = [];
  for (const absatz of String(text ?? "").split(/\r?\n/)) {
    if (!absatz.trim()) {
      zeilen.push("");
      continue;
    }
    let zeile = "";
    for (const wort of absatz.split(/ +/)) {
      const versuch = zeile ? `${zeile} ${wort}` : wort;
      if (textbreite(versuch, groesse, fett) <= breite || !zeile) {
        // Ein einzelnes zu langes Wort wird hart getrennt - sonst liefe
        // es über den Rand hinaus.
        if (!zeile && textbreite(wort, groesse, fett) > breite) {
          let rest = wort;
          while (textbreite(rest, groesse, fett) > breite) {
            let n = 1;
            while (n < rest.length
                   && textbreite(rest.slice(0, n + 1), groesse, fett) <= breite) {
              n += 1;
            }
            zeilen.push(rest.slice(0, n));
            rest = rest.slice(n);
          }
          zeile = rest;
        } else {
          zeile = versuch;
        }
      } else {
        zeilen.push(zeile);
        zeile = wort;
      }
    }
    zeilen.push(zeile);
  }
  return zeilen;
}

// ---------------------------------------------------------------- Aufbau

export class PdfDokument {
  /**
   * Seitengröße und Ränder werden in PUNKTEN erwartet. Für die Umrechnung
   * aus Millimetern gibt es mm().
   */
  constructor({ titel = "", autor = "", betreff = "",
                breite = SEITE_BREITE, hoehe = SEITE_HOEHE,
                randLinks = mm(20), randRechts = mm(10),
                randOben = mm(10), randUnten = mm(10) } = {}) {
    this.titel = titel;
    this.autor = autor;
    this.betreff = betreff;
    this.breite = breite;
    this.hoehe = hoehe;
    this.randLinks = randLinks;
    this.randRechts = randRechts;
    this.randOben = randOben;
    this.randUnten = randUnten;
    this.seiten = [];        // je Seite ein Feld von Byte-Stücken
    this.anhaenge = [];      // {name, daten, beschreibung, mime}
    this.aktuell = null;
    this.y = 0;
  }

  /** Linker Rand. Der Name bleibt kurz, weil er oft gebraucht wird. */
  get rand() {
    return this.randLinks;
  }

  get innenbreite() {
    return this.breite - this.randLinks - this.randRechts;
  }

  neueSeite() {
    this.aktuell = [];
    this.seiten.push(this.aktuell);
    this.y = this.hoehe - this.randOben;
    return this.aktuell;
  }

  /** Platz für die nächsten Zeilen sichern, notfalls umblättern. */
  platzPruefen(hoehe) {
    if (!this.aktuell) this.neueSeite();
    if (this.y - hoehe < this.randUnten) this.neueSeite();
  }

  /**
   * Eine Textzeile setzen. Gibt die neue Schreibhöhe zurück.
   */
  zeile(text, { groesse = 10, fett = false, einzug = 0,
                abstand = 1.35, farbe = null } = {}) {
    const hoehe = groesse * abstand;
    this.platzPruefen(hoehe);
    const x = this.rand + einzug;
    const teile = [];
    if (farbe) {
      teile.push(`${farbe[0]} ${farbe[1]} ${farbe[2]} rg\n`);
    }
    teile.push("BT\n");
    teile.push(`/${fett ? "F2" : "F1"} ${groesse} Tf\n`);
    teile.push(`1 0 0 1 ${x.toFixed(2)} ${(this.y - groesse).toFixed(2)} Tm\n`);
    this.aktuell.push(...teile.map((t) => new TextEncoder().encode(t)));
    this.aktuell.push(new Uint8Array([0x28]));            // (
    this.aktuell.push(new Uint8Array(pdfText(text)));
    this.aktuell.push(new TextEncoder().encode(") Tj\nET\n"));
    if (farbe) {
      this.aktuell.push(new TextEncoder().encode("0 0 0 rg\n"));
    }
    this.y -= hoehe;
    return this.y;
  }

  /** Mehrere Zeilen mit automatischem Umbruch. */
  absatz(text, opt = {}) {
    const groesse = opt.groesse ?? 10;
    const einzug = opt.einzug ?? 0;
    const breite = this.innenbreite - einzug;
    for (const z of umbrechen(text, breite, groesse, opt.fett)) {
      this.zeile(z, opt);
    }
  }

  /**
   * Text an einer festen Stelle setzen, ohne die Schreibhöhe zu ändern.
   *
   * Wird für Spaltensatz gebraucht: Beschriftung und Wert stehen auf
   * derselben Grundlinie, aber an verschiedenen Stellen.
   */
  textAn(x, grundlinie, text, { groesse = 10, fett = false,
                                farbe = null } = {}) {
    if (!this.aktuell) this.neueSeite();
    const teile = [];
    if (farbe) teile.push(`${farbe[0]} ${farbe[1]} ${farbe[2]} rg\n`);
    teile.push("BT\n");
    teile.push(`/${fett ? "F2" : "F1"} ${groesse} Tf\n`);
    teile.push(`1 0 0 1 ${x.toFixed(2)} ${grundlinie.toFixed(2)} Tm\n`);
    this.aktuell.push(...teile.map((t) => new TextEncoder().encode(t)));
    this.aktuell.push(new Uint8Array([0x28]));
    this.aktuell.push(new Uint8Array(pdfText(text)));
    this.aktuell.push(new TextEncoder().encode(") Tj\nET\n"));
    if (farbe) this.aktuell.push(new TextEncoder().encode("0 0 0 rg\n"));
  }

  /**
   * Gefülltes Rechteck.
   *
   * Muss VOR dem Text gezeichnet werden - im Inhaltsstrom gilt die
   * Reihenfolge, Späteres liegt oben.
   */
  rechteck(x, y, breite, hoehe, grau = 0.95) {
    if (!this.aktuell) this.neueSeite();
    const s = `${grau} g ${x.toFixed(2)} ${y.toFixed(2)} `
      + `${breite.toFixed(2)} ${hoehe.toFixed(2)} re f 0 g\n`;
    this.aktuell.push(new TextEncoder().encode(s));
  }

  /** Waagerechte Linie. */
  linie(dicke = 0.6, grau = 0.75) {
    this.platzPruefen(8);
    this.y -= 4;
    const s = `${grau} G ${dicke} w ${this.randLinks.toFixed(2)} `
      + `${this.y.toFixed(2)} m `
      + `${(this.breite - this.randRechts).toFixed(2)} `
      + `${this.y.toFixed(2)} l S\n`;
    this.aktuell.push(new TextEncoder().encode(s));
    this.y -= 8;
  }

  abstand(punkte) {
    this.platzPruefen(punkte);
    this.y -= punkte;
  }

  /**
   * Datei an das Dokument anhängen.
   *
   * daten muss ein Uint8Array sein. Der Name wird im Anhangsbereich des
   * Betrachters angezeigt.
   */
  anhang(name, daten, { beschreibung = "", mime = "application/octet-stream" } = {}) {
    this.anhaenge.push({
      name: String(name),
      daten: daten instanceof Uint8Array ? daten : new Uint8Array(daten),
      beschreibung: String(beschreibung),
      mime: String(mime)
    });
  }

  // ------------------------------------------------------------ Ausgabe

  bauen() {
    if (!this.seiten.length) this.neueSeite();

    const enc = (s) => new TextEncoder().encode(s);
    const objekte = [];                    // 1-basiert, Index 0 bleibt leer
    const neu = (inhalt) => { objekte.push(inhalt); return objekte.length; };

    // Reihenfolge festlegen, damit Verweise bekannt sind
    const katalogNr = 1;
    const seitenbaumNr = 2;
    const infoNr = 3;
    const f1Nr = 4;
    const f2Nr = 5;
    objekte.push(null, null, null, null, null);   // Plätze 1..5

    // Seiteninhalte und Seitenobjekte
    const seitenNr = [];
    for (const stuecke of this.seiten) {
      const inhalt = verbinden(stuecke);
      const stromNr = neu({
        kopf: `<< /Length ${inhalt.length} >>`,
        strom: inhalt
      });
      const seiteNr = neu({
        kopf: `<< /Type /Page /Parent ${seitenbaumNr} 0 R `
          + `/MediaBox [0 0 ${this.breite.toFixed(2)} `
          + `${this.hoehe.toFixed(2)}] `
          + `/Resources << /Font << /F1 ${f1Nr} 0 R /F2 ${f2Nr} 0 R >> >> `
          + `/Contents ${stromNr} 0 R >>`
      });
      seitenNr.push(seiteNr);
    }

    // Anhänge
    const namensPaare = [];
    for (const a of this.anhaenge) {
      const stromNr = neu({
        kopf: `<< /Type /EmbeddedFile /Subtype ${nameEscape(a.mime)} `
          + `/Length ${a.daten.length} /Params << /Size ${a.daten.length} >> >>`,
        strom: a.daten
      });
      const specNr = neu({
        kopf: `<< /Type /Filespec /F (${roh(a.name)}) /UF (${roh(a.name)}) `
          + (a.beschreibung ? `/Desc (${roh(a.beschreibung)}) ` : "")
          + `/AFRelationship /Source /EF << /F ${stromNr} 0 R >> >>`
      });
      namensPaare.push(`(${roh(a.name)}) ${specNr} 0 R`);
    }

    let namenNr = 0;
    if (namensPaare.length) {
      namenNr = neu({
        kopf: `<< /EmbeddedFiles << /Names [ ${namensPaare.join(" ")} ] >> >>`
      });
    }

    // Feste Objekte nachtragen
    objekte[katalogNr - 1] = {
      kopf: `<< /Type /Catalog /Pages ${seitenbaumNr} 0 R`
        + (namenNr ? ` /Names ${namenNr} 0 R /PageMode /UseAttachments` : "")
        + " >>"
    };
    objekte[seitenbaumNr - 1] = {
      kopf: `<< /Type /Pages /Count ${seitenNr.length} `
        + `/Kids [ ${seitenNr.map((n) => `${n} 0 R`).join(" ")} ] >>`
    };
    objekte[infoNr - 1] = {
      kopf: "<< " + [
        this.titel ? `/Title (${roh(this.titel)})` : "",
        this.autor ? `/Author (${roh(this.autor)})` : "",
        this.betreff ? `/Subject (${roh(this.betreff)})` : "",
        "/Producer (Paperless-Connector)",
        `/CreationDate (${pdfDatum(new Date())})`
      ].filter(Boolean).join(" ") + " >>"
    };
    objekte[f1Nr - 1] = {
      kopf: "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica "
        + "/Encoding /WinAnsiEncoding >>"
    };
    objekte[f2Nr - 1] = {
      kopf: "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold "
        + "/Encoding /WinAnsiEncoding >>"
    };

    // Zusammensetzen
    const teile = [enc("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n")];
    let pos = teile[0].length;
    const versatz = [0];

    for (let i = 0; i < objekte.length; i += 1) {
      const o = objekte[i];
      versatz.push(pos);
      const kopf = enc(`${i + 1} 0 obj\n${o.kopf}\n`);
      teile.push(kopf);
      pos += kopf.length;
      if (o.strom) {
        const a = enc("stream\n");
        teile.push(a, o.strom, enc("\nendstream\n"));
        pos += a.length + o.strom.length + 11;
      }
      const ende = enc("endobj\n");
      teile.push(ende);
      pos += ende.length;
    }

    const xrefPos = pos;
    let xref = `xref\n0 ${objekte.length + 1}\n0000000000 65535 f \n`;
    for (let i = 1; i <= objekte.length; i += 1) {
      xref += `${String(versatz[i]).padStart(10, "0")} 00000 n \n`;
    }
    xref += `trailer\n<< /Size ${objekte.length + 1} `
      + `/Root ${katalogNr} 0 R /Info ${infoNr} 0 R >>\n`
      + `startxref\n${xrefPos}\n%%EOF\n`;
    teile.push(enc(xref));

    return verbinden(teile);
  }
}

// ------------------------------------------------------------ Hilfsmittel

function verbinden(stuecke) {
  let laenge = 0;
  for (const s of stuecke) laenge += s.length;
  const aus = new Uint8Array(laenge);
  let p = 0;
  for (const s of stuecke) { aus.set(s, p); p += s.length; }
  return aus;
}

/** Zeichenkette für eine PDF-Literalzeichenkette absichern. */
function roh(text) {
  return String(text)
    .replace(/\\/g, "\\\\")
    .replace(/\(/g, "\\(")
    .replace(/\)/g, "\\)")
    // Zeichen ausserhalb von ASCII vermeiden - in Namen und Titeln reicht
    // das, und es erspart die Umsetzung nach WinAnsi an dieser Stelle.
    .replace(/[^\x20-\x7E]/g, (z) => ({
      "ä": "ae", "ö": "oe", "ü": "ue", "Ä": "Ae", "Ö": "Oe", "Ü": "Ue",
      "ß": "ss"
    }[z] ?? "?"));
}

/** Namen im PDF-Syntax absichern, etwa für Medientypen. */
function nameEscape(text) {
  return "/" + String(text).replace(/[^A-Za-z0-9._-]/g,
    (z) => "#" + z.charCodeAt(0).toString(16).padStart(2, "0"));
}

function pdfDatum(d) {
  const z = (n) => String(n).padStart(2, "0");
  return `D:${d.getFullYear()}${z(d.getMonth() + 1)}${z(d.getDate())}`
    + `${z(d.getHours())}${z(d.getMinutes())}${z(d.getSeconds())}`;
}