Beiwerk im Medienordner, und eine Zuordnung lässt sich korrigieren

Plakate, Hintergründe und NFO-Dateien landen jetzt neben dem Film — und eine
falsche Zuordnung lässt sich richtigstellen, ohne dass der nächste Scan sie
wieder überschreibt.

    Der Untergang (2004)/
    ├── Der Untergang (2004).mkv
    ├── poster.jpg
    ├── fanart.jpg
    └── movie.nfo

Bei Serien liegt `tvshow.nfo` eine Ebene über dem Staffelordner, je Folge
kommen NFO und Standbild daneben. Liegen mehrere Filme in einem Ordner, heisst
das Beiwerk `Titel (Jahr)-poster.jpg` — sonst überschrieben sie sich
gegenseitig.

**Die Erlaubnisliste ist der ganze Schutz.** Damit das geht, muss die
Medieneinhängung ohne `:ro` auskommen, und damit könnte der Server dort alles
anstellen. Dass er es nicht tut, hängt an `SidecarNames`: sechs Arten von
Datei, nichts sonst. Ein Name, der nicht daraufsteht, wirft — laut, nicht
still, denn das wäre ein Fehler im Programm. Mediendateien werden nie
geändert, umbenannt oder gelöscht; es gibt keine Stelle, die das könnte.
Geprüft an echten Dateien, einschliesslich der Versuche mit `../`, mit
absoluten Pfaden und mit einer Mediendatei als Ziel.

Standardmässig **aus**. In fremde Medienordner zu schreiben ist nichts, was
ein Server ungefragt tun sollte.

**Gelesen wird auch ohne Schreiberlaubnis.** Eine vorhandene NFO ist eine
Zuordnung, die jemand getroffen hat — Halo nimmt sie und sucht gar nicht
erst. Dasselbe gilt für Ordnernamen der Form `[tmdbid-613]`. Halo liest sie
und benennt **nichts** um: Umbenennen ist der einzige Eingriff, der eine
Bibliothek wirklich zerlegen kann.

Nebenbei: eine NFO aus dem Medienordner hat Halo nicht geschrieben. DTDs sind
beim Lesen abgeschaltet — eine untergeschobene Datei mit externer Entität
könnte sonst den Server dazu bringen, `/config/halo.db` einzulesen und als
Titel auszuliefern. Mit Prüfung.

---

**Der Fehler, den erst der echte Lauf zeigte** — und er ist die zweite
Auflage eines schon einmal behobenen:

Nach der Korrektur stand im Ordner „Dark (2017)", in der Datenbank aber 2004.
Der nächste Scan suchte nach *(Dark, 2017)*, fand nichts, legte den Film neu
an und löschte den korrigierten als verwaist. Überlebt hat die Zuordnung nur,
weil sie in der NFO stand — das System hat sich selbst gerettet, aber der
Eintrag war ein anderer und das Jahr wieder falsch.

Dieselbe Klasse wie bei `ParsedTitle`: zugeordnet wurde über einen Wert, den
die Metadatenquelle verändert. Jetzt gibt es `ParsedYear`, und das ändert sich
nie. Mit Prüfung, die genau diesen Ablauf festhält.

---

Dazu von TMDB: die IMDb-Kennung wird nachgeschlagen, damit sie in der NFO
steht — wer später auf ein anderes Werkzeug wechselt, findet denselben Titel
wieder, auch wenn das TMDB gar nicht kennt.

308 Tests grün. Im Container nachgewiesen: Zuordnung falsch, korrigiert,
zweiter Scan — derselbe Eintrag, dieselbe Kennung, Jahr bleibt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/src/Halo.Metadata/TmdbClient.cs

