wp-to-nostr.ts

#!/usr/bin/env -S deno run --allow-net --allow-env=NOSTR_PRIVATE_KEY,DRY_RUN,FORCE_REPUBLISH,SYNC_MODE,WP_API_URL,WP_CATEGORY,NOSTR_RELAY,NOSTR_RELAYS,EXTRA_HASHTAGS,COMMUNITY_NPUBS
/**
 * wp-to-nostr.ts
 *
 * Holt WordPress-Termine über die REST-API und veröffentlicht sie als
 * Nostr kind:31923 Calendar-Events (NIP-52).
 *
 * Lokal testen (Dry-Run, kein Posting):
 *   deno task dry-run
 *
 * Lokal live (postet auf Relay):
 *   NOSTR_PRIVATE_KEY=nsec1… deno task start
 *
 * Konfiguration über Umgebungsvariablen:
 *   NOSTR_PRIVATE_KEY  – nsec1… oder 64-stellige Hex-Zeichenkette (Pflicht im Live-Modus)
 *   DRY_RUN            – 'true' → nur anzeigen, nichts posten (Standard: 'false')
 *   WP_API_URL         – WordPress REST-API-Endpunkt
 *                        (Standard: https://relilab.org/wp-json/wp/v2/posts)
 *   WP_CATEGORY        – Kategorie-ID (Standard: 176)
 *   NOSTR_RELAY        – Relay-URL (Standard: wss://relay-rpi.edufeed.org)
 */

// @deno-types="npm:@types/turndown"
import TurndownService from "turndown";
import { finalizeEvent, getPublicKey } from "nostr-tools";
import { Relay } from "nostr-tools/relay";
import { decode } from "nostr-tools/nip19";
// Deno hat natives WebSocket – kein ws-Paket nötig

// ── Typen ─────────────────────────────────────────────────────────────────────

interface WpPost {
  id: number;
  link: string;
  guid: { rendered: string };
  title: { rendered: string };
  content: { rendered: string };
  excerpt: { rendered: string };
  date_gmt: string;
  modified_gmt: string;
  acf?: {
    relilab_startdate?: string;
    relilab_enddate?: string;
    relilab_custom_zoom_link?: string;
  };
  featured_image_urls_v2?: { thumbnail?: string[] };
  taxonomy_info?: { post_tag?: Array<{ label: string }> };
  _embedded?: {
    author?: Array<{ name?: string; link?: string }>;
    "wp:featuredmedia"?: Array<{ caption?: { rendered?: string } }>;
  };
}

type SyncMode = "calendar" | "article";

export function kindForSyncMode(mode: SyncMode): number {
  return mode === "article" ? 30023 : 31923;
}

interface NostrEventTemplate {
  kind: number;
  created_at: number;
  tags: string[][];
  content: string;
}

// ── Konfiguration ─────────────────────────────────────────────────────────────

const WP_API_URL  = Deno.env.get("WP_API_URL")  ?? "https://relilab.org/wp-json/wp/v2/posts";
const WP_CATEGORY = Deno.env.get("WP_CATEGORY") ?? "176";
// Komma-separierte Relay-Liste. Beide Variablen werden zusammengeführt:
// - NOSTR_RELAY (Singular, rückwärtskompatibel zu früheren Workflow-Configs)
// - NOSTR_RELAYS (Plural, primär verwendet)
// Default = ein einzelnes edufeed-Relay, damit ein leerer Forks-Setup auch
// ohne explizite Konfiguration funktioniert.
const NOSTR_RELAY_RAW  = Deno.env.get("NOSTR_RELAY")  ?? "";
const NOSTR_RELAYS_RAW = Deno.env.get("NOSTR_RELAYS") ?? "";
const NOSTR_RELAYS = parseRelayList(`${NOSTR_RELAYS_RAW},${NOSTR_RELAY_RAW}`);
if (NOSTR_RELAYS.length === 0) NOSTR_RELAYS.push("wss://relay-rpi.edufeed.org");
const DRY_RUN     = Deno.env.get("DRY_RUN") === "true";
const FORCE_REPUBLISH = Deno.env.get("FORCE_REPUBLISH") === "true";
const SYNC_MODE: SyncMode = (Deno.env.get("SYNC_MODE") ?? "calendar") === "article"
  ? "article"
  : "calendar";
const PRIVKEY_RAW = Deno.env.get("NOSTR_PRIVATE_KEY") ?? "";
const EXTRA_HASHTAGS_RAW = Deno.env.get("EXTRA_HASHTAGS") ?? "";
const COMMUNITY_NPUBS_RAW = Deno.env.get("COMMUNITY_NPUBS") ?? "";

const EXTRA_HASHTAGS = parseExtraHashtags(EXTRA_HASHTAGS_RAW);
const COMMUNITY_HEX_PUBKEYS = parseCommunityNpubs(COMMUNITY_NPUBS_RAW);

