using Flaro.Core.Metadata;
using Microsoft.Extensions.Logging.Abstractions;

namespace Flaro.Metadata.Tests;

/// <summary>Die beiden Werte von Rotten Tomatoes, von der Seite selbst gelesen.</summary>
///
/// <remarks>
/// <b>Gegen einen festgehaltenen Seitenausschnitt, nicht gegen das Netz.</b>
/// Eine Prüfung, die wirklich hinausgeht, misst das Netz und nicht den Code;
/// sie wäre launisch und fiele aus, sobald jemand ohne Verbindung arbeitet.
/// Der Ausschnitt unten ist gekürzt, aber in der Form, die
/// <c>/m/the_matrix</c> am 9. Oktober 2026 geliefert hat.
/// </remarks>
public class RottenTomatoesTests
{
    private static string Seite(
        string art = "Movie", string name = "The Matrix", string datum = "1999-03-31",
        string kritik = "83", string publikum = "85") =>
        $$$"""
        <html><head>
        <script type="application/ld+json">
        {"@context":"http://schema.org","@type":"{{{art}}}","name":"{{{name}}}",
         "dateCreated":"{{{datum}}}","url":"https://www.rottentomatoes.com/m/matrix"}
        </script>
        </head><body>
        <script>window.__data = {"audienceScore":{"averageRating":"3.6",
          "likedCount":142778,"score":"{{{publikum}}}","scoreType":"ALL",
          "sentiment":"POSITIVE","scorePercent":"{{{publikum}}}%","title":"Popcornmeter"},
          "criticsScore":{"averageRating":"7.90","certified":true,
          "score":"{{{kritik}}}","sentiment":"POSITIVE","scorePercent":"{{{kritik}}}%"}};
        </script>
        </body></html>
        """;

    private static RottenTomatoesClient Client(Attrappe attrappe, bool an = true) =>
        new(new HttpClient(attrappe) { BaseAddress = new Uri(RottenTomatoesClient.BaseAddress) },
            new FesterTomatenschalter(an),
            // Ohne Pause: die Bremse ist eine Höflichkeit gegenüber der
            // echten Seite, und eine Prüfung geht nirgends hin.
            new Anklopfbremse(TimeSpan.Zero),
            NullLogger<RottenTomatoesClient>.Instance);

    private static Wertungsfrage Matrix => new("tt0133093", "The Matrix", 1999);

    /// <summary>Ausgeschaltet heisst: keine einzige Anfrage.</summary>
    ///
    /// <remarks>
    /// <b>Das ist der wichtigste Satz dieser Datei.</b> Hier wird eine fremde
    /// Webseite ausgelesen; das darf nicht beiläufig geschehen, weil jemand
    /// einen Scan startet.
    /// </remarks>
    [Test]
    public async Task Ausgeschaltet_geht_keine_Anfrage_hinaus()
    {
        var attrappe = Attrappe.MitJson(Seite());

        var wertungen = await Client(attrappe, an: false).HolenAsync(Matrix);

        Assert.Multiple(() =>
        {
            Assert.That(wertungen, Is.Empty);
            Assert.That(attrappe.Aufrufe, Is.Empty);
        });
    }

    /// <summary>Kritik und Publikum kommen getrennt zurück.</summary>
    [Test]
    public async Task Beide_Werte_kommen_getrennt()
    {
        var wertungen = await Client(Attrappe.MitJson(Seite())).HolenAsync(Matrix);

        Assert.Multiple(() =>
        {
            var kritik = wertungen.Single(w => w.Quelle == "rottenTomatoes");
            Assert.That(kritik.Anzeige, Is.EqualTo("83%"));
            Assert.That(kritik.Wert, Is.EqualTo(8.3).Within(0.01));

            var publikum = wertungen.Single(w => w.Quelle == "rottenTomatoesAudience");
            Assert.That(publikum.Anzeige, Is.EqualTo("85%"));
            Assert.That(publikum.Wert, Is.EqualTo(8.5).Within(0.01));
        });
    }

