ersatztv/ErsatzTV.Tests/Application/Channels/GetChannelStatesForApiHandlerTests.cs

using ErsatzTV.Application.Channels;
using ErsatzTV.Core.Api.Channels;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Domain.Filler;
using ErsatzTV.Core.Interfaces.FFmpeg;
using ErsatzTV.Core.Interfaces.Streaming;
using ErsatzTV.Infrastructure.Data;
using ErsatzTV.Tests.Support;
using NSubstitute;
using NUnit.Framework;
using Shouldly;

namespace ErsatzTV.Tests.Application.Channels;

[TestFixture]
public class GetChannelStatesForApiHandlerTests
{
    private static readonly DateTime Now = new(2026, 7, 2, 12, 0, 0, DateTimeKind.Utc);

    private InMemoryTvContext _db = null!;
    private IFFmpegSegmenterService _segmenter = null!;
    private IDirectStreamSessionTracker _directStreams = null!;

    [SetUp]
    public async Task SetUp()
    {
        _db = await InMemoryTvContext.CreateAsync();
        _segmenter = Substitute.For<IFFmpegSegmenterService>();
        _directStreams = Substitute.For<IDirectStreamSessionTracker>();
    }

    [TearDown]
    public async Task TearDown() => await _db.DisposeAsync();

