Gallus_Pub/backend/src/services/image-refs.service.ts

import { db } from '../config/database.js';
import { events, galleryImages, contentSections } from '../db/schema.js';
import { AssetService } from './asset.service.js';
import { isManagedAsset, forgetManagedAsset } from './managed-assets.service.js';

const assets = new AssetService();

/**
 * Loescht eine Bilddatei, sofern das CMS sie selbst angelegt hat und kein
 * Datensatz sie mehr benutzt. Muss NACH dem Loeschen bzw. Aktualisieren der
 * Zeile aufgerufen werden.
 */
export async function dropImageIfUnused(url: string | null | undefined): Promise<boolean> {
  if (!url) return false;
  if (!(await isManagedAsset(url))) return false;

  const referenced = await collectReferencedImageUrls();
  if (referenced.has(url)) return false;

  const deleted = assets.deleteImage(url);
  await forgetManagedAsset(url);
  return deleted;
}

/**
 * Entfernt alle vom CMS angelegten Bilder, die nirgends mehr referenziert
 * werden. Die Referenzliste deckt bewusst ALLE Zeilen ab, auch
 * unveroeffentlichte - sonst verlieren die ihr Bild.
 */
export async function sweepOrphanedImages(): Promise<string[]> {
  const referenced = await collectReferencedImageUrls();
  const removed: string[] = [];

  for (const url of assets.listImageFiles()) {
    if (referenced.has(url)) continue;
    if (!(await isManagedAsset(url))) continue;

    if (assets.deleteImage(url)) removed.push(url);
    await forgetManagedAsset(url);
  }

  return removed;
}

/**
 * Sammelt jede Bild-URL, die irgendwo in der Datenbank vorkommt.
 *
 * Bewusst ueber ALLE Zeilen, nicht nur die veroeffentlichten - sonst wuerde
 * ein unveroeffentlichtes Event sein Bild verlieren, sobald jemand publisht.
 *
 * Die Content-Sections enthalten beliebiges JSON (Welcome-Bild, Monatshit,
 * Whiskey-Bilder), deshalb wird es rekursiv nach Bildpfaden durchsucht.
 */
export async function collectReferencedImageUrls(): Promise<Set<string>> {
  const urls = new Set<string>();

  for (const row of (await db.select().from(events)) as any[]) {
    if (row.imageUrl) urls.add(row.imageUrl);
  }

  for (const row of (await db.select().from(galleryImages)) as any[]) {
    if (row.imageUrl) urls.add(row.imageUrl);
  }

  for (const row of (await db.select().from(contentSections)) as any[]) {
    collectFromJson(row.contentJson, urls);
  }

  return urls;
}

/**
 * Ersetzt Bildpfade in einem beliebigen Content-JSON anhand einer Zuordnung
 * alt -> neu. Die Struktur bleibt dabei unveraendert.
 */
export function replaceImageUrls(value: any, mapping: Map<string, string>): any {
  if (typeof value === 'string') {
    return mapping.get(value) ?? value;
  }

  if (Array.isArray(value)) {
    return value.map((entry) => replaceImageUrls(entry, mapping));
  }

  if (value && typeof value === 'object') {
    const out: Record<string, any> = {};
    for (const [key, entry] of Object.entries(value)) {
      out[key] = replaceImageUrls(entry, mapping);
    }
    return out;
  }

  return value;
}

/** Alle Bildpfade aus einem beliebigen Content-JSON. */
export function extractImageUrls(value: any): Set<string> {
  const out = new Set<string>();
  collectFromJson(value, out);
  return out;
}

function collectFromJson(value: any, out: Set<string>): void {
  if (typeof value === 'string') {
    if (value.startsWith('/images/')) {
      out.add(value);
      return;
    }
    // Je nach Treiber kommt das JSON als String zurueck
    if (value.startsWith('{') || value.startsWith('[')) {
      try {
        collectFromJson(JSON.parse(value), out);
      } catch {
        // kein JSON - ignorieren
      }
    }
    return;
  }

  if (Array.isArray(value)) {
    for (const entry of value) collectFromJson(entry, out);
    return;
  }

  if (value && typeof value === 'object') {
    for (const entry of Object.values(value)) collectFromJson(entry, out);
  }
}