    /// <summary>Der gewöhnliche Titel kostet genau eine Anfrage.</summary>
    ///
    /// <remarks>
    /// <b>Gemessen an der echten Seite:</b> <c>/m/the_matrix</c> antwortet,
    /// <c>/m/the_matrix_1999</c> mit 404. Mit Jahr zuerst zu fragen kostete
    /// bei jedem gewöhnlichen Titel eine Anfrage zu viel — auf einer Seite,
    /// die man ohnehin nur mitbenutzt.
    /// </remarks>
    [Test]
    public async Task Ein_gewoehnlicher_Titel_kostet_eine_Anfrage()
    {
        var attrappe = Attrappe.MitJson(Seite());

        await Client(attrappe).HolenAsync(Matrix);

        Assert.Multiple(() =>
        {
            Assert.That(attrappe.Aufrufe, Has.Count.EqualTo(1));
            Assert.That(attrappe.Aufrufe[0], Does.EndWith("m/the_matrix"));
        });
    }

    /// <summary>Ein Film mit anderem Jahr ist ein anderer Film.</summary>
    ///
    /// <remarks>
    /// <b>Auf der Seite steht keine IMDb-Kennung.</b> Der Weg wird aus dem
    /// Titel geraten, und ein geratener Weg kann überall hinführen. Lieber
    /// keine Zahl als die eines fremden Films.
    /// </remarks>
    [Test]
    public async Task Ein_fremdes_Jahr_wird_verworfen()
    {
        var attrappe = Attrappe.MitJson(Seite(name: "The Lion King", datum: "1994-06-24"));

        var wertungen = await Client(attrappe)
            .HolenAsync(new Wertungsfrage(null, "The Lion King", 2019));

        Assert.That(wertungen, Is.Empty);
    }

    /// <summary>Beim falschen Jahr wird der Weg mit Jahr nachgereicht.</summary>
    ///
    /// <remarks>
    /// <b>Die Neuverfilmung ist der einzige Fall, der zwei Anfragen
    /// rechtfertigt.</b> <c>/m/the_lion_king</c> ist die von 1994,
    /// <c>/m/the_lion_king_2019</c> die neue. Erst wird die alte am Jahr
    /// erkannt und verworfen, dann greift die zweite.
    /// </remarks>
    [Test]
    public async Task Eine_Neuverfilmung_wird_ueber_den_Weg_mit_Jahr_gefunden()
    {
        var attrappe = Attrappe.NachPfad(
            ("the_lion_king_2019", Seite(name: "The Lion King (2019)", datum: "2019-07-19",
                                         kritik: "52", publikum: "88")),
            ("the_lion_king", Seite(name: "The Lion King", datum: "1994-06-24",
                                    kritik: "93", publikum: "93")));

        var wertungen = await Client(attrappe)
            .HolenAsync(new Wertungsfrage(null, "The Lion King", 2019));

        Assert.Multiple(() =>
        {
            Assert.That(attrappe.Aufrufe, Has.Count.EqualTo(2));
            Assert.That(wertungen.Single(w => w.Quelle == "rottenTomatoes").Anzeige,
                Is.EqualTo("52%"), "die Fassung von 2019, nicht die von 1994");
            Assert.That(wertungen.Single(w => w.Quelle == "rottenTomatoesAudience").Anzeige,
                Is.EqualTo("88%"));
        });
    }

    /// <summary>Ein Jahr daneben ist kein anderer Film.</summary>
    ///
    /// <remarks>
    /// Rotten Tomatoes führt das Datum der amerikanischen Erstaufführung,
    /// TMDB oft das der Heimatpremiere — ein Film vom Dezember steht dort
    /// schon mal im Folgejahr.
    /// </remarks>
    [Test]
    public async Task Ein_Jahr_Unterschied_zaehlt_noch_als_derselbe()
    {
        var wertungen = await Client(Attrappe.MitJson(Seite(datum: "2000-01-20")))
            .HolenAsync(Matrix);

        Assert.That(wertungen, Has.Count.EqualTo(2));
    }