// ── Privaten Schlüssel auflösen ───────────────────────────────────────────────

function resolvePrivkey(raw: string): Uint8Array {
  const trimmed = raw.trim();
  if (!trimmed) throw new Error("NOSTR_PRIVATE_KEY ist nicht gesetzt.");

  // nsec-Format (bech32)
  if (trimmed.startsWith("nsec")) {
    const decoded = decode(trimmed);
    if (decoded.type !== "nsec") throw new Error("Ungültiger nsec-Schlüssel.");
    return decoded.data as Uint8Array;
  }

  // Hex-Format (64 Zeichen)
  if (/^[0-9a-f]{64}$/i.test(trimmed)) {
    return Uint8Array.from(
      trimmed.match(/.{2}/g)!.map((byte) => parseInt(byte, 16))
    );
  }

  throw new Error("NOSTR_PRIVATE_KEY muss nsec1… oder eine 64-stellige Hex-Zeichenkette sein.");
}

// ── HTML → Markdown ───────────────────────────────────────────────────────────

const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });

function htmlToMarkdown(html: string): string {
  if (!html) return "";
  return turndown.turndown(html).trim();
}

// ── Relay-Liste parsen ────────────────────────────────────────────────────────
// Akzeptiert eine komma-separierte Liste von Relay-URLs. Dedupliziert
// case-insensitive auf der URL (z. B. WSS://Relay vs wss://relay).
// Leere Einträge werden ignoriert.

export function parseRelayList(raw: string): string[] {
  const seen = new Set<string>();
  const result: string[] = [];
  for (const rawEntry of raw.split(",")) {
    const entry = rawEntry.trim();
    if (!entry) continue;
    const norm = entry.toLowerCase();
    if (!seen.has(norm)) {
      seen.add(norm);
      result.push(entry);
    }
  }
  return result;
}

// ── Hashtag-Anreicherung ──────────────────────────────────────────────────────

