Wp2ghost/CSharpGhostImporter/Converter.cs

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Net;
using System.Net.Http;
using HtmlAgilityPack;
using wp2ghost;

// Die Web-Oberfläche (Projekt Wp2GhostUI) ruft dieselben Abläufe auf wie das Konsolenmenü
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Wp2GhostUI")]

/// <summary>
/// Der Importer: Einstellungen und alle Abläufe. Bedient wird er entweder über das
/// Konsolenmenü (Main) oder über die Web-Oberfläche, die dieselben Methoden aufruft.
/// Rückfragen laufen in beiden Fällen über Console.ReadLine/Write.
/// </summary>
class Importer
{
    internal static string WpBaseUrl = "https://deine-domain.com";
    internal static string OutputZipPath = "ghost_import.zip";
    internal static int MaxPosts = -1;
    private static string ConfigPath = "";
    internal static string BaseDir = "";

    /// <summary>Zugangsdaten einer Ghost-Instanz.</summary>
    internal class GhostTarget
    {
        public string Name = "";
        public string Url = "";
        public string AdminApiKey = "";
        public string ContentApiKey = "";
        public bool IsConfigured => Url.Length > 0 && AdminApiKey.Length > 0;
    }

    /// <summary>
    /// Zwei Ghost-Instanzen, zwischen denen umgeschaltet werden kann. Gesendet, geprüft und
    /// abgeglichen wird immer mit der aktiven; Slug-Zuordnungen und hochgeladene Videos führt
    /// jede Instanz für sich. Das Archiv (ghostPosts/archiv/) ist für beide gemeinsam.
    /// </summary>
    internal static readonly GhostTarget[] GhostTargets = { new(), new() };
    internal static int ActiveGhost { get; private set; }
    internal static GhostTarget Ghost => GhostTargets[ActiveGhost];

    // Die Zugangsdaten der aktiven Instanz — so bleiben alle bisherigen Aufrufe unverändert
    internal static string GhostUrl { get => Ghost.Url; set => Ghost.Url = value; }
    internal static string GhostAdminApiKey { get => Ghost.AdminApiKey; set => Ghost.AdminApiKey = value; }
    internal static string GhostContentApiKey { get => Ghost.ContentApiKey; set => Ghost.ContentApiKey = value; }

    /// <summary>Anzeigename einer Instanz: der vergebene Name, sonst die Adresse, sonst "Ghost 1/2".</summary>
    internal static string GhostLabel(int index)
    {
        var target = GhostTargets[index];
        if (target.Name.Length > 0) return target.Name;
        if (target.Url.Length > 0) return target.Url.Replace("https://", "").Replace("http://", "").TrimEnd('/');
        return $"Ghost {index + 1}";
    }

    /// <summary>
    /// Datei im Datenordner, die nur für die aktive Instanz gilt. Die erste Instanz behält die
    /// bisherigen Dateinamen, die zweite bekommt "_2" angehängt (z. B. slug_zuordnung_2.txt).
    /// </summary>
    internal static string InstanceFile(string fileName) =>
        Path.Combine(BaseDir, ActiveGhost == 0 ? fileName
            : $"{Path.GetFileNameWithoutExtension(fileName)}_{ActiveGhost + 1}{Path.GetExtension(fileName)}");

    /// <summary>Lädt die Einstellungen aus dem Datenordner und richtet alle Bausteine darauf ein.</summary>
    internal static void Initialize(string baseDir)
    {
        BaseDir = baseDir;
        ConfigPath = Path.Combine(BaseDir, "config.txt");

        LoadConfig();
        ImageManager.Init(BaseDir);
        MediaManager.Init(BaseDir);
        InternalLinkManager.Init(BaseDir);
        PostFetcher.Init(BaseDir);
        GhostExporter.Init(BaseDir);
        LinkDecisionManager.Init(BaseDir);
        ActivateGhost();
    }

    /// <summary>Speichert geänderte Einstellungen und meldet Ghost mit den neuen Zugangsdaten an.</summary>
    internal static void ApplySettings()
    {
        SaveConfig();
        ActivateGhost();
    }

    /// <summary>Macht eine der beiden Ghost-Instanzen zur aktiven und merkt sich die Wahl.</summary>
    internal static void SwitchGhost(int index)
    {
        if (index < 0 || index >= GhostTargets.Length || index == ActiveGhost) return;
        ActiveGhost = index;
        SaveConfig();
        ActivateGhost();
        Console.WriteLine($"Aktive Ghost-Instanz: {GhostLabel(index)}");
    }

    // Meldet Ghost mit den Zugangsdaten der aktiven Instanz an und lädt deren Slug-Zuordnungen
    private static void ActivateGhost()
    {
        GhostApi.Init(GhostUrl, GhostAdminApiKey, GhostContentApiKey, ImageManager.ImageContainerPath);
        SlugAssignments.Init(InstanceFile("slug_zuordnung.txt"));
    }

    static async Task Main(string[] args)
    {
        Initialize(Directory.GetCurrentDirectory());

        Console.OutputEncoding = System.Text.Encoding.UTF8;
        // Damit Emojis/Sonderzeichen beim manuellen Editieren eingegeben werden können
        if (!Console.IsInputRedirected)
        {
            try { Console.InputEncoding = System.Text.Encoding.Unicode; } catch { }
        }
        Console.Title = "WP2Ghost Converter";


        bool running = true;
        while (running)
        {
            ShowMenu();
            string? choice = Console.ReadLine()?.Trim();

            switch (choice)
            {
                case "1":
                    await PostFetcher.FetchFromWordPressAsync(WpBaseUrl, MaxPosts);
                    break;
                case "2":
                    await GhostExporter.CreateZipAsync();
                    break;
                case "3":
                    ConfigureSettings();
                    break;
                case "4":
                    ShowCacheInfo();
                    break;
                case "5":
                    PostFetcher.ClearProcessedPosts();
                    break;
                case "6":
                    ImageManager.ClearAll();
                    break;
                case "7":
                    await GhostMenuAsync();
                    break;
                case "8":
                    LinkDecisionManager.ShowInfo();
                    break;
                case "9":
                    ChooseGhost();
                    break;
                case "0":
                    ImageManager.SaveCache();
                    LinkDecisionManager.Save();
                    running = false;
                    Console.WriteLine("Programm beendet. Auf Wiedersehen!");
                    break;
                default:
                    Console.WriteLine("Ungültige Auswahl. Bitte erneut eingeben.");
                    break;
            }
        }
    }

    static void ShowMenu()
    {
        Console.WriteLine();
        Console.WriteLine("=========================================");
        Console.WriteLine("       WP2Ghost - WordPress to Ghost");
        Console.WriteLine("=========================================");
        Console.WriteLine($"WordPress-URL       : {WpBaseUrl}");
        Console.WriteLine($"Ausgabe-Datei       : {OutputZipPath}");
        Console.WriteLine($"Max. Beiträge/Seiten: {(MaxPosts == -1 ? "Alle" : MaxPosts.ToString())}");
        Console.WriteLine($"Abgefragte Objekte  : {PostFetcher.ProcessedCount}");
        Console.WriteLine($"Ghost-Instanz       : {ActiveGhost + 1} – {GhostLabel(ActiveGhost)}");
        Console.WriteLine($"Ghost-URL           : {(string.IsNullOrEmpty(GhostUrl) ? "(nicht konfiguriert)" : GhostUrl)}");
        Console.WriteLine($"Ghost-Status        : {(GhostApi.IsConfigured() ? "verbunden" : "nicht konfiguriert")}");
        Console.WriteLine("-----------------------------------------");
        Console.WriteLine("  1 - Von WordPress abrufen (Posts & Pages)");
        Console.WriteLine("  2 - Ghost ZIP erstellen");
        Console.WriteLine("  3 - Einstellungen konfigurieren");
        Console.WriteLine("  4 - Cache-Informationen anzeigen");
        Console.WriteLine("  5 - Abgefragte Objekte zurücksetzen");
        Console.WriteLine("  6 - Bilder lokal löschen");
        Console.WriteLine("  7 - Beiträge direkt an Ghost senden");
        Console.WriteLine("  8 - Gespeicherte Link-Entscheidungen anzeigen");
        Console.WriteLine("  9 - Ghost-Instanz wechseln");
        Console.WriteLine("  0 - Beenden");
        Console.WriteLine("-----------------------------------------");
        Console.Write("Auswahl: ");
    }