    /// <summary>Eine Serie darf nicht auf einer Filmseite landen.</summary>
    [Test]
    public async Task Eine_Filmseite_beantwortet_keine_Seriensuche()
    {
        var wertungen = await Client(Attrappe.MitJson(Seite(art: "Movie", name: "Dark")))
            .HolenAsync(new Wertungsfrage(null, "Dark", 1999, Serie: true));

        Assert.That(wertungen, Is.Empty);
    }

    [Test]
    public async Task Eine_Serie_wird_unter_tv_gesucht()
    {
        var attrappe = Attrappe.MitJson(
            Seite(art: "TVSeries", name: "Dark", datum: "2017-12-01"));

        var wertungen = await Client(attrappe)
            .HolenAsync(new Wertungsfrage(null, "Dark", 2017, Serie: true));

        Assert.Multiple(() =>
        {
            Assert.That(attrappe.Aufrufe[0], Does.EndWith("tv/dark"),
                "Serien stehen dort ohne Jahr: /tv/dark_2017 antwortet mit 404.");
            Assert.That(wertungen, Has.Count.EqualTo(2));
        });
    }

    /// <summary>Ein unbekannter Weg endet mit 404 — und das ist eine Antwort.</summary>
    [Test]
    public async Task Ein_unbekannter_Weg_ergibt_nichts()
    {
        var wertungen = await Client(Attrappe.MitStatus(System.Net.HttpStatusCode.NotFound))
            .HolenAsync(Matrix);

        Assert.That(wertungen, Is.Empty);
    }

    /// <summary>Eine Sperrseite ohne die bekannten Felder ergibt nichts, keinen Absturz.</summary>
    [Test]
    public async Task Eine_umgebaute_Seite_ergibt_nichts()
    {
        var wertungen = await Client(Attrappe.MitJson("<html><body>Nichts hier.</body></html>"))
            .HolenAsync(Matrix);

        Assert.That(wertungen, Is.Empty);
    }

    [Test]
    public async Task Kein_Netz_ergibt_nichts_statt_eines_Absturzes()
    {
        var wertungen = await Client(Attrappe.DieWirft(new HttpRequestException("weg")))
            .HolenAsync(Matrix);

        Assert.That(wertungen, Is.Empty);
    }

    /// <summary>Der Originaltitel wird zuerst versucht.</summary>
    ///
    /// <remarks>
    /// <b>Sonst fände ein deutscher Bestand dort so gut wie nichts.</b> Steht
    /// die Mediathek auf Deutsch, heisst der Film bei uns „Ich einfach
    /// unverbesserlich"; Rotten Tomatoes kennt nur <c>despicable_me</c>.
    /// </remarks>
    [Test]
    public async Task Der_Originaltitel_wird_zuerst_versucht()
    {
        var attrappe = Attrappe.NachPfad(
            ("despicable_me", Seite(name: "Despicable Me", datum: "2010-07-09",
                                    kritik: "81", publikum: "84")));

        var wertungen = await Client(attrappe).HolenAsync(new Wertungsfrage(
            null, "Ich einfach unverbesserlich", 2010, Originaltitel: "Despicable Me"));

        Assert.Multiple(() =>
        {
            Assert.That(attrappe.Aufrufe[0], Does.EndWith("m/despicable_me"));
            Assert.That(wertungen.Single(w => w.Quelle == "rottenTomatoesAudience").Anzeige,
                Is.EqualTo("84%"));
        });
    }