export function parseExtraHashtags(raw: string): string[] {
  return raw
    .split(",")
    .map((entry) => entry.trim().replace(/^#/, ""))
    .filter((entry) => entry.length > 0);
}

export function mergeExtraHashtags(
  tags: string[][],
  extras: string[],
): string[][] {
  const existing = new Set(
    tags
      .filter((t) => t[0] === "t")
      .map((t) => (t[1] ?? "").toLowerCase()),
  );
  const result = tags.map((t) => [...t]);
  for (const extra of extras) {
    const norm = extra.toLowerCase();
    if (!existing.has(norm)) {
      result.push(["t", extra]);
      existing.add(norm);
    }
  }
  return result;
}

// ── Community-Zuordnung (Communikey h-Tag) ────────────────────────────────────

export function parseCommunityNpubs(raw: string): string[] {
  const seen = new Set<string>();
  const result: string[] = [];
  for (const rawEntry of raw.split(",")) {
    const entry = rawEntry.trim();
    if (!entry) continue;

    let hex: string;
    if (entry.startsWith("npub1")) {
      let decoded;
      try {
        decoded = decode(entry);
      } catch (err) {
        throw new Error(`COMMUNITY_NPUBS: ungültiger Eintrag „${entry}" (${(err as Error).message})`);
      }
      if (decoded.type !== "npub") {
        throw new Error(`COMMUNITY_NPUBS: ungültiger Eintrag „${entry}" (Typ ${decoded.type})`);
      }
      hex = (decoded.data as string).toLowerCase();
    } else if (/^[0-9a-f]{64}$/i.test(entry)) {
      hex = entry.toLowerCase();
    } else {
      throw new Error(`COMMUNITY_NPUBS: ungültiger Eintrag „${entry}"`);
    }

    if (!seen.has(hex)) {
      seen.add(hex);
      result.push(hex);
    }
  }
  return result;
}

export function mergeCommunityHTags(
  tags: string[][],
  hexPubkeys: string[],
): string[][] {
  const existing = new Set(
    tags
      .filter((t) => t[0] === "h")
      .map((t) => (t[1] ?? "").toLowerCase()),
  );
  const result = tags.map((t) => [...t]);
  for (const hex of hexPubkeys) {
    const norm = hex.toLowerCase();
    if (!existing.has(norm)) {
      result.push(["h", hex]);
      existing.add(norm);
    }
  }
  return result;
}

// ── Letzten Sync-Zeitstempel pro Relay ermitteln ─────────────────────────────
// Fragt jedes Relay nach dem neuesten eigenen Event des angegebenen kind und
// nimmt das Minimum über alle Relays. Wenn auch nur ein Relay leer ist oder
// einen Fehler liefert: Rückgabe null → der Caller macht einen Vollsync.

export interface RelayLike {
  subscribe(
    filters: Array<Record<string, unknown>>,
    handlers: {
      onevent?: (event: { created_at: number; tags?: string[][]; content?: string }) => void;
      oneose?: () => void;
    },
  ): { close: () => void };
}

const RELAY_QUERY_TIMEOUT_MS = 5000;

export async function getLastSyncTimestamp(
  pool: Array<{ url: string; relay: RelayLike | null }>,
  pubkeyHex: string,
  kind: number,
): Promise<number | null> {
  if (pool.length === 0) return null;

  const perRelay = await Promise.all(
    pool.map(({ url, relay }) => queryNewestCreatedAt(url, relay, pubkeyHex, kind)),
  );

  // Wenn auch nur ein Relay null lieferte: Vollsync.
  if (perRelay.some((v) => v === null)) return null;
  return Math.min(...perRelay as number[]);
}

function queryNewestCreatedAt(
  url: string,
  relay: RelayLike | null,
  pubkeyHex: string,
  kind: number,
): Promise<number | null> {
  return new Promise((resolve) => {
    if (!relay) {
      resolve(null);
      return;
    }

    let newest: number | null = null;
    let done = false;

    const finish = (value: number | null) => {
      if (done) return;
      done = true;
      try { sub?.close(); } catch { /* ignore */ }
      clearTimeout(timer);
      resolve(value);
    };

    const timer = setTimeout(() => {
      console.warn(`     ⚠️  ${url}: Timeout beim Abfragen des letzten Events`);
      finish(null);
    }, RELAY_QUERY_TIMEOUT_MS);

    let sub: { close: () => void } | undefined;
    try {
      sub = relay.subscribe(
        [{ authors: [pubkeyHex], kinds: [kind], limit: 1 }],
        {
          onevent: (evt) => {
            if (newest === null || evt.created_at > newest) newest = evt.created_at;
          },
          oneose: () => finish(newest),
        },
      );
      // Falls subscribe die Handler synchron gerufen hat (finish bereits durch),
      // war sub zu dem Zeitpunkt noch undefined — jetzt nachträglich schließen.
      if (done) {
        try { sub.close(); } catch { /* ignore */ }
      }
    } catch (err) {
      console.warn(`     ⚠️  ${url}: ${(err as Error).message}`);
      finish(null);
    }
  });
}

// ── Bestehende eigene Events pro Relay abrufen ───────────────────────────────
// Liefert eine Map d-Tag → neueste Bestandsversion (created_at, tags, content)
// für den Payload-Vergleich vor dem Publish. null = Zustand unbekannt
// (Connect-/Query-Fehler oder Timeout) → Caller publiziert sicherheitshalber.

export function fetchExistingEventsByD(
  url: string,
  relay: RelayLike | null,
  pubkeyHex: string,
  kind: number,
): Promise<Map<string, StoredEvent> | null> {
  return new Promise((resolve) => {
    if (!relay) {
      resolve(null);
      return;
    }

    const byD = new Map<string, StoredEvent>();
    let done = false;

    const finish = (value: Map<string, StoredEvent> | null) => {
      if (done) return;
      done = true;
      try { sub?.close(); } catch { /* ignore */ }
      clearTimeout(timer);
      resolve(value);
    };

    const timer = setTimeout(() => {
      console.warn(`     ⚠️  ${url}: Timeout beim Abrufen der Bestands-Events`);
      finish(null);
    }, RELAY_QUERY_TIMEOUT_MS);

    let sub: { close: () => void } | undefined;
    try {
      sub = relay.subscribe(
        [{ authors: [pubkeyHex], kinds: [kind] }],
        {
          onevent: (evt) => {
            const d = (evt.tags ?? []).find((t) => t[0] === "d")?.[1];
            if (d === undefined) return;
            const existing = byD.get(d);
            if (!existing || evt.created_at > existing.created_at) {
              byD.set(d, {
                created_at: evt.created_at,
                tags: evt.tags ?? [],
                content: evt.content ?? "",
              });
            }
          },
          oneose: () => finish(byD),
        },
      );
      if (done) {
        try { sub.close(); } catch { /* ignore */ }
      }
    } catch (err) {
      console.warn(`     ⚠️  ${url}: ${(err as Error).message}`);
      finish(null);
    }
  });
}

// ── WordPress REST-API (mit Pagination) ──────────────────────────────────────

export interface BuildWpUrlOpts {
  apiUrl: string;
  category: string;
  syncMode: SyncMode;
  page: number;
  modifiedAfter?: Date;
}

export function buildWpUrl(opts: BuildWpUrlOpts): string {
  const url = new URL(opts.apiUrl);
  url.searchParams.set("categories", opts.category);
  url.searchParams.set("per_page", "100");

  if (opts.syncMode === "calendar") {
    // Termine: nach Veröffentlichungsdatum sortieren. Die frühere Sortierung
    // nach relilab_startdate (orderby=meta_value) wird von der WP-API
    // inzwischen mit 400 abgelehnt; funktional ist die Reihenfolge egal,
    // weil alle Seiten geholt und alle Events einzeln publiziert werden.
    url.searchParams.set("orderby", "date");
    url.searchParams.set("order", "desc");
  } else {
    // Article: nach Veröffentlichungsdatum, mit Autor- und Beitragsbild-Embed
    // (Caption des Beitragsbilds enthält die Bildlizenz)
    url.searchParams.set("orderby", "date");
    url.searchParams.set("order", "desc");
    url.searchParams.set("_embed", "author,wp:featuredmedia");
  }

  url.searchParams.set("page", String(opts.page));

  if (opts.modifiedAfter) {
    // ISO-8601 mit "Z" — WP-REST-API (Core ≥ 5.7) akzeptiert UTC-Suffix.
    // Sekundengenau, ohne Millisekunden.
    const iso = opts.modifiedAfter.toISOString().replace(/\.\d{3}Z$/, "Z");
    url.searchParams.set("modified_after", iso);
  }

  return url.toString();
}

async function fetchWpPosts(modifiedAfter?: Date): Promise<WpPost[]> {
  const all: WpPost[] = [];
  let page = 1;
  let totalPages = 1;

  do {
    const url = buildWpUrl({
      apiUrl: WP_API_URL,
      category: WP_CATEGORY,
      syncMode: SYNC_MODE,
      page,
      modifiedAfter,
    });
    console.log(`  Seite ${page}/${totalPages} – ${url}`);

    const res = await fetch(url);
    if (!res.ok) throw new Error(`WordPress API Fehler (Seite ${page}): ${res.status} ${res.statusText}`);

    // Gesamtseitenanzahl aus Response-Header lesen
    totalPages = Number(res.headers.get("X-WP-TotalPages") ?? "1");
    const posts = await res.json() as WpPost[];
    all.push(...posts);
    page++;
  } while (page <= totalPages);

  return all;
}

// ── Datumskonvertierung ───────────────────────────────────────────────────────
// WP speichert "YYYY-MM-DD HH:MM:SS" als Berliner Lokalzeit (kein TZ-Suffix).
// Vorgehen: naive UTC-Referenz → Intl zeigt Berliner Wanduhrzeit zu diesem
// UTC-Moment → Differenz = Berliner UTC-Offset → korrigierter Unix-Timestamp.
//
// Beispiel: "2026-03-13 16:00:00" (Berlin CET = UTC+1)
//   naiveUtc  → 16:00 UTC (falsch, aber Referenz)
//   Berlin zeigt bei 16:00 UTC → 17:00 Uhr
//   offsetMs  = 16:00 UTC − 17:00 UTC = −3600 ms
//   Ergebnis  = 16:00 UTC + (−1h) = 15:00 UTC ✓  (= 16:00 Berlin)

function wpDateToUnix(dateStr: string | undefined): number {
  if (!dateStr) return 0;
  const naiveUtc = new Date(dateStr.replace(" ", "T") + "Z");
  if (isNaN(naiveUtc.getTime())) return 0;

  const parts = new Intl.DateTimeFormat("en-CA", {
    timeZone: "Europe/Berlin",
    year: "numeric", month: "2-digit", day: "2-digit",
    hour: "2-digit", minute: "2-digit", second: "2-digit",
    hour12: false,
  }).formatToParts(naiveUtc);

  const g = (type: string) => parts.find(p => p.type === type)?.value ?? "00";
  const berlinWallClock = new Date(
    `${g("year")}-${g("month")}-${g("day")}T${g("hour")}:${g("minute")}:${g("second")}Z`
  );

  const offsetMs = naiveUtc.getTime() - berlinWallClock.getTime();
  return Math.floor((naiveUtc.getTime() + offsetMs) / 1000);
}

// ── created_at-Berechnung (gemeinsam für Calendar + Article) ─────────────────
// kind:31923 und kind:30023 sind beide adressierbar — gleicher d-Tag +
// gleicher/älterer created_at → Relay ignoriert das Event, höherer →
// Relay ersetzt. Wir nutzen modified_gmt mit einem 2025-01-01-Floor, damit
// alte Posts nicht "too early" abgelehnt werden. FORCE_REPUBLISH=true
// überschreibt einmalig mit Date.now(), für rückwirkende Anreicherungen.

function computeCreatedAt(modifiedGmt: string): number {
  const MIN_CREATED_AT = 1735689600;  // 2025-01-01T00:00:00Z
  const modifiedAt = Math.floor(
    new Date(modifiedGmt + "Z").getTime() / 1000
  ) || Math.floor(Date.now() / 1000);
  return FORCE_REPUBLISH
    ? Math.floor(Date.now() / 1000)
    : Math.max(modifiedAt, MIN_CREATED_AT);
}

// ── HTML-Entitäten in Titel dekodieren ───────────────────────────────────────
function decodeHtmlEntities(s: string): string {
  return s
    .replace(/&#(\d+);/g, (_, dec: string) => String.fromCharCode(Number(dec)))
    .replace(/&amp;/g, "&")
    .replace(/&lt;/g,  "<")
    .replace(/&gt;/g,  ">");
}

// ── WordPress-Post → Nostr-Event mappen ──────────────────────────────────────

export function mapPostToCalendarEvent(
  post: WpPost,
  nowSec: number = Math.floor(Date.now() / 1000),
): NostrEventTemplate | null {
  const startTs = wpDateToUnix(post.acf?.relilab_startdate);
  const endTs   = wpDateToUnix(post.acf?.relilab_enddate);

  // Posts ohne Startdatum überspringen (kein gültiges Kalender-Event)
  if (!startTs) return null;

  // Bereits vergangene Termine überspringen: WP-Edits an alten Posts (z. B.
  // Saison-Aufräumen) bumpen modified_gmt und würden den Termin sonst mit
  // frischem created_at erneut in die Timeline spülen. Laufende Termine
  // (Ende in der Zukunft) bleiben synchronisiert.
  if (Math.max(startTs, endTs) < nowSec) return null;

  // d-Tag + r-Tag: originale WordPress-Permalink-URL
  const wpUrl = post.link ?? post.guid?.rendered ?? String(post.id);

  // Titel bereinigen (HTML-Entitäten dekodieren)
  const title = decodeHtmlEntities(post.title?.rendered ?? "");

  // HTML → Markdown
  const contentMd = htmlToMarkdown(post.content?.rendered ?? "");
  const summaryMd = htmlToMarkdown(post.excerpt?.rendered ?? "");

  // Location (Zoom-Link)
  const zoomLink = (post.acf?.relilab_custom_zoom_link ?? "").trim();
  const location = zoomLink ? `Zoom: ${zoomLink}` : "";

  // Beitragsbild
  const image = post.featured_image_urls_v2?.thumbnail?.[0] ?? "";

  // Schlagwörter → ["t", label]
  const keywordTags = (post.taxonomy_info?.post_tag ?? [])
    .map((t) => ["t", t.label]);

  // Nostr-Tags-Array (NIP-52 / kind 31923)
  const tags: string[][] = [
    ["d",          wpUrl],
    ["title",      title],
    ["start",      String(startTs)],
    ["start_tzid", "Europe/Berlin"],
    ["end",        String(endTs)],
    ["end_tzid",   "Europe/Berlin"],
  ];
  if (summaryMd) tags.push(["summary", summaryMd]);
  if (location)  tags.push(["location", location]);
  if (image)     tags.push(["image", image]);
  tags.push(["r", wpUrl]);
  tags.push(...keywordTags);

  let enrichedTags = mergeExtraHashtags(tags, EXTRA_HASHTAGS);
  enrichedTags = mergeCommunityHTags(enrichedTags, COMMUNITY_HEX_PUBKEYS);

  return {
    kind: 31923,
    created_at: computeCreatedAt(post.modified_gmt),
    tags: enrichedTags,
    content: contentMd,
  };
}

// ── WordPress-Post → Nostr Long-Form-Article (kind:30023) ────────────────────
// Für Beiträge ohne Termin-Charakter (z. B. Lernmodule, Blog-Posts).
// Autor*in wird als Markdown-Header oben in den Content eingefügt — solange
// keine eigenen Autoren-npubs existieren, bleibt die Zuschreibung im Text
// sichtbar und kann später durch echte pubkey-Zuordnung ersetzt werden.
export function mapPostToArticleEvent(post: WpPost): NostrEventTemplate {
  const wpUrl = post.link ?? post.guid?.rendered ?? String(post.id);
  const title = decodeHtmlEntities(post.title?.rendered ?? "");
  const contentMd = htmlToMarkdown(post.content?.rendered ?? "");
  const summaryMd = htmlToMarkdown(post.excerpt?.rendered ?? "");
  const image = post.featured_image_urls_v2?.thumbnail?.[0] ?? "";

  // published_at: WP-Veröffentlichungs-Zeitstempel (date_gmt) — bleibt stabil,
  // unabhängig von späteren Bearbeitungen. created_at hingegen reflektiert
  // die letzte Änderung (für Replace-Logik).
  const publishedAt = Math.floor(
    new Date(post.date_gmt + "Z").getTime() / 1000
  ) || Math.floor(Date.now() / 1000);

  // Autor-Header in den Content packen — sichtbare Zuschreibung
  const author = post._embedded?.author?.[0];
  const authorName = author?.name ?? "";
  const authorLink = author?.link ?? "";
  const authorLine = authorName
    ? authorLink
      ? `> Erstellt von: [${authorName}](${authorLink})`
      : `> Erstellt von: ${authorName}`
    : "";
  const sourceLine = `> Veröffentlicht auf [relilab.org](${wpUrl})`;

  // Caption des Beitragsbilds (enthält bei relilab die Bildlizenz) als
  // Blockquote-Zeile(n) in den Header — jede Zeile einzeln prefixen,
  // damit mehrzeilige Captions im Blockquote bleiben.
  const captionMd = htmlToMarkdown(
    post._embedded?.["wp:featuredmedia"]?.[0]?.caption?.rendered ?? "",
  );
  const captionLines = captionMd
    .split("\n")
    .filter((line) => line.trim().length > 0)
    .map((line) => `> ${line}`)
    .join("\n");

  const headerBlock = [authorLine, sourceLine, captionLines].filter(Boolean).join("\n") + "\n\n";
  const fullContent = headerBlock + contentMd;

  const keywordTags = (post.taxonomy_info?.post_tag ?? [])
    .map((t) => ["t", t.label]);

  // Nostr-Tags-Array (NIP-23 / kind 30023)
  const tags: string[][] = [
    ["d",            wpUrl],
    ["title",        title],
    ["published_at", String(publishedAt)],
  ];
  if (summaryMd) tags.push(["summary", summaryMd]);
  if (image)     tags.push(["image", image]);
  tags.push(["r", wpUrl]);
  tags.push(...keywordTags);

  let enrichedTags = mergeExtraHashtags(tags, EXTRA_HASHTAGS);
  enrichedTags = mergeCommunityHTags(enrichedTags, COMMUNITY_HEX_PUBKEYS);

  return {
    kind: 30023,
    created_at: computeCreatedAt(post.modified_gmt),
    tags: enrichedTags,
    content: fullContent,
  };
}

// ── Unveränderte Events erkennen ─────────────────────────────────────────────
// Ein reiner modified_gmt-Bump in WordPress (Bulk-Edit, Plugin-Save) darf kein
// Republish auslösen. Deshalb wird vor dem Publish die inhaltliche Identität
// (tags + content, ohne created_at) gegen die Bestandsversion auf jedem Relay
// verglichen — analog zum Content-Addressing in edufeed-data.

export interface StoredEvent {
  created_at: number;
  tags: string[][];
  content: string;
}

export function eventPayloadEquals(
  a: { tags: string[][]; content: string },
  b: { tags: string[][]; content: string },
): boolean {
  // Tag-Reihenfolge trägt keine Semantik und ist nicht stabil (WP liefert
  // Schlagwörter in wechselnder Reihenfolge) → sortiert vergleichen.
  const tagKey = (tags: string[][]) =>
    JSON.stringify(tags.map((t) => JSON.stringify(t)).sort());
  return a.content === b.content && tagKey(a.tags) === tagKey(b.tags);
}

// Entscheidet pro Relay, ob publiziert wird:
//   existing = StoredEvent → nur bei abweichendem Payload
//   existing = null        → Event fehlt auf dem Relay → publizieren (Backfill)
//   existing = undefined   → Zustand unbekannt (Query-Fehler) → publizieren
// Hält ein Ziel-Relay bereits eine neuere Version mit anderem Payload (z. B.
// aus einem früheren FORCE_REPUBLISH), wird created_at darüber angehoben,
// sonst würde das adressierbare Event dort mit „have newer" abgelehnt.
export function planPublish(
  evt: NostrEventTemplate,
  existingByRelay: Array<{ url: string; existing: StoredEvent | null | undefined }>,
): { relayUrls: string[]; createdAt: number } {
  const relayUrls: string[] = [];
  let createdAt = evt.created_at;
  for (const { url, existing } of existingByRelay) {
    if (existing && eventPayloadEquals(evt, existing)) continue;
    relayUrls.push(url);
    if (existing && existing.created_at >= createdAt) {
      createdAt = existing.created_at + 1;
    }
  }
  return { relayUrls, createdAt };
}

// ── Auf Nostr veröffentlichen ─────────────────────────────────────────────────

interface PublishResult {
  url: string;
  ok: boolean;
  error?: string;
  skipped?: boolean;  // Relay hat neuere Version
}

// Publiziert ein Event auf alle übergebenen Relays parallel. Failures auf
// einzelnen Relays brechen den Lauf nicht ab — sie werden im Ergebnis
// dokumentiert und nach allen Events aggregiert.
async function publishEvent(
  eventTemplate: NostrEventTemplate,
  privkey: Uint8Array,
  relays: Array<{ url: string; relay: Relay | null }>,
): Promise<PublishResult[]> {
  const signed = finalizeEvent(eventTemplate, privkey);
  console.log(`     → Event-ID: ${signed.id}`);

  const results = await Promise.all(
    relays.map(async ({ url, relay }): Promise<PublishResult> => {
      if (!relay) return { url, ok: false, error: "nicht verbunden" };
      try {
        await relay.publish(signed);
        return { url, ok: true };
      } catch (err) {
        const msg = (err as Error).message;
        if (msg.includes("replaced: have newer")) {
          return { url, ok: true, skipped: true };
        }
        return { url, ok: false, error: msg };
      }
    }),
  );
  return results;
}

// ── Hauptprogramm ─────────────────────────────────────────────────────────────

async function main(): Promise<void> {
  const modeLabel = SYNC_MODE === "article"
    ? "📰 Article-Sync (kind:30023 Long-Form)"
    : "📅 Calendar-Sync (kind:31923 Termine)";

  console.log(`\n🔄 WordPress → Nostr Sync — ${modeLabel}`);
  console.log(`   Relays: ${NOSTR_RELAYS.join(", ")}`);
  console.log(`   Modus : ${DRY_RUN
    ? "🧪 DRY RUN – keine Events werden tatsächlich gesendet"
    : "🚀 LIVE – Events werden auf Nostr veröffentlicht"}\n`);

  // Privkey/Pubkey nur im Live-Modus
  let privkey: Uint8Array | null = null;
  let pubkeyHex: string | null = null;
  if (!DRY_RUN) {
    privkey = resolvePrivkey(PRIVKEY_RAW);
    pubkeyHex = getPublicKey(privkey);
    console.log(`🔑 Öffentlicher Schlüssel (hex): ${pubkeyHex}\n`);
  }

  // Relay-Pool VOR dem WP-Fetch aufbauen, damit wir den Cutoff bestimmen können.
  const relayPool: Array<{ url: string; relay: Relay | null }> = [];
  if (!DRY_RUN) {
    console.log(`🔌 Verbinde mit ${NOSTR_RELAYS.length} Relay(s) …`);
    for (const url of NOSTR_RELAYS) {
      try {
        const relay = await Relay.connect(url);
        relayPool.push({ url, relay });
        console.log(`   ✅ ${url}`);
      } catch (err) {
        relayPool.push({ url, relay: null });
        console.error(`   ❌ ${url}: ${(err as Error).message}`);
      }
    }
    console.log();
  }

  try {
    // Cutoff für inkrementellen Sync ermitteln.
    let cutoff: Date | undefined = undefined;
    if (!FORCE_REPUBLISH && !DRY_RUN && pubkeyHex) {
      console.log("🔎 Letzten Sync-Zeitstempel von Relays abfragen …");
      const lastTs = await getLastSyncTimestamp(
        relayPool,
        pubkeyHex,
        kindForSyncMode(SYNC_MODE),
      );
      if (lastTs !== null) {
        // 60s Sicherheitspuffer gegen Clock-Drift.
        cutoff = new Date((lastTs - 60) * 1000);
        console.log(`   Letztes Event: ${new Date(lastTs * 1000).toISOString()}`);
        console.log(`   Cutoff (−60s): ${cutoff.toISOString()}\n`);
      } else {
        console.log("   Kein gemeinsamer Cutoff verfügbar → Vollsync.\n");
      }
    } else if (FORCE_REPUBLISH) {
      console.log("⚡ FORCE_REPUBLISH=true → Filter wird übersprungen, Vollsync.\n");
    } else if (DRY_RUN) {
      console.log("🧪 DRY RUN → kein Cutoff-Query, Vollsync für Anzeige.\n");
    }

    // Bestands-Events pro Relay abrufen (d-Tag → neueste Version) für den
    // Payload-Vergleich vor dem Publish. Bei FORCE_REPUBLISH bewusst leer,
    // damit alles publiziert wird.
    const existingMaps = new Map<string, Map<string, StoredEvent> | null>();
    if (!DRY_RUN && !FORCE_REPUBLISH && pubkeyHex) {
      console.log("🔎 Bestands-Events von Relays abrufen …");
      const maps = await Promise.all(
        relayPool.map(({ url, relay }) =>
          fetchExistingEventsByD(url, relay, pubkeyHex!, kindForSyncMode(SYNC_MODE))
        ),
      );
      relayPool.forEach(({ url }, i) => {
        existingMaps.set(url, maps[i]);
        console.log(`   ${url}: ${maps[i] === null ? "unbekannt (Fehler/Timeout)" : `${maps[i]!.size} Events`}`);
      });
      console.log();
    }

    // 1. WordPress-Posts holen (optional gefiltert)
    console.log("📥 WordPress-Posts abrufen …");
    const posts = await fetchWpPosts(cutoff);
    console.log(`   ${posts.length} Posts gefunden\n`);

    // 2. Filtern & mappen
    // Explizite Lambda: map(fn) würde den Array-Index als nowSec durchreichen.
    const events: NostrEventTemplate[] = SYNC_MODE === "article"
      ? posts.map(mapPostToArticleEvent)
      : posts.map((p) => mapPostToCalendarEvent(p)).filter(
          (e): e is NostrEventTemplate => e !== null,
        );
    const itemLabel = SYNC_MODE === "article" ? "Artikel" : "Termine";
    const droppedCount = posts.length - events.length;
    console.log(`📅 ${events.length} ${itemLabel} zum Synchronisieren` + (
      SYNC_MODE === "calendar" && droppedCount > 0
        ? ` (${droppedCount} übersprungen: vergangen oder ohne Startdatum)\n`
        : "\n"
    ));

    if (events.length === 0) {
      console.log("✅ Nichts zu veröffentlichen – alles aktuell.");
      return;
    }

    // 3. Veröffentlichen oder Dry-Run-Ausgabe
    const perRelayStats = new Map<string, { ok: number; skipped: number; failed: number }>();
    for (const url of NOSTR_RELAYS) {
      perRelayStats.set(url, { ok: 0, skipped: 0, failed: 0 });
    }
    let eventsAcceptedSomewhere = 0;
    let eventsRejectedEverywhere = 0;

    for (const evt of events) {
      const title = evt.tags.find((t) => t[0] === "title")?.[1] ?? "(kein Titel)";
      console.log(`  📌 "${title}"`);

      if (SYNC_MODE === "article") {
        const pubSec = Number(evt.tags.find((t) => t[0] === "published_at")?.[1] ?? 0);
        const pubStr = pubSec ? new Date(pubSec * 1000).toISOString().slice(0, 10) : "?";
        console.log(`     Veröff.: ${pubStr}`);
      } else {
        const startSec = Number(evt.tags.find((t) => t[0] === "start")?.[1] ?? 0);
        const startStr = startSec ? new Date(startSec * 1000).toISOString() : "?";
        console.log(`     Start : ${startStr}`);
      }

      if (DRY_RUN) {
        console.log("     [DRY RUN] Tags:", JSON.stringify(evt.tags));
        console.log(`     [DRY RUN] Content (${evt.content.length} Zeichen): ${evt.content.slice(0, 120)}…`);
      } else {
        // Nur auf Relays publizieren, deren Bestandsversion fehlt oder
        // inhaltlich abweicht — ein reiner modified_gmt-Bump wird übersprungen.
        const dTag = evt.tags.find((t) => t[0] === "d")?.[1] ?? "";
        const existingByRelay = relayPool.map(({ url }) => {
          const m = existingMaps.get(url);
          return { url, existing: m ? (m.get(dTag) ?? null) : undefined };
        });
        const plan = planPublish(evt, existingByRelay);
        const unchangedCount = relayPool.length - plan.relayUrls.length;
        for (const { url } of relayPool) {
          if (!plan.relayUrls.includes(url)) perRelayStats.get(url)!.skipped++;
        }

        if (plan.relayUrls.length === 0) {
          console.log("     ⏭️  unverändert – auf allen Relays aktuell");
          eventsAcceptedSomewhere++;
          console.log();
          continue;
        }
        if (unchangedCount > 0) {
          console.log(`     ⏭️  ${unchangedCount} Relay(s) unverändert übersprungen`);
        }

        const targets = relayPool.filter(({ url }) => plan.relayUrls.includes(url));
        const results = await publishEvent(
          { ...evt, created_at: plan.createdAt },
          privkey!,
          targets,
        );
        let acceptedCount = unchangedCount;
        for (const r of results) {
          const stat = perRelayStats.get(r.url)!;
          if (r.ok && r.skipped) {
            stat.skipped++;
            acceptedCount++;
          } else if (r.ok) {
            stat.ok++;
            acceptedCount++;
          } else {
            stat.failed++;
            console.error(`     ❌ ${r.url}: ${r.error}`);
          }
        }
        const okCount = results.filter((r) => r.ok && !r.skipped).length;
        const skipCount = results.filter((r) => r.ok && r.skipped).length;
        const failCount = results.filter((r) => !r.ok).length;
        console.log(`     ✅ ${okCount} ok, ⏭️  ${skipCount} skipped, ❌ ${failCount} failed`);

        if (acceptedCount > 0) eventsAcceptedSomewhere++;
        else eventsRejectedEverywhere++;
      }
      console.log();
    }

    // Zusammenfassung
    console.log("📊 Zusammenfassung:");
    if (DRY_RUN) {
      console.log(`   ${events.length} Events bereit (Dry Run – nichts wurde gesendet)`);
    } else {
      console.log(`   ${eventsAcceptedSomewhere}/${events.length} Events von mindestens einem Relay akzeptiert`);
      if (eventsRejectedEverywhere > 0) {
        console.log(`   ⚠️  ${eventsRejectedEverywhere} Events von keinem Relay akzeptiert`);
      }
      console.log(`   Pro Relay:`);
      for (const [url, s] of perRelayStats) {
        console.log(`     ${url}: ${s.ok} ok · ${s.skipped} skipped · ${s.failed} failed`);
      }
    }
  } finally {
    for (const { relay } of relayPool) relay?.close();
    if (!DRY_RUN) console.log("\n🔌 Relay-Verbindungen geschlossen");
  }
}

if (import.meta.main) {
  main().catch((err: Error) => {
    console.error("\n💥 Fatal:", err.message);
    Deno.exit(1);
  });
}