    static void LoadConfig()
    {
        if (!File.Exists(ConfigPath))
        {
            SaveConfig();
            Console.WriteLine($"Neue Konfigurationsdatei erstellt: {ConfigPath}");
            return;
        }

        try
        {
            var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            foreach (var line in File.ReadAllLines(ConfigPath))
            {
                if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
                    continue;

                var parts = line.Split('=', 2);
                if (parts.Length == 2)
                    values[parts[0].Trim()] = parts[1].Trim();
            }

            if (values.TryGetValue("wpBaseUrl", out string? wpBaseUrl)) WpBaseUrl = wpBaseUrl;
            if (values.TryGetValue("outputZipPath", out string? outputZipPath)) OutputZipPath = outputZipPath;
            if (values.TryGetValue("maxPosts", out string? maxPosts) && int.TryParse(maxPosts, out int max)) MaxPosts = max;

            for (int i = 0; i < GhostTargets.Length; i++)
            {
                string prefix = GhostConfigPrefix(i);
                var target = GhostTargets[i];
                target.Name = values.GetValueOrDefault(prefix + "Name", "");
                target.Url = values.GetValueOrDefault(prefix + "Url", "");
                target.AdminApiKey = values.GetValueOrDefault(prefix + "AdminApiKey", "");
                target.ContentApiKey = values.GetValueOrDefault(prefix + "ContentApiKey", "");
            }
            if (values.TryGetValue("activeGhost", out string? active) && int.TryParse(active, out int number)
                && number >= 1 && number <= GhostTargets.Length)
                ActiveGhost = number - 1;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler beim Laden der Konfiguration: {ex.Message}");
        }
    }

    // Schlüssel in config.txt: die erste Instanz behält die bisherigen (ghostUrl ...), die zweite heißt ghost2Url ...
    private static string GhostConfigPrefix(int index) => index == 0 ? "ghost" : $"ghost{index + 1}";

    static void SaveConfig()
    {
        var lines = new List<string>
        {
            "# WP2Ghost Konfiguration",
            "# Ändere die Werte und starte das Programm neu",
            "",
            $"wpBaseUrl={WpBaseUrl}",
            $"outputZipPath={OutputZipPath}",
            $"maxPosts={MaxPosts}",
            "",
            "# Ghost API (optional - für direkten Push). Zwei Instanzen, activeGhost wählt die aktive (1 oder 2).",
            $"activeGhost={ActiveGhost + 1}",
        };
        for (int i = 0; i < GhostTargets.Length; i++)
        {
            string prefix = GhostConfigPrefix(i);
            var target = GhostTargets[i];
            lines.Add("");
            lines.Add($"{prefix}Name={target.Name}");
            lines.Add($"{prefix}Url={target.Url}");
            lines.Add($"{prefix}AdminApiKey={target.AdminApiKey}");
            if (!string.IsNullOrEmpty(target.ContentApiKey))
                lines.Add($"{prefix}ContentApiKey={target.ContentApiKey}");
        }
        File.WriteAllLines(ConfigPath, lines);
    }

    static void ChooseGhost()
    {
        Console.WriteLine();
        Console.WriteLine("--- Ghost-Instanz wechseln ---");
        for (int i = 0; i < GhostTargets.Length; i++)
        {
            string state = GhostTargets[i].IsConfigured ? GhostTargets[i].Url : "(nicht eingerichtet)";
            Console.WriteLine($"  {i + 1} - {GhostLabel(i)}{(i == ActiveGhost ? "  [aktiv]" : "")}  {state}");
        }
        Console.Write("Auswahl (leer = unverändert): ");
        if (int.TryParse(Console.ReadLine()?.Trim(), out int number) && number >= 1 && number <= GhostTargets.Length)
            SwitchGhost(number - 1);
        if (!Ghost.IsConfigured)
            Console.WriteLine("Diese Instanz ist noch nicht eingerichtet: bitte Option 3 (Einstellungen) nutzen.");
    }