@@ -58,30 +58,84 @@ public sealed class TmdbClient(
     {
         var treffer = await SuchenAsync<TmdbMovie>("search/movie", title,
             year is { } j ? ("year", j.ToString()) : null, m => m.Title, ct);
-        if (treffer is null) return null;
-
-        return new MovieMetadata(
-            treffer.Id,
-            treffer.Title ?? title,
-            JahrAus(treffer.ReleaseDate),
-            Leer(treffer.Overview),
-            Bild(treffer.PosterPath, PosterSize),
-            Bild(treffer.BackdropPath, BackdropSize));
+        return treffer is null ? null : await MitImdb(Als(treffer, title), "movie", ct);
     }
 
+    public async Task<IReadOnlyList<MovieMetadata>> SearchMoviesAsync(
+        string title, int? year, CancellationToken ct = default)
+    {
+        var alle = await AlleAsync<TmdbMovie>("search/movie", title,
+            year is { } j ? ("year", j.ToString()) : null, ct);
+        return alle.Select(m => Als(m, title)).ToList();
+    }
+
+    public async Task<MovieMetadata?> GetMovieAsync(int providerId, CancellationToken ct = default)
+    {
+        var einstellung = await einstellungen.GetAsync(ct);
+        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
+
+        var film = await HolenAsync<TmdbMovie>(
+            $"movie/{providerId}?language={Uri.EscapeDataString(einstellung.Language)}", einstellung, ct);
+        return film is null ? null : await MitImdb(Als(film, ""), "movie", ct);
+    }
+
+    private static MovieMetadata Als(TmdbMovie roh, string rückfall) => new(
+        roh.Id, roh.Title ?? rückfall, JahrAus(roh.ReleaseDate), Leer(roh.Overview),
+        Bild(roh.PosterPath, PosterSize), Bild(roh.BackdropPath, BackdropSize));
+
     public async Task<SeriesMetadata?> FindSeriesAsync(string title, int? year, CancellationToken ct = default)
     {
         var treffer = await SuchenAsync<TmdbSeries>("search/tv", title,
             year is { } j ? ("first_air_date_year", j.ToString()) : null, s => s.Name, ct);
-        if (treffer is null) return null;
+        return treffer is null ? null : await MitImdb(Als(treffer, title), "tv", ct);
+    }
 
-        return new SeriesMetadata(
-            treffer.Id,
-            treffer.Name ?? title,
-            JahrAus(treffer.FirstAirDate),
-            Leer(treffer.Overview),
-            Bild(treffer.PosterPath, PosterSize),
-            Bild(treffer.BackdropPath, BackdropSize));
+    public async Task<IReadOnlyList<SeriesMetadata>> SearchSeriesAsync(
+        string title, int? year, CancellationToken ct = default)
+    {
+        var alle = await AlleAsync<TmdbSeries>("search/tv", title,
+            year is { } j ? ("first_air_date_year", j.ToString()) : null, ct);
+        return alle.Select(s => Als(s, title)).ToList();
+    }
+
+    public async Task<SeriesMetadata?> GetSeriesAsync(int providerId, CancellationToken ct = default)
+    {
+        var einstellung = await einstellungen.GetAsync(ct);
+        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
+
+        var serie = await HolenAsync<TmdbSeries>(
+            $"tv/{providerId}?language={Uri.EscapeDataString(einstellung.Language)}", einstellung, ct);
+        return serie is null ? null : await MitImdb(Als(serie, ""), "tv", ct);
+    }
+
+    private static SeriesMetadata Als(TmdbSeries roh, string rückfall) => new(
+        roh.Id, roh.Name ?? rückfall, JahrAus(roh.FirstAirDate), Leer(roh.Overview),
+        Bild(roh.PosterPath, PosterSize), Bild(roh.BackdropPath, BackdropSize));
+
+    /// <summary>Holt die IMDb-Kennung nach — eine Anfrage je neuem Treffer.</summary>
+    ///
+    /// <remarks>
+    /// <b>Die Suche bei TMDB liefert sie nicht mit.</b> Gebraucht wird sie für
+    /// die NFO-Datei: wer später auf ein anderes Werkzeug wechselt, findet
+    /// damit denselben Titel wieder, auch wenn das Werkzeug TMDB gar nicht
+    /// kennt.
+    ///
+    /// Scheitert der Nachschlag, bleibt sie leer — das ist kein Grund, den
+    /// ganzen Treffer wegzuwerfen.
+    /// </remarks>
+    private async Task<MovieMetadata> MitImdb(MovieMetadata film, string art, CancellationToken ct) =>
+        film with { ImdbId = await ImdbAsync(art, film.ProviderId, ct) };
+
+    private async Task<SeriesMetadata> MitImdb(SeriesMetadata serie, string art, CancellationToken ct) =>
+        serie with { ImdbId = await ImdbAsync(art, serie.ProviderId, ct) };
+
+    private async Task<string?> ImdbAsync(string art, int kennung, CancellationToken ct)
+    {
+        var einstellung = await einstellungen.GetAsync(ct);
+        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
+
+        var fremde = await HolenAsync<TmdbExternalIds>($"{art}/{kennung}/external_ids", einstellung, ct);
+        return Leer(fremde?.ImdbId);
     }
 
     public async Task<EpisodeMetadata?> FindEpisodeAsync(
@@ -99,6 +153,22 @@ public sealed class TmdbClient(
         return new EpisodeMetadata(Leer(folge.Name), Leer(folge.Overview), Bild(folge.StillPath, StillSize));
     }
 
+    /// <summary>Die ganze Trefferliste — für die Auswahl von Hand.</summary>
+    private async Task<List<T>> AlleAsync<T>(
+        string pfad, string titel, (string Name, string Wert)? zusatz, CancellationToken ct) where T : class
+    {
+        var einstellung = await einstellungen.GetAsync(ct);
+        if (string.IsNullOrWhiteSpace(einstellung.ApiKey) || string.IsNullOrWhiteSpace(titel)) return [];
+
+        var abfrage = $"{pfad}?language={Uri.EscapeDataString(einstellung.Language)}" +
+                      $"&query={Uri.EscapeDataString(titel)}";
+        if (zusatz is { } z) abfrage += $"&{z.Name}={Uri.EscapeDataString(z.Wert)}";
+
+        var antwort = await HolenAsync<TmdbSearch<T>>(abfrage, einstellung, ct);
+        // Gedeckelt: wer aus fünfzig Vorschlägen wählen soll, wählt gar nicht.
+        return antwort?.Results?.Take(10).ToList() ?? [];
+    }
+
     private async Task<T?> SuchenAsync<T>(
         string pfad, string titel, (string Name, string Wert)? zusatz,
         Func<T, string?> titelVon, CancellationToken ct) where T : class
@@ -202,6 +272,8 @@ public sealed class TmdbClient(
     // Nur die Felder, die gebraucht werden. TMDB liefert dreissig weitere.
     private sealed record TmdbSearch<T>([property: JsonPropertyName("results")] List<T>? Results);
 
+    private sealed record TmdbExternalIds([property: JsonPropertyName("imdb_id")] string? ImdbId);
+
     private sealed record TmdbMovie(
         [property: JsonPropertyName("id")] int Id,
         [property: JsonPropertyName("title")] string? Title,