Flaro/server/src/Flaro.Api/Quellenprobe.cs

using Flaro.Core.Metadata;
using Flaro.Metadata;

namespace Flaro.Api;

/// <summary>Was eine Quelle auf Nachfrage geantwortet hat.</summary>
///
/// <param name="Source">„tmdb", „fanart" oder „omdb".</param>
/// <param name="Configured">Ob überhaupt ein Zugang hinterlegt ist.</param>
/// <param name="Ok">Ob die Probe etwas Brauchbares ergeben hat.</param>
/// <param name="Detail">Ein Satz, der sagt, was herauskam.</param>
public sealed record Quellenbefund(string Source, bool Configured, bool Ok, string Detail);

/// <summary>Fragt die Quellen einmal und sagt, was zurückkam.</summary>
///
/// <remarks>
/// <para>
/// <b>Der Anlass.</b> Nach dem Eintragen eines Schlüssels stand in der
/// Oberfläche „Hinterlegt" — und das war alles. Ob er stimmt, ob der Dienst
/// antwortet und ob zu einem Film überhaupt etwas zu holen ist, liess sich
/// nicht feststellen; man trug ein, frischte die Metadaten über
/// achthundert Titel auf und sah danach nach, ob sich etwas geändert hatte.
/// </para>
/// <para>
/// <b>Mit einem bekannten Film, nicht mit einem aus der Mediathek.</b> „The
/// Matrix" hat bei allen drei Quellen Einträge; ein Film aus dem eigenen
/// Bestand könnte schlicht unbekannt sein, und dann wüsste man wieder
/// nicht, ob es am Schlüssel liegt oder am Film.
/// </para>
/// </remarks>
public sealed class Quellenprobe(
    TmdbClient tmdb,
    FanartClient fanart,
    OmdbClient omdb,
    RottenTomatoesClient tomaten,
    ITmdbSettingsSource spracheVon)
{
    /// <summary>„The Matrix" — bei allen Quellen vorhanden.</summary>
    private const int ProbeTmdbId = 603;
    private const string ProbeImdbId = "tt0133093";
    private const string ProbeTitel = "The Matrix";
    private const int ProbeJahr = 1999;

    public async Task<IReadOnlyList<Quellenbefund>> LaufenAsync(CancellationToken ct = default) =>
    [
        await TmdbProbe(ct),
        await FanartProbe(ct),
        await OmdbProbe(ct),
        await TomatenProbe(ct),
    ];

    private async Task<Quellenbefund> TmdbProbe(CancellationToken ct)
    {
        if (!await tmdb.IsConfiguredAsync(ct))
            return new("tmdb", false, false, "Kein Zugang hinterlegt.");

        var film = await tmdb.FindMovieAsync("The Matrix", 1999, ct);

        return film is null
            ? new("tmdb", true, false,
                "Der Dienst hat nicht geantwortet oder den Zugang abgelehnt.")
            : new("tmdb", true, true,
                $"Erreichbar — Probeabruf ergab {film.Title} ({film.Year}).");
    }

    private async Task<Quellenbefund> FanartProbe(CancellationToken ct)
    {
        if (!await fanart.EingerichtetAsync(ct))
            return new("fanart", false, false, "Kein Schlüssel hinterlegt — die Quelle ist aus.");

        var bilder = await fanart.FilmbilderAsync(ProbeTmdbId, ct);
        var plakate = bilder.Where(b => b.Kind == "poster").ToList();

        if (plakate.Count == 0)
        {
            return new("fanart", true, false,
                "Erreicht, aber nichts bekommen. Stimmt der Schlüssel?");
        }

        // **Die Zahl in der eingestellten Sprache ist die eigentliche
        // Auskunft.** „42 Plakate" sagt nur, dass etwas kam; „davon 3
        // deutsche" sagt, ob die Quelle den Zweck erfüllt, für den sie da ist.
        var sprache = (await spracheVon.GetAsync(ct)).Language.Split('-')[0];
        var passend = plakate.Count(b =>
            string.Equals(b.Language, sprache, StringComparison.OrdinalIgnoreCase));

        return new("fanart", true, true,
            $"Erreichbar — {plakate.Count} Plakate zu The Matrix, davon {passend} in {sprache}.");
    }

    private async Task<Quellenbefund> OmdbProbe(CancellationToken ct)
    {
        if (!await omdb.EingerichtetAsync(ct))
            return new("omdb", false, false, "Kein Schlüssel hinterlegt — die Quelle ist aus.");

        var wertungen = await omdb.HolenAsync(
            new Wertungsfrage(ProbeImdbId, ProbeTitel, ProbeJahr), ct);

        if (wertungen.Count == 0)
        {
            return new("omdb", true, false,
                "Erreicht, aber nichts bekommen. Stimmt der Schlüssel, "
                + "oder ist das Tageskontingent aufgebraucht?");
        }

        return new("omdb", true, true, $"Erreichbar — zu The Matrix: {Aufzaehlung(wertungen)}.");
    }

    /// <summary>Die Seite von Rotten Tomatoes, falls das Lesen erlaubt wurde.</summary>
    ///
    /// <remarks>
    /// <b>Hier ist die Probe mehr als eine Höflichkeit.</b> Bei den anderen
    /// beantwortet sie die Frage, ob ein Schlüssel stimmt; hier beantwortet
    /// sie die Frage, ob das Auslesen überhaupt noch geht. Wird die Seite
    /// umgebaut oder der Zugriff gesperrt, merkt man es genau hier — und
    /// sonst nirgends.
    /// </remarks>
    private async Task<Quellenbefund> TomatenProbe(CancellationToken ct)
    {
        if (!await tomaten.EingerichtetAsync(ct))
            return new("rottenTomatoes", false, false, "Ausgeschaltet.");

        var wertungen = await tomaten.HolenAsync(
            new Wertungsfrage(ProbeImdbId, ProbeTitel, ProbeJahr), ct);

        if (wertungen.Count == 0)
        {
            return new("rottenTomatoes", true, false,
                "Nichts bekommen. Entweder ist der Zugriff gesperrt, "
                + "oder die Seite ist umgebaut worden.");
        }

        return new("rottenTomatoes", true, true,
            $"Erreichbar — zu The Matrix: {Aufzaehlung(wertungen)}.");
    }

    private static string Aufzaehlung(IEnumerable<Fremdwertung> wertungen) =>
        string.Join(", ", wertungen.Select(w => $"{Kurz(w.Quelle)} {w.Anzeige}"));

    private static string Kurz(string quelle) => quelle switch
    {
        "imdb" => "IMDb",
        "rottenTomatoes" => "RT Kritik",
        "rottenTomatoesAudience" => "RT Publikum",
        "metacritic" => "MC",
        _ => quelle,
    };
}