import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import {
  SCHRIFT_STANDARD,
  liesSchriftgroesse,
  schreibeSchriftgroesse,
  schriftsicherung,
} from '../../electron/schriftgroesse';

/**
 * Befund 11: Eine misslungene Sicherung der Schriftgroesse
 * verwarf die Stufe endgueltig - auch beim Programmende.
 *
 * `schreibe()` setzte `letzteGesicherte = wert` VOR dem Schreibversuch, und
 * `schreibeSchriftgroesse` verschluckte jeden Schreibfehler ohne Rueckmeldung.
 * Danach galt der Wert als gesichert, obwohl nichts auf dem Datentraeger stand:
 * `offen` war `null`, der Fruehausstieg in `plane` griff bei demselben Wert, und
 * das `jetzt()` aus `before-quit` (electron/main.ts) fand nichts mehr vor. Wer
 * 175 % einstellte, waehrend der Profilabgleich oder ein Virenwaechter
 * `ansicht.json` kurz sperrte, sass beim naechsten Start wieder vor 100 %.
 *
 * Nachgestellt wird der Fehlschlag ueber ein Verzeichnis, das es noch nicht
 * gibt - derselbe Wurf (ENOENT) wie bei einer voruebergehend unerreichbaren
 * Ordnerumleitung. Danach entsteht das Verzeichnis: Der Sperrgrund ist fort,
 * und die Anwendung muss die Gelegenheit zum Nachholen noch haben.
 */

describe('Schriftgroesse: eine misslungene Sicherung wird als solche gefuehrt', () => {
  let ordner = '';
  /** Der Ort, an dem `ansicht.json` liegt - anfangs unerreichbar. */
  let profil = '';
  let datei = '';

  beforeEach(() => {
    vi.useFakeTimers();
    ordner = mkdtempSync(path.join(tmpdir(), 'lsa-hauptprozess-schrift-'));
    profil = path.join(ordner, 'profil');
    datei = path.join(profil, 'ansicht.json');
  });

  afterEach(() => {
    vi.useRealTimers();
    rmSync(ordner, { recursive: true, force: true });
  });

  it('meldet zurück, ob wirklich geschrieben wurde', () => {
    expect(schreibeSchriftgroesse(datei, 175), 'Fehlschlag als Erfolg gemeldet').toBe(false);
    mkdirSync(profil);
    expect(schreibeSchriftgroesse(datei, 175), 'gelungene Schreibung nicht gemeldet').toBe(true);
    expect(liesSchriftgroesse(datei)).toBe(175);
  });

  it('holt beim Programmende nach, was der erste Versuch nicht schreiben konnte', () => {
    const sicherung = schriftsicherung(datei, SCHRIFT_STANDARD, 750);

    // Ansicht -> Schriftgröße -> 175 %, die Ruhezeit laeuft ab.
    sicherung.plane(175);
    vi.advanceTimersByTime(800);
    expect(existsSync(datei), 'die Schreibung ist wider Erwarten gelungen').toBe(false);

    // Abends ist der Sperrgrund laengst fort.
    mkdirSync(profil);

    // `app.on('before-quit')` in electron/main.ts ruft genau das.
    sicherung.jetzt();
    expect(liesSchriftgroesse(datei), 'beim Programmende nichts nachgeholt').toBe(175);
  });

  it('schreibt beim erneuten Einstellen desselben Werts, wenn er nie ankam', () => {
    const sicherung = schriftsicherung(datei, SCHRIFT_STANDARD, 750);
    sicherung.plane(175);
    vi.advanceTimersByTime(800);

    mkdirSync(profil);

    // Ein Auswahlpunkt loest seinen Handler auch dann aus, wenn er bereits
    // markiert ist - der Anwender stellt 175 % noch einmal ein.
    sicherung.plane(175);
    vi.advanceTimersByTime(800);
    expect(liesSchriftgroesse(datei), 'der Fruehausstieg griff auf einen Wert, der nie ankam').toBe(
      175,
    );
  });

  it('bleibt beim gelungenen Weg bei einer einzigen Schreibung je Wert', () => {
    // Gegenprobe zu Befund B5: Ist der Wert wirklich gesichert, darf dieselbe
    // Stufe kein zweites Mal geschrieben werden.
    mkdirSync(profil);
    const sicherung = schriftsicherung(datei, SCHRIFT_STANDARD, 750);
    sicherung.plane(150);
    vi.advanceTimersByTime(800);
    expect(liesSchriftgroesse(datei)).toBe(150);

    rmSync(datei);
    sicherung.plane(150);
    vi.advanceTimersByTime(800);
    sicherung.jetzt();
    expect(existsSync(datei), 'derselbe Wert wurde ein zweites Mal geschrieben').toBe(false);
  });
});