    static void ConfigureSettings()
    {
        Console.WriteLine();
        Console.WriteLine("--- Einstellungen konfigurieren ---");
        Console.Write($"WordPress-URL [{WpBaseUrl}]: ");
        string? input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            WpBaseUrl = input;

        Console.Write($"Ausgabe-Datei [{OutputZipPath}]: ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            OutputZipPath = input;

        Console.Write($"Maximale Anzahl Posts (leer = alle) [{(MaxPosts == -1 ? "alle" : MaxPosts.ToString())}]: ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input) && int.TryParse(input, out int max))
            MaxPosts = max;

        Console.WriteLine();
        Console.WriteLine($"--- Ghost API (optional) – Instanz {ActiveGhost + 1}, wechseln mit Option 9 ---");
        Console.Write($"Name der Instanz [{Ghost.Name}]: ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            Ghost.Name = input;

        Console.Write($"Ghost-URL [{GhostUrl}]: ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            GhostUrl = input;

        Console.Write($"Ghost Admin API Key [{(string.IsNullOrEmpty(GhostAdminApiKey) ? "(nicht gesetzt)" : "****")}] : ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            GhostAdminApiKey = input;

        Console.Write($"Ghost Content API Key [{(string.IsNullOrEmpty(GhostContentApiKey) ? "(nicht gesetzt)" : "****")}] : ");
        input = Console.ReadLine()?.Trim();
        if (!string.IsNullOrEmpty(input))
            GhostContentApiKey = input;

        ApplySettings();
        Console.WriteLine("Einstellungen gespeichert.");
    }

    static void ShowCacheInfo()
    {
        Console.WriteLine();
        Console.WriteLine("--- Cache-Informationen ---");
        Console.WriteLine($"Abgefragte Objekte: {PostFetcher.ProcessedCount}");
        Console.WriteLine($"Ghost-Beiträge geladen: {GhostExporter.PostCount}");

        ImageManager.ShowInfo();
        PostFetcher.ShowInfo();
    }

    static async Task GhostMenuAsync()
    {
        if (!GhostApi.IsConfigured())
        {
            Console.WriteLine();
            Console.WriteLine("Ghost API nicht konfiguriert. Bitte zuerst Option 3 (Einstellungen) nutzen.");
            return;
        }

        bool inGhostMenu = true;
        while (inGhostMenu)
        {
            Console.WriteLine();
            Console.WriteLine("=========================================");
            Console.WriteLine("       Ghost Admin API");
            Console.WriteLine("=========================================");
            Console.WriteLine($"  Instanz      : {ActiveGhost + 1} – {GhostLabel(ActiveGhost)}");
            Console.WriteLine($"  Ghost-URL    : {GhostUrl}");
            Console.WriteLine("-----------------------------------------");
            Console.WriteLine("  1 - Posts anzeigen (Ghost)");
            Console.WriteLine("  2 - Post lesen (nach ID)");
            Console.WriteLine("  3 - Post erstellen");
            Console.WriteLine("  4 - Post bearbeiten");
            Console.WriteLine("  5 - Post löschen");
            Console.WriteLine("  6 - Alle lokalen Posts an Ghost senden");
            Console.WriteLine("  7 - Bilder hochladen");
            Console.WriteLine("  8 - Post aus JSON erstellen/aktualisieren");
            Console.WriteLine("  9 - Untertag zu allen Posts mit einem bestimmten Tag hinzufügen");
            Console.WriteLine(" 10 - Posts in Ghost prüfen und korrigieren (z. B. Postdatum)");
            Console.WriteLine("  0 - Zurück zum Hauptmenü");
            Console.WriteLine("-----------------------------------------");
            Console.Write("Auswahl: ");

            string? choice = Console.ReadLine()?.Trim();
            switch (choice)
            {
                case "1":
                    await GhostBrowsePostsAsync();
                    break;
                case "2":
                    await GhostReadPostAsync();
                    break;
                case "3":
                    await GhostCreatePostAsync();
                    break;
                case "4":
                    await GhostEditPostAsync();
                    break;
                case "5":
                    await GhostDeletePostAsync();
                    break;
                case "6":
                    await GhostApi.PushAllPostsAsync(html => InternalLinkManager.Rewrite(HtmlGhostConverter.Convert(html), WpBaseUrl, GhostUrl).Html);
                    break;
                case "7":
                    await GhostUploadImagesAsync();
                    break;
                case "8":
                    await GhostCreateOrUpdateFromJsonAsync();
                    break;
                case "9":
                    await GhostAddTagToTaggedPostsAsync();
                    break;
                case "10":
                    await PostChecker.RunAsync(BaseDir);
                    break;
                case "0":
                    inGhostMenu = false;
                    break;
                default:
                    Console.WriteLine("Ungültige Auswahl.");
                    break;
            }
        }
    }

    static async Task GhostBrowsePostsAsync()
    {
        Console.Write("Filter (leer = alle, z.B. status:published): ");
        string? filter = Console.ReadLine()?.Trim();
        Console.Write("Anzahl (leer = 50): ");
        string? limitStr = Console.ReadLine()?.Trim();
        int limit = int.TryParse(limitStr, out int l) ? l : 50;

        Console.WriteLine();
        Console.WriteLine("Lade Posts von Ghost...");
        var posts = await GhostApi.BrowsePostsAsync(filter ?? "", limit);

        if (posts.Count == 0)
        {
            Console.WriteLine("Keine Posts gefunden.");
            return;
        }

        Console.WriteLine();
        Console.WriteLine($"  {"ID",-24} {"Status",-12} {"Titel"}");
        Console.WriteLine($"  {new string('-', 23)} {new string('-', 11)} {new string('-', 30)}");
        foreach (var post in posts)
        {
            Console.WriteLine($"  {post.Id,-24} {post.Status,-12} {post.Title}");
        }
        Console.WriteLine();
        Console.WriteLine($"  Gesamt: {posts.Count} Posts");
    }

    static async Task GhostReadPostAsync()
    {
        Console.Write("Post-ID: ");
        string? id = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(id)) return;

        var post = await GhostApi.GetPostAsync(id);
        if (post == null)
        {
            Console.WriteLine("Post nicht gefunden.");
            return;
        }

        Console.WriteLine();
        Console.WriteLine($"  ID          : {post.Id}");
        Console.WriteLine($"  Titel       : {post.Title}");
        Console.WriteLine($"  Slug        : {post.Slug}");
        Console.WriteLine($"  Status      : {post.Status}");
        Console.WriteLine($"  Erstellt    : {post.CreatedAt}");
        Console.WriteLine($"  Aktualisiert: {post.UpdatedAt}");
        Console.WriteLine($"  Feature Img : {post.FeatureImage ?? "(keine)"}");
        Console.WriteLine($"  HTML ({(post.Html?.Length ?? 0)} Zeichen):");
        Console.WriteLine($"  {new string('-', 50)}");
        string preview = post.Html ?? "";
        if (preview.Length > 500) preview = preview[..500] + "...";
        Console.WriteLine($"  {preview}");
    }

    static async Task GhostCreatePostAsync()
    {
        Console.Write("Titel: ");
        string? title = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(title)) return;

        Console.Write("HTML-Inhalt: ");
        string? html = Console.ReadLine()?.Trim();

        // Links validieren und ggf. korrigieren
        html = await ValidateAndFixLinksAsync(html);

        Console.Write("Status (published/draft) [published]: ");
        string? status = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(status)) status = "published";

        Console.Write("Slug (leer = automatisch): ");
        string? slug = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(slug)) slug = null;

        Console.WriteLine();
        Console.Write("Erstelle Post...");
        var post = await GhostApi.CreatePostAsync(title, html ?? "", status, slug);
        if (post != null)
            Console.WriteLine($" OK (ID: {post.Id})");
        else
            Console.WriteLine(" FEHLER");
    }

    static async Task GhostEditPostAsync()
    {
        Console.Write("Post-ID: ");
        string? id = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(id)) return;

        var existing = await GhostApi.GetPostAsync(id);
        if (existing == null)
        {
            Console.WriteLine("Post nicht gefunden.");
            return;
        }

        Console.WriteLine($"  Aktueller Titel: {existing.Title}");
        Console.Write("Neuer Titel (Enter = unverändert): ");
        string? title = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(title)) title = existing.Title;