    [Test]
    public async Task Handle_Should_Return_OnAir_And_Current_NowPlaying()
    {
        DateTime start = Now.AddMinutes(-10);
        DateTime finish = Now.AddMinutes(20);
        await SeedChannelWithMovie(start, finish);
        _segmenter.IsActive("7.1").Returns(true);
        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
        state.ChannelId.ShouldBe(7);
        state.ChannelNumber.ShouldBe("7.1");
        state.OnAir.ShouldBeTrue();
        state.NowPlaying.ShouldNotBeNull();
        state.NowPlaying.Title.ShouldBe("Retro Cartoons");
        state.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(start, TimeSpan.Zero));
        state.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(finish, TimeSpan.Zero));
    }

    [Test]
    public async Task Handle_Should_Return_OnAir_For_Direct_Stream_Session()
    {
        await using TvContext context = _db.CreateContext();
        context.Channels.Add(MakeChannel(8, "8"));
        await context.SaveChangesAsync();
        _directStreams.IsActive("8").Returns(true);
        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        result.ShouldHaveSingleItem().OnAir.ShouldBeTrue();
    }

    [Test]
    public async Task Handle_Should_Match_Item_When_Now_Equals_Start()
    {
        await SeedChannelWithMovie(Now, Now.AddMinutes(30));
        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        result.ShouldHaveSingleItem().NowPlaying.ShouldNotBeNull();
    }

    [Test]
    public async Task Handle_Should_Not_Match_Item_When_Now_Equals_Finish()
    {
        await SeedChannelWithMovie(Now.AddMinutes(-30), Now);
        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        result.ShouldHaveSingleItem().NowPlaying.ShouldBeNull();
    }

    [Test]
    public async Task Handle_Should_Return_Null_NowPlaying_When_No_Current_Item()
    {
        await using TvContext context = _db.CreateContext();
        context.Channels.Add(MakeChannel(8, "8"));
        await context.SaveChangesAsync();
        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
        state.OnAir.ShouldBeFalse();
        state.NowPlaying.ShouldBeNull();
    }

    [Test]
    public async Task Handle_Should_Surface_Program_Not_Filler_During_MidRoll_Break()
    {
        // program part 1 / mid-roll filler / program part 2, all in one guide group
        await using TvContext context = _db.CreateContext();
        Channel channel = MakeChannel(12, "12");
        var movie = new Movie
        {
            Id = 120,
            MovieMetadata = [new MovieMetadata { Title = "Feature Presentation" }]
        };
        var filler = new OtherVideo
        {
            Id = 121,
            OtherVideoMetadata = [new OtherVideoMetadata { Title = "Some Bumper" }]
        };
        var playout = new Playout { Id = 122, Channel = channel, ChannelId = channel.Id, Items = [] };
        PlayoutItem MakeItem(int id, MediaItem mediaItem, DateTime start, DateTime finish, FillerKind fillerKind) =>
            new()
            {
                Id = id,
                MediaItem = mediaItem,
                MediaItemId = mediaItem.Id,
                Playout = playout,
                PlayoutId = playout.Id,
                Start = start,
                Finish = finish,
                FillerKind = fillerKind,
                GuideGroup = 1,
                ChapterTitle = string.Empty
            };

        context.Channels.Add(channel);
        context.Movies.Add(movie);
        context.OtherVideos.Add(filler);
        context.Playouts.Add(playout);
        context.PlayoutItems.AddRange(
            MakeItem(123, movie, Now.AddMinutes(-20), Now.AddMinutes(-2), FillerKind.None),
            MakeItem(124, filler, Now.AddMinutes(-2), Now.AddMinutes(2), FillerKind.MidRoll),
            MakeItem(125, movie, Now.AddMinutes(2), Now.AddMinutes(40), FillerKind.None));
        await context.SaveChangesAsync();

        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
        state.NowPlaying.ShouldNotBeNull();
        state.NowPlaying.Title.ShouldBe("Feature Presentation");
        state.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(Now.AddMinutes(-20), TimeSpan.Zero));
        state.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(Now.AddMinutes(40), TimeSpan.Zero));
    }

    [Test]
    public async Task Handle_Should_Return_Null_NowPlaying_For_Guide_Entry_With_Only_Filler()
    {
        await using TvContext context = _db.CreateContext();
        Channel channel = MakeChannel(13, "13");
        var filler = new OtherVideo
        {
            Id = 130,
            OtherVideoMetadata = [new OtherVideoMetadata { Title = "Offline Loop" }]
        };
        var playout = new Playout { Id = 131, Channel = channel, ChannelId = channel.Id, Items = [] };
        var item = new PlayoutItem
        {
            Id = 132,
            MediaItem = filler,
            MediaItemId = filler.Id,
            Playout = playout,
            PlayoutId = playout.Id,
            Start = Now.AddMinutes(-5),
            Finish = Now.AddMinutes(5),
            FillerKind = FillerKind.Fallback,
            GuideGroup = 1,
            ChapterTitle = string.Empty
        };

        context.Channels.Add(channel);
        context.OtherVideos.Add(filler);
        context.Playouts.Add(playout);
        context.PlayoutItems.Add(item);
        await context.SaveChangesAsync();

        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        result.ShouldHaveSingleItem().NowPlaying.ShouldBeNull();
    }

    [Test]
    public async Task Handle_Should_Map_Remote_Stream_NowPlaying_Title()
    {
        DateTime start = Now.AddMinutes(-10);
        DateTime finish = Now.AddMinutes(20);

        await using TvContext context = _db.CreateContext();
        Channel channel = MakeChannel(9, "9");
        var remoteStream = new RemoteStream
        {
            Id = 90,
            RemoteStreamMetadata = [new RemoteStreamMetadata { Title = "Live Source" }]
        };
        var playout = new Playout { Id = 91, Channel = channel, ChannelId = channel.Id, Items = [] };
        var item = new PlayoutItem
        {
            Id = 92,
            MediaItem = remoteStream,
            MediaItemId = remoteStream.Id,
            Playout = playout,
            PlayoutId = playout.Id,
            Start = start,
            Finish = finish,
            ChapterTitle = string.Empty
        };

        context.Channels.Add(channel);
        context.RemoteStreams.Add(remoteStream);
        context.Playouts.Add(playout);
        context.PlayoutItems.Add(item);
        await context.SaveChangesAsync();

        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        ChannelStateResponseModel state =
            (await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None))
            .ShouldHaveSingleItem();

        state.NowPlaying.ShouldNotBeNull();
        state.NowPlaying.Title.ShouldBe("Live Source");
    }

    [Test]
    public async Task Handle_Should_Resolve_Mirror_Channel_NowPlaying_From_Source_With_Offset()
    {
        TimeSpan offset = TimeSpan.FromHours(1);
        DateTime sourceStart = Now.AddMinutes(-70);
        DateTime sourceFinish = Now.AddMinutes(-40);

        await using TvContext context = _db.CreateContext();
        Channel source = MakeChannel(10, "10");
        Channel mirror = MakeChannel(11, "11");
        mirror.PlayoutSource = ChannelPlayoutSource.Mirror;
        mirror.MirrorSourceChannelId = source.Id;
        mirror.PlayoutOffset = offset;

        var movie = new Movie
        {
            Id = 110,
            MovieMetadata = [new MovieMetadata { Title = "Offset Feature" }]
        };
        var playout = new Playout { Id = 111, Channel = source, ChannelId = source.Id, Items = [] };
        var item = new PlayoutItem
        {
            Id = 112,
            MediaItem = movie,
            MediaItemId = movie.Id,
            Playout = playout,
            PlayoutId = playout.Id,
            Start = sourceStart,
            Finish = sourceFinish,
            ChapterTitle = string.Empty
        };

        context.Channels.AddRange(source, mirror);
        context.Movies.Add(movie);
        context.Playouts.Add(playout);
        context.PlayoutItems.Add(item);
        await context.SaveChangesAsync();

        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter, _directStreams);

        List<ChannelStateResponseModel> result =
            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);

        ChannelStateResponseModel mirrorState = result.Single(s => s.ChannelId == mirror.Id);
        mirrorState.NowPlaying.ShouldNotBeNull();
        mirrorState.NowPlaying.Title.ShouldBe("Offset Feature");
        mirrorState.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(sourceStart + offset, TimeSpan.Zero));
        mirrorState.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(sourceFinish + offset, TimeSpan.Zero));

        // the source's own item is 40+ minutes in the past with no offset, so its own row is off-air
        ChannelStateResponseModel sourceState = result.Single(s => s.ChannelId == source.Id);
        sourceState.NowPlaying.ShouldBeNull();
    }

    private async Task SeedChannelWithMovie(DateTime start, DateTime finish)
    {
        await using TvContext context = _db.CreateContext();
        Channel channel = MakeChannel(7, "7.1");
        var movie = new Movie
        {
            Id = 10,
            MovieMetadata = [new MovieMetadata { Title = "Retro Cartoons" }]
        };
        var playout = new Playout
        {
            Id = 20,
            Channel = channel,
            ChannelId = channel.Id,
            Items = []
        };
        var item = new PlayoutItem
        {
            Id = 30,
            MediaItem = movie,
            MediaItemId = movie.Id,
            Playout = playout,
            PlayoutId = playout.Id,
            Start = start,
            Finish = finish,
            ChapterTitle = string.Empty
        };

        context.Channels.Add(channel);
        context.Movies.Add(movie);
        context.Playouts.Add(playout);
        context.PlayoutItems.Add(item);
        await context.SaveChangesAsync();
    }

    private static Channel MakeChannel(int id, string number) =>
        new(Guid.NewGuid())
        {
            Id = id,
            Number = number,
            SortNumber = id,
            Name = $"Channel {number}",
            Group = "Test",
            Categories = string.Empty,
            PreferredAudioLanguageCode = string.Empty
        };
}