using System.Net;
using System.Text.Json;
using System.Text.Json.Serialization;
using Flaro.Core.Metadata;
using Microsoft.Extensions.Logging;

namespace Flaro.Metadata;

/// <summary>Fragt TMDB nach Titeln, Beschreibungen und Bildern.</summary>
///
/// <remarks>
/// <para>
/// <b>Ein Fehlschlag ist kein Abbruch.</b> Antwortet TMDB nicht — kein Netz,
/// Kontingent erschöpft, Wartung —, kommt <c>null</c> zurück und der Titel
/// bleibt beim Dateinamen. Ein Scan, der an einem fremden Dienst scheitert,
/// wäre der falsche Entwurf: die Mediathek steht dann leer da, obwohl die
/// Dateien tadellos vorhanden sind.
/// </para>
/// <para>
/// <b>Ein falscher Schlüssel ist dagegen sehr wohl etwas, das jemand erfahren
/// muss</b> — sonst sucht man stundenlang, warum keine Bilder erscheinen.
/// Deshalb nur dafür eine Ausnahme.
/// </para>
/// </remarks>
public sealed class TmdbClient(
    HttpClient http,
    ITmdbSettingsSource einstellungen,
    ILogger<TmdbClient> log) : IMetadataProvider
{
    public const string BaseAddress = "https://api.themoviedb.org/3/";

    /// <summary>w500 für Plakate, w1280 für Hintergründe — genug für jeden Bildschirm.</summary>
    ///
    /// <remarks>
    /// Die Originalgrösse wäre bei einem Bestand mit tausend Titeln mehrere
    /// Gigabyte Cache, ohne dass es auf einem Telefon je sichtbar würde.
    /// </remarks>
    private const string PosterSize = "w500";
    private const string BackdropSize = "w1280";
    private const string StillSize = "w300";
    /// <summary>Porträts sind klein und viele — ein Kopf je Kachel.</summary>
    private const string ProfileSize = "w185";
    /// <summary>Schriftzüge sind breit und flach — w500 reicht auch gross.</summary>
    private const string LogoSize = "w500";

    /// <summary>Wie viele Darsteller je Titel übernommen werden.</summary>
    ///
    /// <remarks>
    /// TMDB nennt bei grossen Produktionen über hundert. Eine Besetzungsliste,
    /// die man scrollen muss, bis die Statisten kommen, hilft niemandem — und
    /// jede Zeile ist ein Porträt, das heruntergeladen und abgelegt wird.
    /// </remarks>
    private const int HöchstensDarsteller = 20;

    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);

    /// <summary>Ein Lese-Token ist ein JWT und fängt immer so an.</summary>
    ///
    /// <remarks>
    /// <b>Damit beides funktioniert, was auf TMDBs Kontoseite steht.</b> Dort
    /// liegen zwei Dinge nebeneinander — „API Key" und „API Read Access
    /// Token" —, und wer eines davon kopiert, soll nicht erst herausfinden
    /// müssen, welches gemeint war.
    /// </remarks>
    private const string JwtAnfang = "eyJ";

    public async Task<bool> IsConfiguredAsync(CancellationToken ct = default) =>
        !string.IsNullOrWhiteSpace((await einstellungen.GetAsync(ct)).ApiKey);

    public async Task<MovieMetadata?> FindMovieAsync(string title, int? year, CancellationToken ct = default)
    {
        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;

        // **Der Treffer der Suche taugt nur als Kennung.** `search/movie`
        // liefert weder Laufzeit noch Genres noch Besetzung; dafür braucht es
        // den Einzelabruf. Der kostet eine Anfrage — dieselbe, die vorher
        // ohnehin für die IMDb-Kennung fällig war.
        return await GetMovieAsync(treffer.Id, ct) ?? Als(treffer, title);
    }

    public async Task<IReadOnlyList<MovieMetadata>> SearchMoviesAsync(
        string title, int? year, CancellationToken ct = default)
    {
        foreach (var begriff in Suchvarianten.Fuer(title))
        {
            var alle = await AlleAsync<TmdbMovie>("search/movie", begriff,
                year is { } j ? ("year", j.ToString()) : null, ct);
            if (alle.Count == 0) continue;

            // **Nach Ähnlichkeit zum gesuchten Titel, nicht nach Beliebtheit.**
            // Gefunden wird unter Umständen über einen gekürzten Begriff;
            // dann liefert TMDB zwanzig Treffer, und der richtige ist der mit
            // den meisten gemeinsamen Worten.
            return alle
                .OrderByDescending(m => Suchvarianten.Aehnlichkeit(title, m.Title, m.OriginalTitle))
                .Select(m => Als(m, title))
                .ToList();
        }

        return [];
    }

    public Task<MovieMetadata?> GetMovieAsync(int providerId, CancellationToken ct = default) =>
        FilmHolenAsync(providerId, null, ct);

    public Task<MovieMetadata?> GetMovieAsync(int providerId, string sprache, CancellationToken ct = default) =>
        FilmHolenAsync(providerId, sprache, ct);

    /// <summary>Der gemeinsame Weg — mit Sprache oder mit der des Servers.</summary>
    private async Task<MovieMetadata?> FilmHolenAsync(
        int providerId, string? sprache, CancellationToken ct)
    {
        var einstellung = await einstellungen.GetAsync(ct);
        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
        if (sprache is { Length: > 0 }) einstellung = einstellung with { Language = sprache };

        // **Alles in einer Anfrage.** `append_to_response` hängt Besetzung,
        // Fremdkennungen und Freigaben an den Einzelabruf. Drei getrennte
        // Anfragen je Titel wären bei vierhundert Filmen zwölfhundert — und
        // TMDB begrenzt, wie oft man fragen darf.
        var film = await HolenAsync<TmdbMovie>(
            $"movie/{providerId}?language={Uri.EscapeDataString(einstellung.Language)}" +
            "&append_to_response=credits,external_ids,release_dates,images" +
            // **Sprachlos ist erwünscht.** Viele Schriftzüge tragen gar keine
            // Sprache (`null`), weil sie keinen Text enthalten, der übersetzt
            // werden müsste. Ohne diese Angabe liefert TMDB sie nicht mit.
            $"&include_image_language={Uri.EscapeDataString(Sprachkürzel(einstellung.Language))},en,null",
            einstellung, ct);

        // **Kennung null gibt es bei TMDB nicht.** Antwortet etwas anderes
        // als der erwartete Einzelabruf — ein Anmeldeportal, ein Proxy, eine
        // Trefferliste —, liest der Dekoder daraus eine Null. Das als Treffer
        // durchzulassen hiesse, einen Film mit der Kennung 0 anzulegen.
        if (film is null or { Id: 0 }) return null;

        return Als(film, "") with
        {
            ImdbId = Leer(film.ExternalIds?.ImdbId),
            RuntimeMinutes = film.Runtime > 0 ? film.Runtime : null,
            Rating = film.VoteAverage > 0 ? film.VoteAverage : null,
            Tagline = Leer(film.Tagline),
            ContentRating = Freigabe(film.ReleaseDates, Land(einstellung.Language)),
            Genres = Namen(film.Genres),
            Credits = Mitwirkende(film.Credits),
            Logo = Schriftzug(film.Images, Sprachkürzel(einstellung.Language)),
        };
    }

    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))
    {
        OriginalTitle = Leer(roh.OriginalTitle),
    };

    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 await GetSeriesAsync(treffer.Id, ct) ?? Als(treffer, title);
    }

    public async Task<IReadOnlyList<SeriesMetadata>> SearchSeriesAsync(
        string title, int? year, CancellationToken ct = default)
    {
        foreach (var begriff in Suchvarianten.Fuer(title))
        {
            var alle = await AlleAsync<TmdbSeries>("search/tv", begriff,
                year is { } j ? ("first_air_date_year", j.ToString()) : null, ct);
            if (alle.Count == 0) continue;

            return alle
                .OrderByDescending(s => Suchvarianten.Aehnlichkeit(title, s.Name, s.OriginalName))
                .Select(s => Als(s, title))
                .ToList();
        }

        return [];
    }

    public Task<SeriesMetadata?> GetSeriesAsync(int providerId, CancellationToken ct = default) =>
        SerieHolenAsync(providerId, null, ct);

    public Task<SeriesMetadata?> GetSeriesAsync(int providerId, string sprache, CancellationToken ct = default) =>
        SerieHolenAsync(providerId, sprache, ct);

    private async Task<SeriesMetadata?> SerieHolenAsync(
        int providerId, string? sprache, CancellationToken ct)
    {
        var einstellung = await einstellungen.GetAsync(ct);
        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
        if (sprache is { Length: > 0 }) einstellung = einstellung with { Language = sprache };

        var serie = await HolenAsync<TmdbSeries>(
            $"tv/{providerId}?language={Uri.EscapeDataString(einstellung.Language)}" +
            "&append_to_response=credits,external_ids,content_ratings,images" +
            $"&include_image_language={Uri.EscapeDataString(Sprachkürzel(einstellung.Language))},en,null",
            einstellung, ct);

        if (serie is null or { Id: 0 }) return null;

        return Als(serie, "") with
        {
            ImdbId = Leer(serie.ExternalIds?.ImdbId),
            // Die übliche Länge einer Folge, nicht die der ganzen Serie.
            RuntimeMinutes = serie.EpisodeRunTime?.FirstOrDefault(l => l > 0),
            Rating = serie.VoteAverage > 0 ? serie.VoteAverage : null,
            Tagline = Leer(serie.Tagline),
            ContentRating = Freigabe(serie.ContentRatings, Land(einstellung.Language)),
            Genres = Namen(serie.Genres),
            Credits = Mitwirkende(serie.Credits),
            Logo = Schriftzug(serie.Images, Sprachkürzel(einstellung.Language)),
        };
    }

    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))
    {
        OriginalTitle = Leer(roh.OriginalName),
    };

    // Der eigene Abruf von `external_ids` ist entfallen: die Kennung hängt
    // jetzt über `append_to_response` am Einzelabruf. Das spart eine Anfrage
    // je Titel — bei vierhundert Filmen vierhundert.

    public async Task<EpisodeMetadata?> FindEpisodeAsync(
        int seriesProviderId, int season, int episode, CancellationToken ct = default)
    {
        var einstellung = await einstellungen.GetAsync(ct);
        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;

        var pfad = $"tv/{seriesProviderId}/season/{season}/episode/{episode}" +
                   $"?language={Uri.EscapeDataString(einstellung.Language)}";

        var folge = await HolenAsync<TmdbEpisode>(pfad, einstellung, ct);
        if (folge is null) return null;

        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
    {
        var einstellung = await einstellungen.GetAsync(ct);
        if (string.IsNullOrWhiteSpace(einstellung.ApiKey) || string.IsNullOrWhiteSpace(titel)) return null;

        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);
        var treffer = antwort?.Results;
        if (treffer is null || treffer.Count == 0) return null;

        // **Ein genau passender Name sticht den beliebtesten.**
        //
        // TMDB sortiert nach Beliebtheit. Ohne Jahresangabe führt das in die
        // Irre: die Suche nach „Dark" lieferte „Dark Shadows" von 1966 statt
        // der Serie von 2017 — am echten Dienst gemessen, nicht vermutet.
        // Steht ein Treffer mit genau diesem Namen in der Liste, ist er
        // gemeint.
        //
        // Nur bei Gleichheit, nicht bei Ähnlichkeit: eine eigene Bewertung zu
        // bauen hiesse, TMDBs Rangfolge nachzubauen — mit weniger Daten.
        var genau = treffer.FirstOrDefault(e =>
            string.Equals(titelVon(e)?.Trim(), titel.Trim(), StringComparison.OrdinalIgnoreCase));

        return genau ?? treffer[0];
    }

    /// <summary>Holt eine Antwort — mit Bearer, wo es geht.</summary>
    ///
    /// <remarks>
    /// <b>Der Lese-Token wandert in die Kopfzeile, nicht in die Adresse.</b>
    /// Ein <c>?api_key=…</c> steht in jedem Zugriffsprotokoll, in jedem
    /// Reverse Proxy und in jeder Fehlermeldung, die eine Adresse zitiert.
    /// Eine Kopfzeile tut das nicht. Dazu kann ein Lese-Token nichts ändern,
    /// nur lesen — bei einem Schlüssel, der in einem offenen Projekt
    /// mitgeliefert wird, ist das der Unterschied, auf den es ankommt.
    ///
    /// Der ältere Schlüssel geht trotzdem: er kann nur in die Adresse.
    /// </remarks>
    private async Task<T?> HolenAsync<T>(
        string pfadMitAbfrage, TmdbSettings einstellung, CancellationToken ct) where T : class
    {
        var zugang = einstellung.ApiKey!;
        var alsBearer = zugang.StartsWith(JwtAnfang, StringComparison.Ordinal);
        var adresse = alsBearer
            ? pfadMitAbfrage
            : pfadMitAbfrage + (pfadMitAbfrage.Contains('?') ? "&" : "?")
              + $"api_key={Uri.EscapeDataString(zugang)}";

        try
        {
            using var anfrage = new HttpRequestMessage(HttpMethod.Get, adresse);
            if (alsBearer) anfrage.Headers.Authorization = new("Bearer", zugang);

            using var antwort = await http.SendAsync(anfrage, ct);

            if (antwort.StatusCode is HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden)
                throw new MetadataCredentialsException(
                    "TMDB weist den hinterlegten Schlüssel zurück. Prüfe ihn in den Servereinstellungen.");

            // 404 heisst bei TMDB schlicht „gibt es nicht" — etwa eine Folge,
            // die dort noch nicht eingetragen ist.
            if (antwort.StatusCode == HttpStatusCode.NotFound) return null;

            if (!antwort.IsSuccessStatusCode)
            {
                log.LogWarning("TMDB antwortete mit {Code} auf {Pfad}.", (int)antwort.StatusCode, Gekürzt(adresse));
                return null;
            }

            return await antwort.Content.ReadFromJsonSafeAsync<T>(Json, ct);
        }
        catch (MetadataCredentialsException) { throw; }
        catch (OperationCanceledException) when (ct.IsCancellationRequested) { throw; }
        catch (Exception fehler)
        {
            log.LogWarning(fehler, "TMDB war für {Pfad} nicht erreichbar.", Gekürzt(adresse));
            return null;
        }
    }

    /// <summary>Der Pfad ohne den Schlüssel — der gehört in kein Protokoll.</summary>
    private static string Gekürzt(string pfadMitAbfrage)
    {
        var index = pfadMitAbfrage.IndexOf("api_key=", StringComparison.Ordinal);
        return index < 0 ? pfadMitAbfrage : pfadMitAbfrage[..index] + "api_key=…";
    }

    /// <summary>Das Land aus einer Sprachangabe wie „de-DE".</summary>
    ///
    /// <remarks>
    /// Freigaben sind national: die FSK gilt in Deutschland, die MPAA in den
    /// USA, und TMDB führt beide nebeneinander. Steht kein Land dabei, ist
    /// „US" die Angabe, die am häufigsten gefüllt ist — besser als keine.
    /// </remarks>
    private static string Land(string sprache)
    {
        var teile = sprache.Split('-');
        return teile.Length > 1 && teile[1].Length == 2 ? teile[1].ToUpperInvariant() : "US";
    }

    /// <summary>„de" aus „de-DE".</summary>
    private static string Sprachkürzel(string sprache) =>
        sprache.Split('-')[0].ToLowerInvariant();

    /// <summary>Der Schriftzug, möglichst in der eingestellten Sprache.</summary>
    ///
    /// <remarks>
    /// <b>Die Reihenfolge ist die Aussage.</b> Erst die eigene Sprache — ein
    /// deutscher Filmtitel in deutscher Schrift —, dann der ohne Sprache
    /// (meist ein reines Bildzeichen, überall richtig), dann Englisch. Erst
    /// innerhalb einer Stufe entscheidet die Bewertung bei TMDB, weil es dort
    /// um Bildqualität geht und nicht mehr um die Sprache.
    /// </remarks>
    /// <summary>Alle Bilder zu einem Titel — für die Auswahl von Hand.</summary>
    ///
    /// <remarks>
    /// <b>Die Liste kommt ohnehin mit.</b> <c>append_to_response=…,images</c>
    /// hängt sie an den Einzelabruf, und bisher wurde alles ausser dem
    /// Schriftzug weggeworfen. Die Auswahl kostet also keine zusätzliche
    /// Anfrage.
    /// </remarks>
    public async Task<IReadOnlyList<Bildkandidat>> BilderAsync(
        int providerId, bool serie, CancellationToken ct = default)
    {
        var einstellung = await einstellungen.GetAsync(ct);
        if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return [];

        var sprache = Sprachkürzel(einstellung.Language);
        var weg = serie ? "tv" : "movie";
        var antwort = await HolenAsync<TmdbBilderAntwort>(
            $"{weg}/{providerId}/images?include_image_language={Uri.EscapeDataString(sprache)},en,null",
            einstellung, ct);

        if (antwort is null) return [];

        var liste = new List<Bildkandidat>();
        Sammeln(antwort.Posters, "poster", PosterSize);
        Sammeln(antwort.Backdrops, "backdrop", BackdropSize);
        Sammeln(antwort.Logos, "logo", "w500");
        return liste;

        void Sammeln(List<TmdbImage>? bilder, string art, string groesse)
        {
            foreach (var b in (bilder ?? []).Where(b => !string.IsNullOrWhiteSpace(b.FilePath))
                         .OrderByDescending(b => b.VoteAverage ?? 0)
                         .Take(24))
            {
                liste.Add(new Bildkandidat(
                    art, Bild(b.FilePath, groesse)!.Url,
                    Bild(b.FilePath, "w185")!.Url,
                    string.IsNullOrEmpty(b.Language) ? null : b.Language,
                    b.VoteAverage));
            }
        }
    }

    private sealed record TmdbBilderAntwort(
        [property: JsonPropertyName("posters")] List<TmdbImage>? Posters,
        [property: JsonPropertyName("backdrops")] List<TmdbImage>? Backdrops,
        [property: JsonPropertyName("logos")] List<TmdbImage>? Logos);

    private static RemoteImage? Schriftzug(TmdbImages? bilder, string sprache)
    {
        var alle = bilder?.Logos?.Where(l => !string.IsNullOrWhiteSpace(l.FilePath)).ToList();
        if (alle is not { Count: > 0 }) return null;

        var beste = alle
            .OrderBy(l => string.Equals(l.Language, sprache, StringComparison.OrdinalIgnoreCase) ? 0
                        : string.IsNullOrEmpty(l.Language) ? 1
                        : string.Equals(l.Language, "en", StringComparison.OrdinalIgnoreCase) ? 2
                        : 3)
            .ThenByDescending(l => l.VoteAverage ?? 0)
            .First();

        return Bild(beste.FilePath, LogoSize);
    }

    private static string? Freigabe(TmdbReleaseDates? quelle, string land) =>
        Leer(quelle?.Results?
            .FirstOrDefault(r => string.Equals(r.Country, land, StringComparison.OrdinalIgnoreCase))?
            .Releases?
            .Select(r => r.Certification)
            .FirstOrDefault(c => !string.IsNullOrWhiteSpace(c)));

    private static string? Freigabe(TmdbContentRatings? quelle, string land) =>
        Leer(quelle?.Results?
            .FirstOrDefault(r => string.Equals(r.Country, land, StringComparison.OrdinalIgnoreCase))?
            .Rating);

    private static IReadOnlyList<string>? Namen(List<TmdbGenre>? genres)
    {
        var liste = genres?
            .Select(g => g.Name?.Trim())
            .Where(n => !string.IsNullOrEmpty(n))
            .Select(n => n!)
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList();
        return liste is { Count: > 0 } ? liste : null;
    }

    /// <summary>Darsteller, Regie und Drehbuch — in dieser Reihenfolge.</summary>
    ///
    /// <remarks>
    /// <b>Aus dem Stab nur zwei Rollen.</b> TMDB führt dort auch Beleuchter
    /// und Caterer; eine Detailseite, die alle nennt, nennt nichts. Regie und
    /// Drehbuch sind das, wonach jemand sucht.
    /// </remarks>
    private static IReadOnlyList<CreditMetadata>? Mitwirkende(TmdbCredits? quelle)
    {
        if (quelle is null) return null;

        var liste = new List<CreditMetadata>();

        foreach (var d in (quelle.Cast ?? []).OrderBy(c => c.Order ?? int.MaxValue).Take(HöchstensDarsteller))
        {
            if (string.IsNullOrWhiteSpace(d.Name)) continue;
            liste.Add(new CreditMetadata(
                d.Id, d.Name.Trim(), CreditKind.Actor, Leer(d.Character),
                Bild(d.ProfilePath, ProfileSize), d.Order ?? liste.Count));
        }

        var stab = 0;
        foreach (var m in quelle.Crew ?? [])
        {
            var rolle = m.Job?.Trim() switch
            {
                "Director" => CreditKind.Director,
                "Writer" or "Screenplay" or "Story" => CreditKind.Writer,
                _ => (CreditKind?)null,
            };
            if (rolle is not { } art || string.IsNullOrWhiteSpace(m.Name)) continue;

            // Dieselbe Person steht im Stab mehrfach, wenn sie mehrere
            // Aufgaben hatte — „Drehbuch" und „Story" sind bei TMDB zwei
            // Zeilen und auf einer Detailseite ein Name.
            if (liste.Any(e => e.ProviderId == m.Id && e.Kind == art)) continue;

            liste.Add(new CreditMetadata(
                m.Id, m.Name.Trim(), art, null, Bild(m.ProfilePath, ProfileSize), stab++));
        }

        return liste.Count > 0 ? liste : null;
    }

    private static RemoteImage? Bild(string? pfad, string grösse) =>
        string.IsNullOrWhiteSpace(pfad) ? null : new RemoteImage($"https://image.tmdb.org/t/p/{grösse}{pfad}");

    private static string? Leer(string? wert) => string.IsNullOrWhiteSpace(wert) ? null : wert;

    private static int? JahrAus(string? datum) =>
        datum is { Length: >= 4 } && int.TryParse(datum[..4], out var jahr) ? jahr : null;

    // 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,
        [property: JsonPropertyName("original_title")] string? OriginalTitle,
        [property: JsonPropertyName("release_date")] string? ReleaseDate,
        [property: JsonPropertyName("overview")] string? Overview,
        [property: JsonPropertyName("poster_path")] string? PosterPath,
        [property: JsonPropertyName("backdrop_path")] string? BackdropPath,
        // Die folgenden liefert nur der Einzelabruf, nicht die Suche.
        [property: JsonPropertyName("runtime")] int? Runtime = null,
        [property: JsonPropertyName("vote_average")] double? VoteAverage = null,
        [property: JsonPropertyName("tagline")] string? Tagline = null,
        [property: JsonPropertyName("genres")] List<TmdbGenre>? Genres = null,
        [property: JsonPropertyName("credits")] TmdbCredits? Credits = null,
        [property: JsonPropertyName("external_ids")] TmdbExternalIds? ExternalIds = null,
        [property: JsonPropertyName("release_dates")] TmdbReleaseDates? ReleaseDates = null,
        [property: JsonPropertyName("images")] TmdbImages? Images = null);

    private sealed record TmdbSeries(
        [property: JsonPropertyName("id")] int Id,
        [property: JsonPropertyName("name")] string? Name,
        [property: JsonPropertyName("original_name")] string? OriginalName,
        [property: JsonPropertyName("first_air_date")] string? FirstAirDate,
        [property: JsonPropertyName("overview")] string? Overview,
        [property: JsonPropertyName("poster_path")] string? PosterPath,
        [property: JsonPropertyName("backdrop_path")] string? BackdropPath,
        [property: JsonPropertyName("episode_run_time")] List<int>? EpisodeRunTime = null,
        [property: JsonPropertyName("vote_average")] double? VoteAverage = null,
        [property: JsonPropertyName("tagline")] string? Tagline = null,
        [property: JsonPropertyName("genres")] List<TmdbGenre>? Genres = null,
        [property: JsonPropertyName("credits")] TmdbCredits? Credits = null,
        [property: JsonPropertyName("external_ids")] TmdbExternalIds? ExternalIds = null,
        [property: JsonPropertyName("content_ratings")] TmdbContentRatings? ContentRatings = null,
        [property: JsonPropertyName("images")] TmdbImages? Images = null);

    private sealed record TmdbGenre([property: JsonPropertyName("name")] string? Name);

    private sealed record TmdbImages(
        [property: JsonPropertyName("logos")] List<TmdbImage>? Logos,
        [property: JsonPropertyName("posters")] List<TmdbImage>? Posters = null,
        [property: JsonPropertyName("backdrops")] List<TmdbImage>? Backdrops = null);

    private sealed record TmdbImage(
        [property: JsonPropertyName("file_path")] string? FilePath,
        [property: JsonPropertyName("iso_639_1")] string? Language,
        [property: JsonPropertyName("vote_average")] double? VoteAverage);

    private sealed record TmdbCredits(
        [property: JsonPropertyName("cast")] List<TmdbCast>? Cast,
        [property: JsonPropertyName("crew")] List<TmdbCrew>? Crew);

    private sealed record TmdbCast(
        [property: JsonPropertyName("id")] int Id,
        [property: JsonPropertyName("name")] string? Name,
        [property: JsonPropertyName("character")] string? Character,
        [property: JsonPropertyName("profile_path")] string? ProfilePath,
        [property: JsonPropertyName("order")] int? Order);

    private sealed record TmdbCrew(
        [property: JsonPropertyName("id")] int Id,
        [property: JsonPropertyName("name")] string? Name,
        [property: JsonPropertyName("job")] string? Job,
        [property: JsonPropertyName("profile_path")] string? ProfilePath);

    private sealed record TmdbReleaseDates(
        [property: JsonPropertyName("results")] List<TmdbReleaseCountry>? Results);

    private sealed record TmdbReleaseCountry(
        [property: JsonPropertyName("iso_3166_1")] string? Country,
        [property: JsonPropertyName("release_dates")] List<TmdbRelease>? Releases);

    private sealed record TmdbRelease(
        [property: JsonPropertyName("certification")] string? Certification);

    private sealed record TmdbContentRatings(
        [property: JsonPropertyName("results")] List<TmdbContentRating>? Results);

    private sealed record TmdbContentRating(
        [property: JsonPropertyName("iso_3166_1")] string? Country,
        [property: JsonPropertyName("rating")] string? Rating);

    private sealed record TmdbEpisode(
        [property: JsonPropertyName("name")] string? Name,
        [property: JsonPropertyName("overview")] string? Overview,
        [property: JsonPropertyName("still_path")] string? StillPath);
}

internal static class HttpContentExtensions
{
    /// <summary>Liest JSON und wirft nicht, wenn Unsinn zurückkommt.</summary>
    ///
    /// <remarks>
    /// Ein Reverse Proxy oder ein Anmeldeportal im Hotel-WLAN antwortet mit
    /// HTML und dem Status 200. Darauf mit einer Ausnahme zu reagieren hiesse,
    /// den ganzen Scan an einem fremden Netz scheitern zu lassen.
    /// </remarks>
    public static async Task<T?> ReadFromJsonSafeAsync<T>(
        this HttpContent inhalt, JsonSerializerOptions optionen, CancellationToken ct) where T : class
    {
        try
        {
            await using var strom = await inhalt.ReadAsStreamAsync(ct);
            return await JsonSerializer.DeserializeAsync<T>(strom, optionen, ct);
        }
        catch (JsonException) { return null; }
    }
}