// Generische Datensicherung: spiegelt fertige Ergebnisse auf alle Backup-Ziele
// (NAS aus den Einstellungen + jedes delivery_target mit is_backup), optional mit
// begleitender Metadaten-.md-Datei. Struktur je Ziel: <Basisordner>/JJJJ-MM/.
import { one, query } from './db';
import { getObject } from './storage';
import { uploadBuffer, loadTargetConfig, type PicdropCfg } from './picdrop';
import { loadNasConfig } from './nas';
import { buildMetadataMd, sidecarName } from './metadata';

export interface BackupDest { key: string; label: string; cfg: PicdropCfg; sidecar: boolean; }

/** Alle aktiven Backup-Ziele einsammeln (inkl. Metadaten-Beileger-Flag pro Ziel). */
export async function backupDestinations(): Promise<BackupDest[]> {
  const dests: BackupDest[] = [];
  const nas = await loadNasConfig();
  if (nas) {
    const s = await one<any>('SELECT nas_metadata_sidecar FROM settings WHERE id=1');
    dests.push({ key: 'nas', label: 'NAS', cfg: nas, sidecar: !!s?.nas_metadata_sidecar });
  }
  const targets = await query<any>(`SELECT id, name, metadata_sidecar FROM delivery_targets WHERE is_backup=true`);
  for (const t of targets) {
    const cfg = await loadTargetConfig(t.id);
    if (cfg) dests.push({ key: t.id, label: t.name, cfg, sidecar: !!t.metadata_sidecar });
  }
  return dests;
}

/** Ein Item auf alle Backup-Ziele spiegeln. */
export async function backupItem(itemId: string): Promise<{ mirrored: number; failed: number }> {
  const dests = await backupDestinations();
  if (!dests.length) return { mirrored: 0, failed: 0 };
  const it = await one<any>('SELECT id, result_path, filename, created_at FROM items WHERE id=$1', [itemId]);
  if (!it?.result_path) return { mirrored: 0, failed: 0 };

  const buf = await getObject(it.result_path);
  const ym = new Date(it.created_at || Date.now()).toISOString().slice(0, 7);
  let md: Buffer | null = null;
  const anySidecar = dests.some((d) => d.sidecar);
  if (anySidecar) md = Buffer.from(await buildMetadataMd(itemId), 'utf8');

  let mirrored = 0, failed = 0;
  for (const d of dests) {
    try {
      await uploadBuffer(d.cfg, ym, it.filename || `${it.id}.png`, buf);
      if (d.sidecar && md) await uploadBuffer(d.cfg, ym, sidecarName(it.filename), md);
      await query(`INSERT INTO item_backups (item_id, target, status) VALUES ($1,$2,'mirrored')
                   ON CONFLICT (item_id, target) DO UPDATE SET status='mirrored', at=now()`, [itemId, d.key]);
      if (d.key === 'nas') await query(`UPDATE items SET nas_status='mirrored' WHERE id=$1`, [itemId]);
      mirrored++;
    } catch (e: any) {
      console.error('[backup]', d.label, itemId, e?.message || e);
      await query(`INSERT INTO item_backups (item_id, target, status) VALUES ($1,$2,'failed')
                   ON CONFLICT (item_id, target) DO UPDATE SET status='failed', at=now()`, [itemId, d.key]);
      if (d.key === 'nas') await query(`UPDATE items SET nas_status='failed' WHERE id=$1`, [itemId]);
      failed++;
    }
  }
  return { mirrored, failed };
}

/** Alle fertigen Bilder auf alle Backup-Ziele sichern (Nachsicherung). */
export async function backupAll(): Promise<{ items: number; mirrored: number; failed: number }> {
  const dests = await backupDestinations();
  if (!dests.length) return { items: 0, mirrored: 0, failed: 0 };
  const rows = await query<{ id: string }>(
    `SELECT id FROM items WHERE status='done' AND result_path IS NOT NULL ORDER BY created_at`);
  let mirrored = 0, failed = 0;
  for (const it of rows) { const r = await backupItem(it.id); mirrored += r.mirrored; failed += r.failed; }
  return { items: rows.length, mirrored, failed };
}