using Flaro.Core.Delivery;
using Flaro.Core.Library;

namespace Flaro.Core.Tests;

public class DeliveryDeciderTests
{
    private static ProbedStream Bild(string codec = "h264") =>
        new(0, MediaStreamKind.Video, codec, null, null, true, false, null, 1920, 1080);

    private static ProbedStream Ton(int index, string codec = "aac", string? sprache = "deu", string? name = null) =>
        new(index, MediaStreamKind.Audio, codec, sprache, name, index == 1, false, 6, null, null);

    private static ProbedStream Text(int index, string codec = "subrip") =>
        new(index, MediaStreamKind.Subtitle, codec, "deu", null, false, false, null, null, null);

    [Test]
    public void Eine_passende_MP4_geht_unveraendert_hinaus()
    {
        var plan = DeliveryDecider.ForDownload("mp4", [Bild(), Ton(1)]);

        Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
        Assert.That(plan.NeedsWork, Is.False);
        Assert.That(plan.Reasons, Is.EqualTo(new[] { DeliveryReason.NativelySupported }));
    }

    [Test]
    public void Eine_Matroska_muss_umgepackt_werden_auch_wenn_alles_darin_passt()
    {
        var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1)]);

        Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.Remux));
        Assert.That(plan.Reasons, Does.Contain(DeliveryReason.ContainerUnsupported));
        // Das Bild bleibt unberührt, und kein Ton muss gerechnet werden.
        Assert.That(plan.AudioToEncode, Is.Empty);
    }

    /// <summary>Der Fall, um den es im ganzen Projekt geht.</summary>
    ///
    /// <remarks>
    /// <b>Zwei Tonspuren, und beide kommen mit.</b> Der Plan hat gar kein Feld
    /// „welche Tonspur" — und das ist der Unterschied zu Jellyfin, dessen
    /// Transcode-Endpunkt je Sitzung genau eine abbildet. Wer hier eine
    /// auswählen wollte, fände keine Stelle dafür.
    /// </remarks>
    [Test]
    public void Alle_Tonspuren_bleiben_erhalten()
    {
        var plan = DeliveryDecider.ForDownload("mkv",
            [Bild(), Ton(1, name: "Deutsch"), Ton(2, name: "Audiodeskription"), Ton(3, sprache: "eng")]);

        Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.Remux));
        Assert.That(plan.AudioToEncode, Is.Empty, "Alle drei passen und werden nur umgepackt");
        Assert.That(plan.SubtitlesDropped, Is.Empty);
    }

    /// <summary>DTS kennt AVPlayer nicht — nur diese eine Spur wird gerechnet.</summary>
    [Test]
    public void Nur_untaugliche_Tonspuren_werden_neu_gerechnet()
    {
        var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "aac"), Ton(2, "dts"), Ton(3, "truehd")]);

        Assert.That(plan.AudioToEncode, Is.EqualTo(new[] { 2, 3 }));
        Assert.That(plan.Reasons, Does.Contain(DeliveryReason.AudioCodecUnsupported));
    }

    [Test]
    public void Textuntertitel_werden_fuer_MP4_umgeschrieben()
    {
        var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1), Text(2, "subrip")]);

        Assert.That(plan.Reasons, Does.Contain(DeliveryReason.SubtitlesNeedConversion));
        Assert.That(plan.SubtitlesDropped, Is.Empty);
    }

    /// <summary>Betrifft fast jeden Blu-ray-Rip.</summary>
    ///
    /// <remarks>
    /// PGS liegt als Bild vor, und in eine MP4 passt das nicht. Diese Spuren
    /// fallen weg — und das muss gesagt werden, statt stillschweigend zu
    /// geschehen: sonst sucht jemand nach Untertiteln, die der Server bewusst
    /// weggelassen hat.
    /// </remarks>
    [Test]
    public void Bilduntertitel_fallen_weg_und_das_steht_im_Plan()
    {
        var plan = DeliveryDecider.ForDownload("mkv",
            [Bild(), Ton(1), Text(2, "hdmv_pgs_subtitle"), Text(3, "subrip")]);

        Assert.That(plan.SubtitlesDropped, Is.EqualTo(new[] { 2 }));
        Assert.That(plan.Reasons, Does.Contain(DeliveryReason.ImageSubtitlesDropped));
    }

    [Test]
    public void Ein_untaugliches_Bild_verlangt_ebenfalls_Umpacken()
    {
        var plan = DeliveryDecider.ForDownload("mkv", [Bild("vp9"), Ton(1)]);
        Assert.That(plan.Reasons, Does.Contain(DeliveryReason.VideoCodecUnsupported));
    }

    /// <summary>Was die Datei nicht nennt, gilt als passend.</summary>
    ///
    /// <remarks>
    /// Vorsichtshalber umzupacken hiesse, aus einer tadellosen MP4 eine neue
    /// Datei zu machen — für eine Angabe, die schlicht fehlt.
    /// </remarks>
    [Test]
    public void Fehlende_Angaben_loesen_kein_Umpacken_aus()
    {
        var plan = DeliveryDecider.ForDownload(null,
            [Bild(null!) with { Codec = null }, Ton(1) with { Codec = null }]);

        Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
    }

    [Test]
    public void Jeder_Grund_steht_nur_einmal_da()
    {
        var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "dts"), Ton(2, "truehd"), Ton(3, "vorbis")]);

        Assert.That(plan.Reasons.Count(g => g == DeliveryReason.AudioCodecUnsupported), Is.EqualTo(1));
    }

    [Test]
    public void Ein_eigenes_Geraeteprofil_sticht_die_Voreinstellung()
    {
        var alleskoenner = new DeviceProfile(
            new HashSet<string> { "mkv" }, new HashSet<string> { "h264" }, new HashSet<string> { "dts" });

        var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "dts")], alleskoenner);
        Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
    }
}