        Console.Write("Neuer HTML-Inhalt (Enter = unverändert): ");
        string? html = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(html)) html = existing.Html;

        Console.Write($"Neuer Status ({existing.Status}): ");
        string? status = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(status)) status = existing.Status;

        Console.WriteLine();
        Console.Write("Aktualisiere Post...");
        var updated = await GhostApi.UpdatePostAsync(id, title ?? "", html ?? "", existing.UpdatedAt ?? "", status ?? "published");
        if (updated != null)
            Console.WriteLine(" OK");
        else
            Console.WriteLine(" FEHLER");
    }

    static async Task GhostDeletePostAsync()
    {
        Console.Write("Post-ID: ");
        string? id = Console.ReadLine()?.Trim();
        if (string.IsNullOrEmpty(id)) return;

        var post = await GhostApi.GetPostAsync(id);
        if (post == null)
        {
            Console.WriteLine("Post nicht gefunden.");
            return;
        }

        Console.WriteLine($"  Post: {post.Title}");
        Console.Write("Wirklich löschen? (j/n): ");
        string? confirm = Console.ReadLine()?.Trim();
        if (confirm?.ToLower() != "j") return;

        Console.Write("Lösche Post...");
        bool success = await GhostApi.DeletePostAsync(id);
        Console.WriteLine(success ? " OK" : " FEHLER");
    }

    static async Task GhostUploadImagesAsync()
    {
        var cachedFiles = ImageManager.CachedFiles;
        if (cachedFiles.Count == 0)
        {
            Console.WriteLine("Keine Bilder im Cache. Bitte zuerst Option 1 (Abruf) nutzen.");
            return;
        }

        Console.WriteLine($"  {cachedFiles.Count} Bilder zum Hochladen vorhanden.");
        Console.Write("Alle Bilder hochladen? (j/n): ");
        string? confirm = Console.ReadLine()?.Trim();
        if (confirm?.ToLower() != "j") return;

        int uploaded = 0;
        foreach (var file in cachedFiles)
        {
            Console.Write($"   [Upload] {Path.GetFileName(file.LocalPath)}...");
            string? url = await GhostApi.UploadImageAsync(file.LocalPath);
            if (url != null)
            {
                Console.WriteLine($" -> {url}");
                uploaded++;
            }
            else
                Console.WriteLine(" FEHLER");
        }

        Console.WriteLine();
        Console.WriteLine($"  Hochgeladen: {uploaded}/{cachedFiles.Count}");
    }

    // =========================================================================
    // HTML-Links validieren und bei Bedarf korrigieren
    // =========================================================================
    private static async Task<string> ValidateAndFixLinksAsync(string? html)
    {
        if (string.IsNullOrWhiteSpace(html)) return html ?? "";

        var doc = new HtmlDocument();
        doc.LoadHtml(html);

        // Alle <a>-Tags suchen
        var anchors = doc.DocumentNode.SelectNodes("//a[@href]");
        if (anchors == null) return html;

        bool repaired = false;
        var candidates = new List<(string text, string href, HtmlNode node)>();
        foreach (var anchor in anchors)
        {
            string href = anchor.GetAttributeValue("href", "").Trim();
            if (string.IsNullOrEmpty(href)) continue;

            // Eindeutig reparierbare Adressen (z. B. von \"...\" umschlossen) stillschweigend korrigieren
            string? fixedHref = LinkChecker.TryRepair(HtmlEntity.DeEntitize(href));
            if (fixedHref != null)
            {
                Console.WriteLine($"  [Links] Adresse repariert: {fixedHref}");
                anchor.SetAttributeValue("href", fixedHref);
                href = fixedHref;
                repaired = true;
            }

            // Links auf die eigene Ghost-Seite nicht prüfen: das Ziel wird evtl. erst später importiert
            if (!string.IsNullOrEmpty(GhostUrl) && href.StartsWith(GhostUrl.TrimEnd('/'), StringComparison.OrdinalIgnoreCase)) continue;

            candidates.Add((anchor.InnerText.Trim(), href, anchor));
        }

        // Erreichbarkeit parallel prüfen (begrenzt, damit kein Server mit Anfragen überhäuft wird)
        using var throttle = new SemaphoreSlim(6);
        var reasons = await Task.WhenAll(candidates.Select(async c =>
        {
            await throttle.WaitAsync();
            try { return await LinkChecker.CheckAsync(HtmlEntity.DeEntitize(c.href)); }
            finally { throttle.Release(); }
        }));

        var invalidLinks = new List<(string text, string href, HtmlNode node, string reason)>();
        for (int i = 0; i < candidates.Count; i++)
        {
            if (reasons[i] != null)
                invalidLinks.Add((candidates[i].text, candidates[i].href, candidates[i].node, reasons[i]!));
        }

        if (invalidLinks.Count == 0) return repaired ? doc.DocumentNode.OuterHtml : html;

        // User über invaliden Links informieren und zur Korrektur auffordern
        Console.WriteLine($"\n  {invalidLinks.Count} ungültiger Link(s) gefunden:");
        for (int i = 0; i < invalidLinks.Count; i++)
        {
            Console.WriteLine($"  [{i + 1}] {invalidLinks[i].reason} | Text: \"{invalidLinks[i].text}\" | Link: {invalidLinks[i].href}");
        }

        Console.WriteLine("\nOptionen pro Link:");
        Console.WriteLine("  d = Link löschen (Text bleibt, <a>-Tag entfernt)");
        Console.WriteLine("  e = Link bearbeiten (neue URL eingeben)");
        Console.WriteLine("  k = Link so übernehmen (beibehalten)");
        Console.WriteLine("  Enter = frühere Entscheidung für diesen Link (nur wenn es eine gibt)");

        // Für jeden invaliden Link die User-Entscheidung einholen
        foreach (var (linkText, linkHref, anchorNode, linkReason) in invalidLinks)
        {
            // Für die Web-Oberfläche: um welchen Link es bei den folgenden Rückfragen geht
            LinkQuestion.Current = new LinkQuestion(linkText, HtmlEntity.DeEntitize(linkHref), linkReason);

            // 1. Memory: Frühere Entscheidung suchen und vorschlagen
            var previous = LinkDecisionManager.GetPreviousDecision(linkText, linkHref);

            Console.WriteLine($"\n  ---------------------------------------------");
            Console.WriteLine($"  Link-Text : \"{linkText}\"");
            Console.WriteLine($"  Aktueller Link : {linkHref}");

            if (previous != null)
            {
                string prevInfo = previous.Decision switch
                {
                    "delete" => "LÖSCHEN",
                    "edit" => $"ERSETZEN durch '{previous.NewUrl}'",
                    _ => "BEIBEHALTEN"
                };
                Console.WriteLine($"  [Memory] Frühere Entscheidung: {prevInfo} (vom {previous.Timestamp:dd.MM.yyyy HH:mm})");
            }

            // 2. Grund nennen und Browser-Öffnen anbieten
            string searchQuery = Uri.EscapeDataString(linkText);
            string searchUrl = $"https://www.google.com/search?q={searchQuery}";
            Console.WriteLine($"  Problem : {linkReason}");

            // Gibt es schon eine Entscheidung für diesen Link, ist sie der Default (Enter).
            // Ohne frühere Entscheidung MUSS der User eine treffen — Enter allein genügt dann nicht.
            string options = "k=beibehalten / d=löschen / e=bearbeiten / b=Browser öffnen";
            if (previous != null)
            {
                string defaultLabel = previous.Decision switch
                {
                    "delete" => "wie zuvor: löschen",
                    "edit" => $"wie zuvor: ersetzen durch '{previous.NewUrl}'",
                    _ => "wie zuvor: beibehalten"
                };
                options = $"Enter={defaultLabel} / {options}";
            }

            string decision = "";
            string? newUrl = null;
            while (decision == "")
            {
                Console.Write($"  Optionen: [{options}]: ");
                string? input = Console.ReadLine();
                if (input == null)
                {
                    // Keine Eingabe möglich (stdin geschlossen): nichts ändern und nichts merken,
                    // damit beim nächsten Lauf erneut gefragt wird
                    decision = previous != null ? "previous" : "unanswered";
                    break;
                }

                switch (input.Trim().ToLowerInvariant())
                {
                    case "b":
                        Console.WriteLine($"    -> Öffne Browser mit Suche nach: \"{linkText}\"");
                        OpenBrowser(searchUrl);
                        break;
                    case "":
                    case "v":
                        if (previous != null) decision = "previous";
                        else Console.WriteLine("    Für diesen Link gibt es noch keine Entscheidung – bitte k, d oder e wählen.");
                        break;
                    case "k":
                        decision = "keep";
                        break;
                    case "d":
                        decision = "delete";
                        break;
                    case "e":
                        Console.Write("  Neue URL eingeben: ");
                        newUrl = Console.ReadLine()?.Trim();
                        if (!string.IsNullOrEmpty(newUrl)) decision = "edit";
                        else Console.WriteLine("    Keine URL eingegeben – bitte erneut wählen.");
                        break;
                    default:
                        Console.WriteLine("    Ungültige Eingabe – bitte k, d oder e wählen.");
                        break;
                }
            }

            switch (decision)
            {
                case "previous":
                    ApplyDecision(anchorNode, previous!, linkText, linkHref, ref html, doc);
                    Console.WriteLine($"    -> Frühere Entscheidung angewendet: {previous!.Decision}");
                    break;
                case "delete":
                    // Link löschen: <a>-Tag entfernen, Text erhalten
                    anchorNode.ParentNode?.ReplaceChild(HtmlNode.CreateNode(anchorNode.InnerText), anchorNode);
                    Console.WriteLine($"    -> Link gelöscht");
                    LinkDecisionManager.SaveDecision(linkText, linkHref, "delete");
                    break;
                case "edit":
                    anchorNode.SetAttributeValue("href", newUrl!);
                    Console.WriteLine($"    -> Auf '{newUrl}' aktualisiert");
                    LinkDecisionManager.SaveDecision(linkText, linkHref, "edit", newUrl);
                    break;
                case "keep":
                    Console.WriteLine($"    -> Beibehalten");
                    LinkDecisionManager.SaveDecision(linkText, linkHref, "keep");
                    break;
                default:
                    Console.WriteLine($"    -> Keine Eingabe möglich, Link bleibt unverändert (wird beim nächsten Lauf erneut gefragt)");
                    break;
            }
        }
        LinkQuestion.Current = null;

        return doc.DocumentNode.OuterHtml;
    }

    // =========================================================================
    // Problemfälle im Text: mehrere "?" hintereinander
    // Entstehen, wenn Zeichen (Emojis, griechische/arabische Schrift ...) bei einer
    // früheren Konvertierung verloren gingen. Pro Fundstelle entscheidet der User:
    // löschen, manuell editieren oder beibehalten. Entscheidungen werden gemerkt.
    // =========================================================================

    // "??" und längere Folgen, auch über Leer-/Satzzeichen hinweg ("???? ??? ?????, ????")
    private static readonly System.Text.RegularExpressions.Regex QuestionMarkRunRegex = new(
        @"\?{2,}(?:[\s,.;:\-/]*\?+)*", System.Text.RegularExpressions.RegexOptions.Compiled);

    // Kennung, unter der Text-Entscheidungen im Link-Memory abgelegt werden (statt einer URL)
    private const string TextProblemMarker = "text:fragezeichen";

    private static string ReviewQuestionMarksInHtml(string html)
    {
        if (string.IsNullOrEmpty(html) || !QuestionMarkRunRegex.IsMatch(html)) return html;

        var doc = new HtmlDocument();
        doc.LoadHtml(html);

        // Nur sichtbarer Text — keine URLs/Attribute, kein Code
        var textNodes = doc.DocumentNode.SelectNodes("//text()[not(ancestor::script) and not(ancestor::style) and not(ancestor::code) and not(ancestor::pre)]");
        if (textNodes == null) return html;

        bool changed = false;
        foreach (var node in textNodes.ToList())
        {
            string original = node.InnerHtml;
            if (!QuestionMarkRunRegex.IsMatch(original)) continue;

            string reviewed = ReviewQuestionMarksInText(original, "Text", htmlEncoded: true);
            if (reviewed == original) continue;

            node.ParentNode!.ReplaceChild(doc.CreateTextNode(reviewed), node);
            changed = true;
        }

        return changed ? doc.DocumentNode.OuterHtml : html;
    }

    private static string ReviewQuestionMarksInText(string text, string where, bool htmlEncoded = false)
    {
        if (string.IsNullOrEmpty(text)) return text;

        return QuestionMarkRunRegex.Replace(text, match =>
        {
            // Umgebung der Fundstelle anzeigen, die "?"-Folge hervorgehoben
            int from = Math.Max(0, match.Index - 50);
            int to = Math.Min(text.Length, match.Index + match.Length + 30);
            string before = text.Substring(from, match.Index - from);
            string after = text.Substring(match.Index + match.Length, to - match.Index - match.Length);
            string context = WebUtility.HtmlDecode($"{before}»{match.Value}«{after}").Trim();

            var previous = LinkDecisionManager.GetPreviousDecision(context, TextProblemMarker);
            if (previous != null)
            {
                string result = ApplyTextDecision(previous.Decision, previous.NewUrl, match.Value, htmlEncoded);
                Console.WriteLine($"  [Text] Frühere Entscheidung angewendet ({previous.Decision}): {context}");
                return result;
            }

            Console.WriteLine();
            Console.WriteLine($"  [Problemfall {where}] Mehrere '?' – vermutlich verlorene Zeichen:");
            Console.WriteLine($"    {context}");
            Console.Write("  Optionen: [l=löschen / e=manuell editieren / Enter=beibehalten]: ");
            string? choice = Console.ReadLine()?.Trim().ToLowerInvariant();

            if (choice == "l")
            {
                LinkDecisionManager.SaveDecision(context, TextProblemMarker, "delete");
                Console.WriteLine("    -> gelöscht");
                return ApplyTextDecision("delete", null, match.Value, htmlEncoded);
            }

            if (choice == "e")
            {
                Console.Write($"  Ersatz für »{match.Value}« eingeben: ");
                string? replacement = Console.ReadLine();
                if (!string.IsNullOrEmpty(replacement))
                {
                    LinkDecisionManager.SaveDecision(context, TextProblemMarker, "edit", replacement);
                    Console.WriteLine($"    -> ersetzt durch '{replacement}'");
                    return ApplyTextDecision("edit", replacement, match.Value, htmlEncoded);
                }
            }

            LinkDecisionManager.SaveDecision(context, TextProblemMarker, "keep");
            Console.WriteLine("    -> beibehalten");
            return match.Value;
        });
    }

    private static string ApplyTextDecision(string decision, string? replacement, string original, bool htmlEncoded) => decision switch
    {
        "delete" => "",
        "edit" when !string.IsNullOrEmpty(replacement) => htmlEncoded ? WebUtility.HtmlEncode(replacement) : replacement,
        _ => original
    };

    // =========================================================================
    // Hilfsmethoden für Link-Entscheidungen
    // =========================================================================

    /// <summary>
    /// Wendet eine gespeicherte (frühere) Entscheidung auf den Link an.
    /// </summary>
    private static void ApplyDecision(HtmlNode anchorNode, LinkDecision decision, string linkText, string linkHref, ref string? html, HtmlDocument doc)
    {
        if (decision.Decision == "delete")
        {
            var parent = anchorNode.ParentNode;
            if (parent != null)
            {
                parent.ReplaceChild(HtmlNode.CreateNode(anchorNode.InnerText), anchorNode);
            }
        }
        else if (decision.Decision == "edit" && !string.IsNullOrEmpty(decision.NewUrl))
        {
            anchorNode.SetAttributeValue("href", decision.NewUrl);
        }
        // "keep" = nichts tun
    }

    /// <summary>
    /// Öffnet die Standard-Browser-Anwendung mit der angegebenen URL.
    /// </summary>
    private static void OpenBrowser(string url)
    {
        try
        {
            var psi = new System.Diagnostics.ProcessStartInfo
            {
                FileName = url,
                UseShellExecute = true
            };
            System.Diagnostics.Process.Start(psi);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"    [Browser-Fehler] Konnte Browser nicht öffnen: {ex.Message}");
        }
    }

    /// <summary>
    /// Hängt an alle Posts in Ghost, die einen bestimmten Tag tragen, einen weiteren Tag an
    /// (z. B. alle "Zypern"-Posts zusätzlich nach "Unsere Reisen"). Der neue Tag wird angelegt,
    /// falls es ihn noch nicht gibt, und steht hinter den vorhandenen Tags — der primäre Tag
    /// eines Posts ändert sich nicht.
    /// </summary>
    static async Task GhostAddTagToTaggedPostsAsync()
    {
        try
        {
            var allTags = await GhostApi.BrowseTagsWithCountsAsync();
            if (allTags.Count == 0)
            {
                Console.WriteLine("  In Ghost gibt es noch keine Tags.");
                return;
            }

            Console.WriteLine($"  {allTags.Count} Tags in Ghost (Anzahl Posts):");
            foreach (var tag in allTags)
                Console.WriteLine($"    {tag.Name} ({tag.Count?.Posts ?? 0})");

            Console.Write("Posts mit welchem Tag? (Name, leer = Abbruch): ");
            string sourceName = Console.ReadLine()?.Trim() ?? "";
            if (sourceName.Length == 0) return;

            var sourceTag = allTags.FirstOrDefault(t => string.Equals(t.Name, sourceName, StringComparison.OrdinalIgnoreCase))
                         ?? allTags.FirstOrDefault(t => string.Equals(t.Slug, sourceName, StringComparison.OrdinalIgnoreCase));
            if (sourceTag?.Slug == null)
            {
                Console.WriteLine($"  Tag '{sourceName}' gibt es in Ghost nicht.");
                return;
            }

            Console.Write($"Welcher Untertag soll zu allen '{sourceTag.Name}'-Posts hinzugefügt werden? (leer = Abbruch): ");
            string newName = Console.ReadLine()?.Trim() ?? "";
            if (newName.Length == 0) return;
            if (string.Equals(newName, sourceTag.Name, StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine("  Das ist derselbe Tag.");
                return;
            }

            var posts = await GhostApi.BrowsePostsByTagAsync(sourceTag.Slug);
            var missing = posts.Where(p => !(p.Tags ?? new()).Any(t => string.Equals(t.Name, newName, StringComparison.OrdinalIgnoreCase))).ToList();
            Console.WriteLine($"  {posts.Count} Post(s) mit '{sourceTag.Name}', davon {posts.Count - missing.Count} bereits mit '{newName}'.");
            if (missing.Count == 0)
            {
                Console.WriteLine("  Nichts zu tun.");
                return;
            }

            bool exists = allTags.Any(t => string.Equals(t.Name, newName, StringComparison.OrdinalIgnoreCase));
            Console.Write($"  '{newName}'{(exists ? "" : " (wird neu angelegt)")} zu {missing.Count} Post(s) hinzufügen? (j/n): ");
            if (Console.ReadLine()?.Trim().ToLowerInvariant() != "j") return;

            var newTag = (await GhostApi.EnsureTagsAsync(new List<WpCategory> { new WpCategory { Name = newName } })).FirstOrDefault();
            if (newTag?.Id == null)
            {
                Console.WriteLine($"  [Fehler] Tag '{newName}' konnte nicht angelegt werden.");
                return;
            }

            int done = 0;
            foreach (var post in missing)
            {
                Console.Write($"   [{done + 1}/{missing.Count}] {post.Title}...");
                // Vorhandene Tags in ihrer Reihenfolge behalten, den neuen hinten anhängen
                var tagIds = (post.Tags ?? new()).Where(t => t.Id != null).Select(t => t.Id!).Append(newTag.Id).Distinct();
                bool ok = await GhostApi.SetPostTagsAsync(post.Id!, post.UpdatedAt ?? "", tagIds);
                Console.WriteLine(ok ? " OK" : " FEHLER");
                if (!ok)
                {
                    Console.WriteLine($"  ABBRUCH wegen eines Fehlers. {done} von {missing.Count} Post(s) geändert.");
                    return;
                }
                done++;
            }
            Console.WriteLine($"  '{newTag.Name}' zu {done} Post(s) hinzugefügt.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"  [Fehler] {ex.Message}");
        }
    }

    /// <summary>
    /// Sendet einen Post oder einen Bereich von Posts (Von–Bis) aus ghostPosts/ an Ghost.
    /// Beim ersten Fehler wird abgebrochen. Danach können die erfolgreich gesendeten Posts
    /// archiviert werden (ghostPosts/archiv/), damit sie nicht mehr in der Auswahlliste stehen.
    /// </summary>
    static async Task GhostCreateOrUpdateFromJsonAsync()
    {
        string ghostPostsDir = Path.Combine(BaseDir, "ghostPosts");
        if (!Directory.Exists(ghostPostsDir))
        {
            Console.WriteLine("Verzeichnis 'ghostPosts' nicht gefunden.");
            return;
        }

        // Nach ID sortiert (numerisch), damit Von–Bis der angezeigten Reihenfolge entspricht
        var available = Directory.GetFiles(ghostPostsDir, "*.json")
            .Select(f => (Path: f, Name: Path.GetFileNameWithoutExtension(f)))
            .Where(f => int.TryParse(f.Name, out _))
            .Select(f => (f.Path, Id: int.Parse(f.Name)))
            .OrderBy(f => f.Id)
            .ToList();
        if (available.Count == 0)
        {
            Console.WriteLine("Keine JSON-Dateien in ghostPosts/ vorhanden.");
            return;
        }

        Console.WriteLine($"  {available.Count} verfügbare Posts:");
        foreach (var f in available)
        {
            Console.Write($"    {f.Id} - ");
            try
            {
                var preview = JsonSerializer.Deserialize<GhostPostFile>(File.ReadAllText(f.Path));
                Console.WriteLine(preview?.Title ?? "(kein Titel)");
            }
            catch { Console.WriteLine("(Fehler beim Lesen)"); }
        }

        Console.Write("Von ID (leer = Abbruch): ");
        if (!int.TryParse(Console.ReadLine()?.Trim(), out int fromId)) return;

        Console.Write($"Bis ID (leer = nur {fromId}): ");
        string? toInput = Console.ReadLine()?.Trim();
        int toId = fromId;
        if (!string.IsNullOrEmpty(toInput) && !int.TryParse(toInput, out toId))
        {
            Console.WriteLine("Ungültige Bis-ID.");
            return;
        }
        if (toId < fromId) (fromId, toId) = (toId, fromId);

        var selected = available.Where(f => f.Id >= fromId && f.Id <= toId).ToList();
        if (selected.Count == 0)
        {
            Console.WriteLine($"Keine Posts im Bereich {fromId}–{toId} gefunden.");
            return;
        }

        if (selected.Count > 1)
        {
            Console.Write($"  {selected.Count} Posts ({selected[0].Id}–{selected[^1].Id}) an Ghost senden? (j/n): ");
            if (Console.ReadLine()?.Trim().ToLowerInvariant() != "j") return;
        }

        await SendPostsAsync(selected);
    }

    /// <summary>
    /// Sendet die übergebenen Posts der Reihe nach an die aktive Ghost-Instanz, bricht beim ersten
    /// Fehler ab und bietet danach an, die erfolgreich gesendeten zu archivieren.
    /// </summary>
    internal static async Task SendPostsAsync(List<(string Path, int Id)> selected)
    {
        Console.WriteLine($"Ziel: {GhostLabel(ActiveGhost)} ({GhostUrl})");
        string ghostPostsDir = Path.Combine(BaseDir, "ghostPosts");
        var succeeded = new List<(string Path, int Id)>();
        (string Path, int Id)? failed = null;
        for (int i = 0; i < selected.Count; i++)
        {
            Console.WriteLine();
            Console.WriteLine($"=== [{i + 1}/{selected.Count}] Post {selected[i].Id} ===");

            bool ok;
            try
            {
                ok = await ImportPostFromJsonAsync(selected[i].Path);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  [Fehler] {ex.Message}");
                ok = false;
            }

            if (!ok)
            {
                failed = selected[i];
                break;
            }
            succeeded.Add(selected[i]);
        }

        Console.WriteLine();
        Console.WriteLine("=========================================");
        Console.WriteLine($"  Erfolgreich: {succeeded.Count} von {selected.Count}");
        if (failed.HasValue)
        {
            int notProcessed = selected.Count - succeeded.Count - 1;
            Console.WriteLine($"  ABBRUCH bei Post {failed.Value.Id} wegen eines Fehlers.");
            if (notProcessed > 0)
                Console.WriteLine($"  Nicht mehr verarbeitet: {notProcessed} Post(s) ab ID {selected[succeeded.Count + 1].Id}");
        }
        Console.WriteLine("=========================================");

        if (succeeded.Count == 0) return;

        Console.Write($"  {succeeded.Count} erfolgreich gesendete(n) Post(s) archivieren? (j/n): ");
        if (Console.ReadLine()?.Trim().ToLowerInvariant() != "j") return;

        // Archivierte Dateien liegen in einem Unterordner und erscheinen nicht mehr in der Auswahlliste
        string archiveDir = Path.Combine(ghostPostsDir, "archiv");
        Directory.CreateDirectory(archiveDir);
        foreach (var post in succeeded)
            File.Move(post.Path, Path.Combine(archiveDir, Path.GetFileName(post.Path)), overwrite: true);
        Console.WriteLine($"  {succeeded.Count} Post(s) nach ghostPosts/archiv/ verschoben.");
    }

    /// <summary>
    /// Sendet einen einzelnen Post an Ghost. Liefert false, sobald etwas schiefgeht —
    /// ein Post mit fehlenden Bildern oder Videos wird dann gar nicht erst angelegt.
    /// </summary>
    // Zuletzt eingegebene Untertags — bei einem Von–Bis-Export gehören oft mehrere Posts zum selben Thema
    private static string _lastSubTags = "";

    private static async Task<bool> ImportPostFromJsonAsync(string jsonPath)
    {
        GhostPostFile? postFile;
        try
        {
            postFile = JsonSerializer.Deserialize<GhostPostFile>(File.ReadAllText(jsonPath));
        }
        catch (Exception ex)
        {
            Console.WriteLine($"  [Fehler] JSON konnte nicht gelesen werden: {ex.Message}");
            return false;
        }
        if (postFile == null)
        {
            Console.WriteLine("  [Fehler] JSON konnte nicht gelesen werden.");
            return false;
        }

        // Auch ältere JSON-Dateien enthalten noch prozentkodierte WordPress-Slugs
        postFile.Slug = SlugHelper.Clean(postFile.Slug, $"post-{postFile.WpId}");

        // Die Kategorie "Allgemein" wird nie übernommen — weder als Tag noch als Schlagwort
        postFile.Categories = postFile.Categories.Where(c => !CategoryRules.IsIgnored(c)).ToList();

        Console.WriteLine($"  Post: {postFile.Title}");
        Console.WriteLine($"  Slug: {postFile.Slug}");

        // Immer das Veröffentlichungsdatum des WordPress-Beitrags verwenden. Ohne Datum würde
        // Ghost den Zeitpunkt des Imports eintragen — dann lieber abbrechen.
        string? publishedAt = DateHelper.ToGhostUtc(postFile.PublishedAt ?? postFile.CreatedAt);
        if (publishedAt == null)
        {
            Console.WriteLine("  [Fehler] Kein Veröffentlichungsdatum im JSON – Beitrag bitte neu abrufen.");
            return false;
        }
        Console.WriteLine($"  Datum: {DateTimeOffset.Parse(publishedAt).ToLocalTime():dd.MM.yyyy HH:mm}");

        Console.WriteLine($"  Kategorien: {postFile.Categories.Count}");
        Console.WriteLine($"  Schlagwörter: {postFile.Tags.Count}");
        Console.WriteLine($"  Kommentare: {CommentBlockBuilder.CountRealComments(postFile.Comments)} (ohne Pingbacks/Reaktionen)");
        Console.WriteLine($"  Bilder: {postFile.ImageFiles.Count}");

        // 1. ALLE Bilder hochladen + Ghost-URL-Mapping erstellen
        var ghostUrlMap = new Dictionary<string, string>();
        int errors = 0;
        string html = postFile.Html ?? "";

        // WordPress-Kommentare als Block ans Beitragsende (bei älteren JSON-Dateien fehlt er noch)
        html = CommentBlockBuilder.Append(html, postFile.Comments);

        // Links auf eigene WordPress-Beiträge auf die Ghost-Adresse umschreiben
        var internalLinks = InternalLinkManager.Rewrite(html, WpBaseUrl, GhostUrl);
        html = internalLinks.Html;
        if (internalLinks.Replaced > 0)
            Console.WriteLine($"  [Links] {internalLinks.Replaced} interne(r) Link(s) auf Ghost umgeschrieben");
        foreach (string open in internalLinks.Unresolved)
            Console.WriteLine($"  [Links] Interner Link, Ziel (noch) nicht abgerufen – bleibt auf WordPress: {open}");

        html = await ValidateAndFixLinksAsync(html);

        // Problemfälle im Text melden: mehrere "?" aus fehlerhafter Zeichen-Konvertierung
        postFile.Title = ReviewQuestionMarksInText(postFile.Title ?? "", "Titel");
        html = ReviewQuestionMarksInHtml(html);

        if (postFile.ImageFiles.Count > 0)
        {
            Console.WriteLine($"  [Bilder] Lade {postFile.ImageFiles.Count} Bilder hoch...");
            foreach (string relPath in postFile.ImageFiles)
            {
                string localPath = Path.Combine(BaseDir, "images", relPath);
                if (!File.Exists(localPath))
                {
                    Console.WriteLine($"   [Fehler] {relPath} (nicht lokal)");
                    errors++;
                    continue;
                }
                Console.Write($"   [Upload] {Path.GetFileName(localPath)}...");
                string? url = await GhostApi.UploadImageIfNewAsync(localPath);
                if (url != null)
                {
                    Console.WriteLine($" -> {url}");
                    // Backslash-normalisiert für alte JSONs
                    string normalized = relPath.Replace("\\", "/");
                    string placeholder1 = $"__GHOST_URL__/content/images/{normalized}";
                    string placeholder2 = $"__GHOST_URL__/content/images/{relPath}";
                    ghostUrlMap[placeholder1] = url;
                    if (placeholder1 != placeholder2)
                        ghostUrlMap[placeholder2] = url;
                }
                else
                {
                    Console.WriteLine(" FEHLER");
                    errors++;
                }
            }
        }

        // 1b. Videos hochladen
        foreach (string relPath in postFile.MediaFiles)
        {
            string placeholder = MediaManager.GhostMediaPrefix + relPath;
            string localPath = MediaManager.GetLocalPath(relPath);

            // In diese Instanz bereits hochgeladen und dort noch vorhanden → nicht erneut übertragen
            string? url = MediaManager.GetUploadedUrl(relPath, GhostUrl);
            if (url != null && await GhostApi.ImageExistsAsync(url))
            {
                Console.WriteLine($"   [Video] {Path.GetFileName(localPath)} existiert bereits in Ghost");
                ghostUrlMap[placeholder] = url;
                continue;
            }

            if (!File.Exists(localPath))
            {
                Console.WriteLine($"   [Fehler] Video {relPath} (nicht lokal)");
                errors++;
                continue;
            }

            Console.Write($"   [Video-Upload] {Path.GetFileName(localPath)} ({new FileInfo(localPath).Length / 1048576.0:0.0} MB)...");
            url = await GhostApi.UploadMediaAsync(localPath);
            if (url != null)
            {
                Console.WriteLine($" -> {url}");
                MediaManager.SetUploadedUrl(relPath, url);
                ghostUrlMap[placeholder] = url;
            }
            else
            {
                Console.WriteLine(" FEHLER");
                errors++;
            }
        }

        // 2. Featured Image hochladen (separat, da nicht in ImageFiles)
        string? featureImageUrl = null;
        if (!string.IsNullOrEmpty(postFile.FeatureImage))
        {
            string localFeatPath = postFile.FeatureImage.Replace("__GHOST_URL__/content/images/", "");
            localFeatPath = Path.Combine(BaseDir, "images", localFeatPath);
            if (File.Exists(localFeatPath))
            {
                Console.Write("  [Featured Image]...");
                featureImageUrl = await GhostApi.UploadImageIfNewAsync(localFeatPath);
                Console.WriteLine(featureImageUrl != null ? $" OK" : " FEHLER");
                if (featureImageUrl != null)
                    ghostUrlMap[postFile.FeatureImage] = featureImageUrl;
                else
                    errors++;
            }
            else
            {
                Console.WriteLine($"  [Fehler] Featured Image nicht lokal: {postFile.FeatureImage}");
                errors++;
            }
        }

        // 3. __GHOST_URL__ im HTML durch echte URLs ersetzen
        foreach (var kvp in ghostUrlMap)
            html = html.Replace(kvp.Key, kvp.Value);

        // Übrig gebliebene Platzhalter wären in Ghost kaputte Bilder/Videos
        if (html.Contains("__GHOST_URL__"))
        {
            int remaining = System.Text.RegularExpressions.Regex.Matches(html, "__GHOST_URL__").Count;
            Console.WriteLine($"   [Fehler] {remaining} nicht ersetzte __GHOST_URL__-Platzhalter im HTML");
            errors++;
        }

        if (errors > 0)
        {
            Console.WriteLine($"  [Fehler] {errors} Problem(e) bei Bildern/Videos – der Post wird nicht an Ghost gesendet.");
            return false;
        }

        // Bilder, die noch von WordPress geladen würden → Post neu abrufen (Hauptmenü 5, dann 1)
        int wpImages = System.Text.RegularExpressions.Regex.Matches(html, @"<img\s[^>]*?\bsrc=[""'][^""']*/wp-content/uploads/", System.Text.RegularExpressions.RegexOptions.IgnoreCase).Count;
        if (wpImages > 0)
            Console.WriteLine($"   [Warnung] {wpImages} Bild(er) im HTML zeigen noch auf WordPress (/wp-content/uploads/)");

        // 4. Kategorien als Ghost-Tags erstellen/zuordnen.
        //    Der erste Tag ist in Ghost der primäre, alle weiteren sind sekundär.
        var tags = new List<GhostAdminTag>();
        var allTagSources = new List<WpCategory>();

        // Bei mehreren Kategorien: primäre Kategorie abfragen
        if (postFile.Categories.Count > 1)
        {
            Console.WriteLine();
            Console.WriteLine("  [Kategorien] Mehrere Kategorien gefunden:");
            for (int i = 0; i < postFile.Categories.Count; i++)
            {
                Console.WriteLine($"    [{i + 1}] {postFile.Categories[i].Name}");
            }

            int catIdx;
            while (true)
            {
                Console.Write("  Welche ist die primäre Kategorie? (Nummer): ");
                string? catChoice = Console.ReadLine();
                if (int.TryParse(catChoice?.Trim(), out catIdx) && catIdx >= 1 && catIdx <= postFile.Categories.Count)
                    break;
                if (catChoice == null) { catIdx = 1; break; } // keine Eingabe möglich (stdin geschlossen)
                Console.WriteLine($"  Bitte eine Zahl von 1 bis {postFile.Categories.Count} eingeben.");
            }

            // Gewählte Kategorie an erste Stelle setzen, alle anderen folgen als sekundäre
            var primary = postFile.Categories[catIdx - 1];
            allTagSources.Add(primary);
            allTagSources.AddRange(postFile.Categories.Where((_, idx) => idx != catIdx - 1));
            Console.WriteLine($"  -> Primär: {primary.Name}");
            Console.WriteLine($"  -> Sekundär: {string.Join(", ", allTagSources.Skip(1).Select(c => c.Name))}");
        }
        else if (postFile.Categories.Count == 1)
        {
            allTagSources.AddRange(postFile.Categories);
        }

        // Untertags: zusätzliche Tags, die der User vor dem Export vergibt. Sie stehen hinter den
        // Kategorien (sind also nie der primäre Tag, solange es eine Kategorie gibt) und werden
        // in Ghost angelegt, falls es sie noch nicht gibt.
        Console.WriteLine();
        if (allTagSources.Count > 0)
            Console.WriteLine($"  [Tags] Bisher: {string.Join(", ", allTagSources.Select(c => WebUtility.HtmlDecode(c.Name ?? "")))}");
        string again = _lastSubTags.Length > 0 ? $", + = wie zuletzt: {_lastSubTags}" : "";
        Console.Write($"  Untertag hinzufügen (mehrere mit Komma, leer = keiner{again}): ");
        string subTagInput = Console.ReadLine()?.Trim() ?? "";
        if (subTagInput == "+") subTagInput = _lastSubTags;
        if (subTagInput.Length > 0)
        {
            _lastSubTags = subTagInput;
            var known = allTagSources.Select(c => WebUtility.HtmlDecode(c.Name ?? "").Trim()).ToHashSet(StringComparer.OrdinalIgnoreCase);
            foreach (string name in subTagInput.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
            {
                if (known.Add(name))
                    allTagSources.Add(new WpCategory { Name = name });
            }
        }

        if (allTagSources.Count > 0)
        {
            Console.WriteLine($"  [Tags] Verarbeite {allTagSources.Count} Tag(s)...");
            tags = await GhostApi.EnsureTagsAsync(allTagSources);

            // Jede Kategorie mit Namen muss als Tag vorhanden sein
            int expectedTags = allTagSources
                .Select(c => WebUtility.HtmlDecode(c.Name ?? "").Trim().ToLowerInvariant())
                .Where(n => n.Length > 0).Distinct().Count();
            if (tags.Count < expectedTags)
            {
                Console.WriteLine($"  [Fehler] Nur {tags.Count} von {expectedTags} Tags konnten angelegt/zugeordnet werden.");
                return false;
            }
        }

        // 4b. Schlagwörter (WP-Tags + SEO-Keywords) ohne Nachfrage als <meta name="keywords">
        var keywords = postFile.Tags.Select(t => t.Name ?? "")
            .Concat((postFile.Keywords ?? "").Split(',', StringSplitOptions.RemoveEmptyEntries))
            .Where(k => !CategoryRules.IsIgnored(k))
            .ToList();

        // 5. Prüfe ob Post mit gleichem Slug bereits in Ghost existiert
        //    Hat der User diesem WordPress-Beitrag einen abweichenden Ghost-Slug zugeordnet
        //    (Prüffunktion), wird dort gesucht — sonst entstünde ein zweiter Post.
        string lookupSlug = SlugAssignments.GetGhostSlug(postFile.WpId) ?? postFile.Slug ?? "";
        Console.Write("  Prüfe Ghost...");
        var existingPosts = await GhostApi.BrowsePostsAsync($"slug:{lookupSlug}", 1);
        var existing = existingPosts.FirstOrDefault();

        GhostAdminPost? result = null;
        if (existing != null)
        {
            Console.WriteLine($" vorhanden (ID: {existing.Id})");
            string? head = GhostApi.BuildKeywordsHead(existing.CodeinjectionHead, keywords);
            if (head != null) Console.WriteLine("  [Meta] Schlagwörter als <meta name=\"keywords\"> gesetzt");
            Console.Write("  Aktualisiere...");
            result = await GhostApi.UpdatePostExtendedAsync(
                existing.Id!, postFile.Title ?? "", html,
                existing.UpdatedAt ?? "", postFile.Status ?? "published",
                featureImageUrl, tags, head, publishedAt);
            Console.WriteLine(result != null ? " OK" : " FEHLER");
        }
        else
        {
            Console.WriteLine(" nicht vorhanden");
            string? head = GhostApi.BuildKeywordsHead(null, keywords);
            if (head != null) Console.WriteLine("  [Meta] Schlagwörter als <meta name=\"keywords\"> gesetzt");
            Console.Write("  Erstelle neuen Post...");
            result = await GhostApi.CreatePostExtendedAsync(
                postFile.Title ?? "", html,
                postFile.Status ?? "published", postFile.Slug,
                featureImageUrl, tags, head, publishedAt);
            Console.WriteLine(result != null ? $" OK (ID: {result.Id})" : " FEHLER");
        }

        return result != null;
    }
}