    /// <summary>Gibt es den Originaltitel dort nicht, kommt der deutsche dran.</summary>
    [Test]
    public async Task Ohne_Treffer_wird_auch_der_andere_Titel_versucht()
    {
        var attrappe = Attrappe.NachPfad(
            ("ich_einfach_unverbesserlich",
             Seite(name: "Ich einfach unverbesserlich", datum: "2010-07-09")));

        var wertungen = await Client(attrappe).HolenAsync(new Wertungsfrage(
            null, "Ich einfach unverbesserlich", 2010, Originaltitel: "Despicable Me"));

        Assert.Multiple(() =>
        {
            Assert.That(attrappe.Aufrufe[0], Does.Contain("despicable_me"), "der originale zuerst");
            Assert.That(wertungen, Has.Count.EqualTo(2));
        });
    }

    /// <summary>Derselbe Titel zweimal ergibt nicht zwei Anfragen.</summary>
    [Test]
    public async Task Ein_gleicher_Originaltitel_kostet_nichts_extra()
    {
        var attrappe = Attrappe.MitJson(Seite());

        await Client(attrappe).HolenAsync(
            new Wertungsfrage(null, "The Matrix", 1999, Originaltitel: "The Matrix"));

        Assert.That(attrappe.Aufrufe, Has.Count.EqualTo(1));
    }

    /// <summary>Einmal wirklich hinaus — nur von Hand.</summary>
    ///
    /// <remarks>
    /// <para>
    /// <b><c>[Explicit]</c>, und das ist der Punkt.</b> Diese Prüfung misst
    /// das Netz und eine fremde Seite, nicht den Code; im Durchlauf wäre sie
    /// launisch und fiele ohne Verbindung aus. Von Hand ist sie dagegen das
    /// einzige, was die Frage beantwortet, ob das Auslesen heute noch geht:
    /// </para>
    /// <para>
    /// <c>dotnet test --filter "FullyQualifiedName~Wirklich_von_der_echten_Seite"</c>
    /// </para>
    /// </remarks>
    [Test, Explicit("Geht wirklich ins Netz.")]
    public async Task Wirklich_von_der_echten_Seite_gelesen()
    {
        using var echt = new HttpClient { BaseAddress = new Uri(RottenTomatoesClient.BaseAddress) };
        echt.DefaultRequestHeaders.UserAgent.ParseAdd(
            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) "
            + "Chrome/131.0.0.0 Safari/537.36");

        var client = new RottenTomatoesClient(
            echt, new FesterTomatenschalter(true), new Anklopfbremse(TimeSpan.Zero),
            NullLogger<RottenTomatoesClient>.Instance);

        var wertungen = await client.HolenAsync(Matrix);

        Assert.Multiple(() =>
        {
            Assert.That(wertungen.Select(w => w.Quelle),
                Is.EquivalentTo(new[] { "rottenTomatoes", "rottenTomatoesAudience" }));
            TestContext.Out.WriteLine(string.Join(", ",
                wertungen.Select(w => $"{w.Quelle} {w.Anzeige}")));
        });
    }

    /// <summary>So baut Rotten Tomatoes seine Wege.</summary>
    [TestCase("The Matrix", ExpectedResult = "the_matrix")]
    [TestCase("Spider-Man: No Way Home", ExpectedResult = "spider_man_no_way_home")]
    [TestCase("WALL·E", ExpectedResult = "wall_e")]
    [TestCase("Ich einfach unverbesserlich", ExpectedResult = "ich_einfach_unverbesserlich")]
    [TestCase("Österreich – Grüße", ExpectedResult = "osterreich_grusse")]
    [TestCase("  ", ExpectedResult = "")]
    public string Aus_dem_Titel_wird_ein_Weg(string titel) =>
        RottenTomatoesClient.Kennstueck(titel);
}

public sealed record FesterTomatenschalter(bool An) : IRottenTomatoesSettingsSource
{
    public Task<bool> EingeschaltetAsync(CancellationToken ct = default) => Task.FromResult(An);
}