scheduling fixes (#451)

* scheduling fixes

* restore plex service

* restore plex service part 2

CHANGELOG.md

@@ -5,9 +5,70 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
-## [0.1.3-alpha] - 2021-10-12
+## [0.2.0-alpha] - 2021-10-23
 ### Fixed
-- Fix startup bug for nvidia docker installations
+- Fix generated streams with mpeg2video
+- Fix incorrect row count in playout detail table
+- Fix deleting movies that have been removed from Jellyfin and Emby
+- Fix bug that caused large unscheduled gaps in playouts
+  - This was caused by schedule items with a fixed start of midnight
+
+### Added
+- Add new filler system
+    - `Pre-Roll Filler` plays before each media item
+    - `Mid-Roll Filler` plays between media item chapters
+    - `Post-Roll Filler` plays after each media item
+    - `Tail Filler` plays after all media items, until the next media item
+    - `Fallback Filler` loops instead of default offline image to fill any remaining gaps
+- Store chapter details with media statistics; this is needed to support mid-roll filler
+    - This requires re-ingesting statistics for all media items the first time this version is launched
+- Add switch to show/hide filler in playout detail table
+- Add `minutes` field to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Change some debug log messages to info so they show by default again
+- Remove tail collection options from `Duration` playout mode
+- Show localized start time in schedule items tables
+
+## [0.1.5-alpha] - 2021-10-18
+### Fixed
+- Fix double scheduling; this could happen if the app was shutdown during a playout build
+- Fix updating Jellyfin and Emby TV seasons
+- Fix updating Jellyfin and Emby artwork
+- Fix Plex, Jellyfin, Emby worker crash attempting to sync library that no longer exists
+- Fix bug with `Duration` mode scheduling when media items are too long to fit in the requested duration
+
+### Added
+- Include music video thumbnails in channel guide (xmltv)
+
+### Changed
+- Automatically find working Plex address on startup
+- Automatically select schedule item in schedules that contain only one item
+- Change default log level from `Debug` to `Information`
+  - The `Debug` log level can be enabled in the `appsettings.json` file for non-docker installs
+  - The `Debug` log level can be enabled by setting the environment variable `Serilog:MinimumLevel=Debug` for docker installs
+
+## [0.1.4-alpha] - 2021-10-14
+### Fixed
+- Fix error message/offline stream continuity with channels that use HLS Segmenter
+- Fix removing items from search index when folders are removed from local libraries
+
+### Added
+- Add `Other Video` local libraries
+  - Other video items require no metadata or particular folder layout, and will have tags added for each containing folder
+  - For Example, a video at `commercials/sd/1990/whatever.mkv` will have the tags `commercials`, `sd` and `1990`, and the title `whatever`
+- Add filler `Tail Mode` option to `Duration` playout mode (in addition to existing `Offline` option)
+  - Filler collection will always be randomized (to fill as much time as possible)
+  - Filler will be hidden from channel guide, but visible in playout details in ErsatzTV
+  - Unfilled time will show offline image
+- Add `Guide Mode` option to all schedule items
+  - `Normal` guide mode will show all scheduled items in the channel guide (xmltv)
+  - `Filler` guide mode will hide all scheduled items from the channel guide, and extend the end time for the previous item in the guide
+
+## [0.1.3-alpha] - 2021-10-13
+### Fixed
+- Fix startup bug for some docker installations
 
 ## [0.1.2-alpha] - 2021-10-12
 ### Added
@@ -695,7 +756,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.0-alpha...HEAD
+[0.2.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.5-alpha...v0.2.0-alpha
+[0.1.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...v0.1.5-alpha
+[0.1.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...v0.1.4-alpha
 [0.1.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.2-alpha...v0.1.3-alpha
 [0.1.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.1-alpha...v0.1.2-alpha
 [0.1.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.0-alpha...v0.1.1-alpha

ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs

@@ -0,0 +1,24 @@
+using System;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record CreateFillerPreset(
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId
+    ) : IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public CreateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(CreateFillerPreset request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+                var fillerPreset = new FillerPreset
+                {
+                    Name = request.Name,
+                    FillerKind = request.FillerKind,
+                    FillerMode = request.FillerMode,
+                    Duration = request.Duration,
+                    Count = request.Count,
+                    PadToNearestMinute = request.PadToNearestMinute,
+                    CollectionType = request.CollectionType,
+                    CollectionId = request.CollectionId,
+                    MediaItemId = request.MediaItemId,
+                    MultiCollectionId = request.MultiCollectionId,
+                    SmartCollectionId = request.SmartCollectionId
+                };
+
+                await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
+                await dbContext.SaveChangesAsync(cancellationToken);
+
+                return Unit.Default;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.Message);
+            }
+        }
+    }
+}

ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record DeleteFillerPreset(int FillerPresetId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
+}

ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs

@@ -0,0 +1,43 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public DeleteFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteFillerPreset request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+            return await validation.Apply(ps => DoDeletion(dbContext, ps));
+        }
+
+        private static Task<Unit> DoDeletion(TvContext dbContext, FillerPreset fillerPreset)
+        {
+            dbContext.FillerPresets.Remove(fillerPreset);
+            return dbContext.SaveChangesAsync().ToUnit();
+        }
+
+        private Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+            TvContext dbContext,
+            DeleteFillerPreset request) =>
+            dbContext.FillerPresets
+                .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId)
+                .Map(o => o.ToValidation<BaseError>($"FillerPreset {request.FillerPresetId} does not exist."));
+    }
+}

ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs

@@ -0,0 +1,25 @@
+using System;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record UpdateFillerPreset(
+        int Id,
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId
+    ) : IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(UpdateFillerPreset request, CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+            return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
+        }
+
+        private async Task<Unit> ApplyUpdateRequest(
+            TvContext dbContext,
+            FillerPreset existing,
+            UpdateFillerPreset request)
+        {
+            existing.Name = request.Name;
+            existing.FillerKind = request.FillerKind;
+            existing.FillerMode = request.FillerMode;
+            existing.Duration = request.Duration;
+            existing.Count = request.Count;
+            existing.PadToNearestMinute = request.PadToNearestMinute;
+            existing.CollectionType = request.CollectionType;
+            existing.CollectionId = request.CollectionId;
+            existing.MediaItemId = request.MediaItemId;
+            existing.MultiCollectionId = request.MultiCollectionId;
+            existing.SmartCollectionId = request.SmartCollectionId;
+
+            await dbContext.SaveChangesAsync();
+
+            return Unit.Default;
+        }
+
+        private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+            TvContext dbContext,
+            UpdateFillerPreset request) =>
+            dbContext.FillerPresets
+                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
+                .Map(o => o.ToValidation<BaseError>("FillerPreset does not exist"));
+    }
+}

ErsatzTV.Application/Filler/FillerPresetViewModel.cs

@@ -0,0 +1,20 @@
+using System;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Filler
+{
+    public record FillerPresetViewModel(
+        int Id,
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId);
+}

ErsatzTV.Application/Filler/Mapper.cs

@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Filler
+{
+    internal static class Mapper
+    {
+        internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
+            new(
+                fillerPreset.Id,
+                fillerPreset.Name,
+                fillerPreset.FillerKind,
+                fillerPreset.FillerMode,
+                fillerPreset.Duration,
+                fillerPreset.Count,
+                fillerPreset.PadToNearestMinute,
+                fillerPreset.CollectionType,
+                fillerPreset.CollectionId,
+                fillerPreset.MediaItemId,
+                fillerPreset.MultiCollectionId,
+                fillerPreset.SmartCollectionId);
+    }
+}

ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.Filler
+{
+    public record PagedFillerPresetsViewModel(int TotalCount, List<FillerPresetViewModel> Page);
+}

ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetAllFillerPresets : IRequest<List<FillerPresetViewModel>>;
+}

ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using LanguageExt;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetAllFillerPresetsHandler : IRequestHandler<GetAllFillerPresets, List<FillerPresetViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetAllFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<List<FillerPresetViewModel>> Handle(
+            GetAllFillerPresets request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.FillerPresets.ToListAsync(cancellationToken)
+                .Map(presets => presets.Map(ProjectToViewModel).ToList());
+        }
+    }
+}

ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetFillerPresetById(int Id) : IRequest<Option<FillerPresetViewModel>>;
+}

ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs

@@ -0,0 +1,29 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetFillerPresetByIdHandler : IRequestHandler<GetFillerPresetById, Option<FillerPresetViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetFillerPresetByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Option<FillerPresetViewModel>> Handle(
+            GetFillerPresetById request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.FillerPresets
+                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+                .MapT(ProjectToViewModel);
+        }
+    }
+}

ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetPagedFillerPresets(int PageNum, int PageSize) : IRequest<PagedFillerPresetsViewModel>;
+}

ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using LanguageExt;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedFillerPresetsViewModel> Handle(
+            GetPagedFillerPresets request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM FillerPreset");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<FillerPresetViewModel> page = await dbContext.FillerPresets.FromSqlRaw(
+                    @"SELECT * FROM FillerPreset
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedFillerPresetsViewModel(count, page);
+        }
+    }
+}

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -8,6 +9,7 @@ using ErsatzTV.Application.MediaSources.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -22,15 +24,18 @@ namespace ErsatzTV.Application.Libraries.Commands
     {
         private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
         private readonly IEntityLocker _entityLocker;
+        private readonly ISearchIndex _searchIndex;
         private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
         public UpdateLocalLibraryHandler(
             ChannelWriter<IBackgroundServiceRequest> workerChannel,
             IEntityLocker entityLocker,
+            ISearchIndex searchIndex,
             IDbContextFactory<TvContext> dbContextFactory)
         {
             _workerChannel = workerChannel;
             _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
             _dbContextFactory = dbContextFactory;
         }
 
@@ -56,10 +61,21 @@ namespace ErsatzTV.Application.Libraries.Commands
                 .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
                 .ToList();
 
+            var toRemoveIds = toRemove.Map(lp => lp.Id).ToList();
+
+            List<int> itemsToRemove = await dbContext.MediaItems
+                .Filter(mi => toRemoveIds.Contains(mi.LibraryPathId))
+                .Map(mi => mi.Id)
+                .ToListAsync();
+            
             existing.Paths.RemoveAll(toRemove.Contains);
             existing.Paths.AddRange(toAdd);
 
-            await dbContext.SaveChangesAsync();
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                await _searchIndex.RemoveItems(itemsToRemove);
+                _searchIndex.Commit();
+            }
 
             if (toAdd.Count > 0 || toRemove.Count > 0 && _entityLocker.LockLibrary(existing.Id))
             {

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -9,7 +9,8 @@ namespace ErsatzTV.Application.MediaCards
         List<TelevisionSeasonCardViewModel> SeasonCards,
         List<TelevisionEpisodeCardViewModel> EpisodeCards,
         List<ArtistCardViewModel> ArtistCards,
-        List<MusicVideoCardViewModel> MusicVideoCards)
+        List<MusicVideoCardViewModel> MusicVideoCards,
+        List<OtherVideoCardViewModel> OtherVideoCards)
     {
         public bool UseCustomPlaybackOrder { get; set; }
     }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -103,6 +103,13 @@ namespace ErsatzTV.Application.MediaCards
                 musicVideoMetadata.Album,
                 GetThumbnail(musicVideoMetadata, None, None));
 
+        internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
+            new(
+                otherVideoMetadata.OtherVideoId,
+                otherVideoMetadata.Title,
+                otherVideoMetadata.OriginalTitle,
+                otherVideoMetadata.SortTitle);
+
         internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
             new(
                 artistMetadata.ArtistId,
@@ -133,6 +140,8 @@ namespace ErsatzTV.Application.MediaCards
                     .ToList(),
                 collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<OtherVideo>().Map(mv => ProjectToViewModel(mv.OtherVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
         internal static ActorCardViewModel ProjectToViewModel(

ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardResultsViewModel(
+        int Count,
+        List<OtherVideoCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}

ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs

@@ -0,0 +1,17 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardViewModel
+    (
+        int OtherVideoId,
+        string Title,
+        string Subtitle,
+        string SortTitle) : MediaCardViewModel(
+        OtherVideoId,
+        Title,
+        Subtitle,
+        SortTitle,
+        null)
+    {
+        public int CustomIndex { get; set; }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -80,6 +80,9 @@ namespace ErsatzTV.Application.MediaCards.Queries
                 .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Episode).Season)
                 .ThenInclude(s => s.SeasonMetadata)
+                .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+                .ThenInclude(ovm => ovm.Artwork)
                 .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                 .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
                 .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -12,5 +12,6 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         List<int> SeasonIds,
         List<int> EpisodeIds,
         List<int> ArtistIds,
-        List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+        List<int> MusicVideoIds,
+        List<int> OtherVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -56,6 +56,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                 .Append(request.EpisodeIds)
                 .Append(request.ArtistIds)
                 .Append(request.MusicVideoIds)
+                .Append(request.OtherVideoIds)
                 .ToList();
 
             var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();

ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddOtherVideoToCollection
+        (int CollectionId, int OtherVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs

@@ -0,0 +1,80 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddOtherVideoToCollectionHandler :
+        MediatR.IRequestHandler<AddOtherVideoToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddOtherVideoToCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            AddOtherVideoToCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
+        }
+
+        private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
+        {
+            parameters.Collection.MediaItems.Add(parameters.OtherVideo);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            (await CollectionMustExist(dbContext, request), await ValidateOtherVideo(dbContext, request))
+            .Apply((collection, episode) => new Parameters(collection, episode));
+
+        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.Collections
+                .Include(c => c.MediaItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+        private static Task<Validation<BaseError, OtherVideo>> ValidateOtherVideo(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.OtherVideos
+                .SelectOneAsync(m => m.Id, e => e.Id == request.OtherVideoId)
+                .Map(o => o.ToValidation<BaseError>("OtherVideo does not exist"));
+
+        private record Parameters(Collection Collection, OtherVideo OtherVideo);
+    }
+}

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -26,6 +26,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
         private readonly IMediator _mediator;
         private readonly IMovieFolderScanner _movieFolderScanner;
         private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
+        private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
         private readonly ITelevisionFolderScanner _televisionFolderScanner;
 
         public ScanLocalLibraryHandler(
@@ -34,6 +35,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
             IMovieFolderScanner movieFolderScanner,
             ITelevisionFolderScanner televisionFolderScanner,
             IMusicVideoFolderScanner musicVideoFolderScanner,
+            IOtherVideoFolderScanner otherVideoFolderScanner,
             IEntityLocker entityLocker,
             IMediator mediator,
             ILogger<ScanLocalLibraryHandler> logger)
@@ -43,6 +45,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
             _movieFolderScanner = movieFolderScanner;
             _televisionFolderScanner = televisionFolderScanner;
             _musicVideoFolderScanner = musicVideoFolderScanner;
+            _otherVideoFolderScanner = otherVideoFolderScanner;
             _entityLocker = entityLocker;
             _mediator = mediator;
             _logger = logger;
@@ -107,6 +110,13 @@ namespace ErsatzTV.Application.MediaSources.Commands
                                 progressMin,
                                 progressMax);
                             break;
+                        case LibraryMediaKind.OtherVideos:
+                            await _otherVideoFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                progressMin,
+                                progressMax);
+                            break;
                     }
 
                     libraryPath.LastScan = DateTime.UtcNow;

ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs

@@ -52,6 +52,21 @@ namespace ErsatzTV.Application.Playouts.Commands
                 .Include(p => p.ProgramSchedule)
                 .ThenInclude(ps => ps.Items)
                 .ThenInclude(psi => psi.MediaItem)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.PreRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.MidRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.PostRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.TailFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.FallbackFiller)
                 .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
                 .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
     }

ErsatzTV.Application/Playouts/Mapper.cs

@@ -8,13 +8,13 @@ namespace ErsatzTV.Application.Playouts
     {
         internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
             new(
-                GetDisplayTitle(playoutItem.MediaItem),
+                GetDisplayTitle(playoutItem),
                 playoutItem.StartOffset,
-                GetDisplayDuration(playoutItem.MediaItem));
+                GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));
 
-        private static string GetDisplayTitle(MediaItem mediaItem)
+        private static string GetDisplayTitle(PlayoutItem playoutItem)
         {
-            switch (mediaItem)
+            switch (playoutItem.MediaItem)
             {
                 case Episode e:
                     string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
@@ -28,6 +28,11 @@ namespace ErsatzTV.Application.Playouts
 
                     var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
                     var titlesString = $"{string.Join('/', episodeTitles)}";
+                    if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
+                    {
+                        titlesString += $" ({playoutItem.ChapterTitle})";
+                    }
+
                     return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
                 case Movie m:
                     return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
@@ -36,25 +41,21 @@ namespace ErsatzTV.Application.Playouts
                         .Map(am => $"{am.Title} - ").IfNone(string.Empty);
                     return mv.MusicVideoMetadata.HeadOrNone()
                         .Map(mvm => $"{artistName}{mvm.Title}")
+                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
                         .IfNone("[unknown music video]");
+                case OtherVideo ov:
+                    return ov.OtherVideoMetadata.HeadOrNone()
+                        .Map(ovm => ovm.Title ?? string.Empty)
+                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                        .IfNone("[unknown video]");
                 default:
                     return string.Empty;
             }
         }
 
-        private static string GetDisplayDuration(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem switch
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                MusicVideo mv => mv.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
-            };
-
-            return string.Format(
-                version.Duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                version.Duration);
-        }
+        private static string GetDisplayDuration(TimeSpan duration) =>
+            string.Format(
+                duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
+                duration);
     }
 }

ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Playouts.Queries
+{
+    public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
+}

ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs

@@ -1,8 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using LanguageExt;
 using MediatR;
@@ -11,21 +13,23 @@ using static ErsatzTV.Application.Playouts.Mapper;
 
 namespace ErsatzTV.Application.Playouts.Queries
 {
-    public class GetPlayoutItemsByIdHandler : IRequestHandler<GetPlayoutItemsById, PagedPlayoutItemsViewModel>
+    public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
     {
         private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-        public GetPlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
             _dbContextFactory = dbContextFactory;
 
         public async Task<PagedPlayoutItemsViewModel> Handle(
-            GetPlayoutItemsById request,
+            GetFuturePlayoutItemsById request,
             CancellationToken cancellationToken)
         {
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
+            DateTime now = DateTimeOffset.Now.UtcDateTime;
+
             int totalCount = await dbContext.PlayoutItems
-                .CountAsync(i => i.PlayoutId == request.PlayoutId, cancellationToken);
+                .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
             
             List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
                 .Include(i => i.MediaItem)
@@ -49,7 +53,13 @@ namespace ErsatzTV.Application.Playouts.Queries
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Episode).Season.Show)
                 .ThenInclude(s => s.ShowMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
                 .Filter(i => i.PlayoutId == request.PlayoutId)
+                .Filter(i => i.Finish >= now)
+                .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
                 .OrderBy(i => i.Start)
                 .Skip(request.PageNum * request.PageSize)
                 .Take(request.PageSize)

ErsatzTV.Application/Playouts/Queries/GetPlayoutItemsById.cs

@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetPlayoutItemsById(int PlayoutId, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
-}

ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs

@@ -8,6 +8,7 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Plex;
 using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
@@ -23,16 +24,22 @@ namespace ErsatzTV.Application.Plex.Commands
         private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
         private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlexTvApiClient _plexTvApiClient;
+        private readonly IPlexServerApiClient _plexServerApiClient;
+        private readonly IPlexSecretStore _plexSecretStore;
 
         public SynchronizePlexMediaSourcesHandler(
             IMediaSourceRepository mediaSourceRepository,
             IPlexTvApiClient plexTvApiClient,
+            IPlexServerApiClient plexServerApiClient,
+            IPlexSecretStore plexSecretStore,
             ChannelWriter<IPlexBackgroundServiceRequest> channel,
             IEntityLocker entityLocker,
             ILogger<SynchronizePlexMediaSourcesHandler> logger)
         {
             _mediaSourceRepository = mediaSourceRepository;
             _plexTvApiClient = plexTvApiClient;
+            _plexServerApiClient = plexServerApiClient;
+            _plexSecretStore = plexSecretStore;
             _channel = channel;
             _entityLocker = entityLocker;
             _logger = logger;
@@ -69,32 +76,76 @@ namespace ErsatzTV.Application.Plex.Commands
             return allExisting;
         }
 
-        private Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+        private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
         {
             Option<PlexMediaSource> maybeExisting =
                 allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
-            return maybeExisting.Match(
-                existing =>
-                {
-                    existing.Platform = server.Platform;
-                    existing.PlatformVersion = server.PlatformVersion;
-                    existing.ProductVersion = server.ProductVersion;
-                    existing.ServerName = server.ServerName;
-                    var toAdd = server.Connections
-                        .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                    var toRemove = existing.Connections
-                        .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                    return _mediaSourceRepository.Update(existing, server.Connections, toAdd, toRemove);
-                },
-                async () =>
-                {
-                    if (server.Connections.Any())
-                    {
-                        server.Connections.Head().IsActive = true;
-                    }
 
-                    await _mediaSourceRepository.Add(server);
-                });
+            foreach (PlexMediaSource existing in maybeExisting)
+            {
+                existing.Platform = server.Platform;
+                existing.PlatformVersion = server.PlatformVersion;
+                existing.ProductVersion = server.ProductVersion;
+                existing.ServerName = server.ServerName;
+                var toAdd = server.Connections
+                    .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                var toRemove = existing.Connections
+                    .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                await _mediaSourceRepository.Update(existing, toAdd, toRemove);
+                await FindConnectionToActivate(existing);
+            }
+
+            if (maybeExisting.IsNone)
+            {
+                await _mediaSourceRepository.Add(server);
+                await FindConnectionToActivate(server);
+            }
+        }
+
+        private async Task FindConnectionToActivate(PlexMediaSource server)
+        {
+            var prioritized = server.Connections.OrderBy(pc => pc.IsActive ? 0 : 1).ToList();
+            foreach (PlexConnection connection in server.Connections)
+            {
+                connection.IsActive = false;
+            }
+
+            Option<PlexServerAuthToken> maybeToken = await _plexSecretStore.GetServerAuthToken(server.ClientIdentifier);
+            foreach (PlexServerAuthToken token in maybeToken)
+            {
+                foreach (PlexConnection connection in prioritized)
+                {
+                    try
+                    {
+                        _logger.LogDebug("Attempting to locate to Plex at {Uri}", connection.Uri);
+                        if (await _plexServerApiClient.Ping(connection, token))
+                        {
+                            _logger.LogInformation("Located Plex at {Uri}", connection.Uri);
+                            connection.IsActive = true;
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        // do nothing
+                    }
+                }
+            }
+
+            if (maybeToken.IsNone)
+            {
+                _logger.LogError(
+                    "Unable to activate Plex connection for server {Server} without auth token",
+                    server.ServerName);
+            }
+
+            if (server.Connections.All(c => !c.IsActive))
+            {
+                _logger.LogError("Unable to locate Plex");
+                server.Connections.Head().IsActive = true;
+            }
+
+            await _mediaSourceRepository.Update(server, new List<PlexConnection>(), new List<PlexConnection>());
         }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -19,6 +19,12 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         PlaybackOrder PlaybackOrder,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail,
-        string CustomTitle) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+        TailMode TailMode,
+        string CustomTitle,
+        GuideMode GuideMode,
+        int? PreRollFillerId,
+        int? MidRollFillerId,
+        int? PostRollFillerId,
+        int? TailFillerId,
+        int? FallbackFillerId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
 }

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -15,7 +15,13 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         PlaybackOrder PlaybackOrder { get; }
         int? MultipleCount { get; }
         TimeSpan? PlayoutDuration { get; }
-        bool? OfflineTail { get; }
+        TailMode TailMode { get; }
         string CustomTitle { get; }
+        GuideMode GuideMode { get; }
+        int? PreRollFillerId { get; }
+        int? MidRollFillerId { get; }
+        int? PostRollFillerId { get; }
+        int? TailFillerId { get; }
+        int? FallbackFillerId { get; }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -1,11 +1,15 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
 using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.ProgramSchedules.Commands
 {
@@ -20,6 +24,33 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                 .SelectOneAsync(ps => ps.Id, ps => ps.Id == programScheduleId)
                 .Map(o => o.ToValidation<BaseError>("[ProgramScheduleId] does not exist."));
 
+        protected static async Task<Either<BaseError, ProgramSchedule>> FillerConfigurationMustBeValid(
+            TvContext dbContext,
+            IProgramScheduleItemRequest item,
+            ProgramSchedule programSchedule)
+        {
+            var allFillerIds = Optional(item.PreRollFillerId)
+                .Append(Optional(item.MidRollFillerId))
+                .Append(Optional(item.PostRollFillerId))
+                .ToList();
+
+            List<FillerPreset> allFiller = await dbContext.FillerPresets
+                .Filter(fp => allFillerIds.Contains(fp.Id))
+                .ToListAsync();
+            
+            if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
+            {
+                return BaseError.New("Schedule may only contain one filler preset that is configured to pad");
+            }
+
+            if (allFiller.Any(fp => fp.PadToNearestMinute.HasValue) && !item.FallbackFillerId.HasValue)
+            {
+                return BaseError.New("Fallback filler is required when padding");
+            }
+
+            return programSchedule;
+        }
+
         protected static Validation<BaseError, ProgramSchedule> PlayoutModeMustBeValid(
             IProgramScheduleItemRequest item,
             ProgramSchedule programSchedule)
@@ -55,9 +86,14 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                         return BaseError.New("[PlayoutDuration] is required for playout mode 'duration'");
                     }
 
-                    if (item.OfflineTail is null)
+                    if (item.TailMode == TailMode.Filler && item.TailFillerId == null)
                     {
-                        return BaseError.New("[OfflineTail] is required for playout mode 'duration'");
+                        return BaseError.New("Tail Filler is required with tail mode Filler");
+                    }
+
+                    if (item.TailFillerId != null && item.TailMode != TailMode.Filler)
+                    {
+                        return BaseError.New("Tail Filler will not be used unless tail mode is set to Filler");
                     }
 
                     break;
@@ -133,33 +169,45 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                 {
                     ProgramScheduleId = programSchedule.Id,
                     Index = index,
-                    StartTime = item.StartTime,
+                    StartTime = FixDuration(item.StartTime.GetValueOrDefault()),
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MultiCollectionId = item.MultiCollectionId,
                     SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
                     PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode,
+                    PreRollFillerId = item.PreRollFillerId,
+                    MidRollFillerId = item.MidRollFillerId,
+                    PostRollFillerId = item.PostRollFillerId,
+                    TailFillerId = item.TailFillerId,
+                    FallbackFillerId = item.FallbackFillerId
                 },
                 PlayoutMode.One => new ProgramScheduleItemOne
                 {
                     ProgramScheduleId = programSchedule.Id,
                     Index = index,
-                    StartTime = item.StartTime,
+                    StartTime = FixDuration(item.StartTime.GetValueOrDefault()),
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MultiCollectionId = item.MultiCollectionId,
                     SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
                     PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode,
+                    PreRollFillerId = item.PreRollFillerId,
+                    MidRollFillerId = item.MidRollFillerId,
+                    PostRollFillerId = item.PostRollFillerId,
+                    TailFillerId = item.TailFillerId,
+                    FallbackFillerId = item.FallbackFillerId
                 },
                 PlayoutMode.Multiple => new ProgramScheduleItemMultiple
                 {
                     ProgramScheduleId = programSchedule.Id,
                     Index = index,
-                    StartTime = item.StartTime,
+                    StartTime = FixDuration(item.StartTime.GetValueOrDefault()),
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MultiCollectionId = item.MultiCollectionId,
@@ -167,13 +215,19 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     MediaItemId = item.MediaItemId,
                     PlaybackOrder = item.PlaybackOrder,
                     Count = item.MultipleCount.GetValueOrDefault(),
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode,
+                    PreRollFillerId = item.PreRollFillerId,
+                    MidRollFillerId = item.MidRollFillerId,
+                    PostRollFillerId = item.PostRollFillerId,
+                    TailFillerId = item.TailFillerId,
+                    FallbackFillerId = item.FallbackFillerId
                 },
                 PlayoutMode.Duration => new ProgramScheduleItemDuration
                 {
                     ProgramScheduleId = programSchedule.Id,
                     Index = index,
-                    StartTime = item.StartTime,
+                    StartTime = FixDuration(item.StartTime.GetValueOrDefault()),
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MultiCollectionId = item.MultiCollectionId,
@@ -181,13 +235,19 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     MediaItemId = item.MediaItemId,
                     PlaybackOrder = item.PlaybackOrder,
                     PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
-                    OfflineTail = item.OfflineTail.GetValueOrDefault(),
-                    CustomTitle = item.CustomTitle
+                    TailMode = item.TailMode,
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode,
+                    PreRollFillerId = item.PreRollFillerId,
+                    MidRollFillerId = item.MidRollFillerId,
+                    PostRollFillerId = item.PostRollFillerId,
+                    TailFillerId = item.TailFillerId,
+                    FallbackFillerId = item.FallbackFillerId
                 },
                 _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
             };
 
         private static TimeSpan FixDuration(TimeSpan duration) =>
-            duration > TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
+            duration >= TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -20,8 +20,14 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         PlaybackOrder PlaybackOrder,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail,
-        string CustomTitle) : IProgramScheduleItemRequest;
+        TailMode TailMode,
+        string CustomTitle,
+        GuideMode GuideMode,
+        int? PreRollFillerId,
+        int? MidRollFillerId,
+        int? PostRollFillerId,
+        int? TailFillerId,
+        int? FallbackFillerId) : IProgramScheduleItemRequest;
 
     public record ReplaceProgramScheduleItems
         (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs

@@ -63,7 +63,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
                 .BindT(programSchedule => PlayoutModesMustBeValid(request, programSchedule))
                 .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
-                .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule));
+                .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule))
+                .BindT(programSchedule => FillerConfigurationsMustBeValid(dbContext, request, programSchedule));
 
         private static Validation<BaseError, ProgramSchedule> PlayoutModesMustBeValid(
             ReplaceProgramScheduleItems request,
@@ -77,6 +78,26 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             request.Items.Map(item => CollectionTypeMustBeValid(item, programSchedule)).Sequence()
                 .Map(_ => programSchedule);
 
+        private static async Task<Validation<BaseError, ProgramSchedule>> FillerConfigurationsMustBeValid(
+            TvContext dbContext,
+            ReplaceProgramScheduleItems request,
+            ProgramSchedule programSchedule)
+        {
+            foreach (ReplaceProgramScheduleItem item in request.Items)
+            {
+                Either<BaseError, ProgramSchedule> result = await FillerConfigurationMustBeValid(
+                    dbContext,
+                    item,
+                    programSchedule);
+                if (result.IsLeft)
+                {
+                    return result.ToValidation();
+                }
+            }
+
+            return programSchedule;
+        }
+
         private static Validation<BaseError, ProgramSchedule> PlaybackOrdersMustBeValid(
             ReplaceProgramScheduleItems request,
             ProgramSchedule programSchedule)

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -40,8 +40,24 @@ namespace ErsatzTV.Application.ProgramSchedules
                         },
                         duration.PlaybackOrder,
                         duration.PlayoutDuration,
-                        duration.OfflineTail,
-                        duration.CustomTitle),
+                        duration.TailMode,
+                        duration.CustomTitle,
+                        duration.GuideMode,
+                        duration.PreRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(duration.PreRollFiller)
+                            : null,
+                        duration.MidRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(duration.MidRollFiller)
+                            : null,
+                        duration.PostRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(duration.PostRollFiller)
+                            : null,
+                        duration.TailFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(duration.TailFiller)
+                            : null,
+                        duration.FallbackFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(duration.FallbackFiller)
+                            : null),
                 ProgramScheduleItemFlood flood =>
                     new ProgramScheduleItemFloodViewModel(
                         flood.Id,
@@ -66,7 +82,23 @@ namespace ErsatzTV.Application.ProgramSchedules
                             _ => null
                         },
                         flood.PlaybackOrder,
-                        flood.CustomTitle),
+                        flood.CustomTitle,
+                        flood.GuideMode,
+                        flood.PreRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(flood.PreRollFiller)
+                            : null,
+                        flood.MidRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(flood.MidRollFiller)
+                            : null,
+                        flood.PostRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(flood.PostRollFiller)
+                            : null,
+                        flood.TailFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(flood.TailFiller)
+                            : null,
+                        flood.FallbackFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(flood.FallbackFiller)
+                            : null),
                 ProgramScheduleItemMultiple multiple =>
                     new ProgramScheduleItemMultipleViewModel(
                         multiple.Id,
@@ -92,7 +124,23 @@ namespace ErsatzTV.Application.ProgramSchedules
                         },
                         multiple.PlaybackOrder,
                         multiple.Count,
-                        multiple.CustomTitle),
+                        multiple.CustomTitle,
+                        multiple.GuideMode,
+                        multiple.PreRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(multiple.PreRollFiller)
+                            : null,
+                        multiple.MidRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(multiple.MidRollFiller)
+                            : null,
+                        multiple.PostRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(multiple.PostRollFiller)
+                            : null,
+                        multiple.TailFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(multiple.TailFiller)
+                            : null,
+                        multiple.FallbackFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(multiple.FallbackFiller)
+                            : null),
                 ProgramScheduleItemOne one =>
                     new ProgramScheduleItemOneViewModel(
                         one.Id,
@@ -117,7 +165,23 @@ namespace ErsatzTV.Application.ProgramSchedules
                             _ => null
                         },
                         one.PlaybackOrder,
-                        one.CustomTitle),
+                        one.CustomTitle,
+                        one.GuideMode,
+                        one.PreRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(one.PreRollFiller)
+                            : null,
+                        one.MidRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(one.MidRollFiller)
+                            : null,
+                        one.PostRollFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(one.PostRollFiller)
+                            : null,
+                        one.TailFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(one.TailFiller)
+                            : null,
+                        one.FallbackFiller != null
+                            ? Filler.Mapper.ProjectToViewModel(one.FallbackFiller)
+                            : null),
                 _ => throw new NotSupportedException(
                     $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
             };

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
@@ -19,8 +20,14 @@ namespace ErsatzTV.Application.ProgramSchedules
             NamedMediaItemViewModel mediaItem,
             PlaybackOrder playbackOrder,
             TimeSpan playoutDuration,
-            bool offlineTail,
-            string customTitle) : base(
+            TailMode tailMode,
+            string customTitle,
+            GuideMode guideMode,
+            FillerPresetViewModel preRollFiller,
+            FillerPresetViewModel midRollFiller,
+            FillerPresetViewModel postRollFiller,
+            FillerPresetViewModel tailFiller,
+            FillerPresetViewModel fallbackFiller) : base(
             id,
             index,
             startType,
@@ -32,13 +39,19 @@ namespace ErsatzTV.Application.ProgramSchedules
             smartCollection,
             mediaItem,
             playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode,
+            preRollFiller,
+            midRollFiller,
+            postRollFiller,
+            tailFiller,
+            fallbackFiller)
         {
             PlayoutDuration = playoutDuration;
-            OfflineTail = offlineTail;
+            TailMode = tailMode;
         }
 
         public TimeSpan PlayoutDuration { get; }
-        public bool OfflineTail { get; }
+        public TailMode TailMode { get; }
     }
 }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
@@ -18,7 +19,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
             PlaybackOrder playbackOrder,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode,
+            FillerPresetViewModel preRollFiller,
+            FillerPresetViewModel midRollFiller,
+            FillerPresetViewModel postRollFiller,
+            FillerPresetViewModel tailFiller,
+            FillerPresetViewModel fallbackFiller) : base(
             id,
             index,
             startType,
@@ -30,7 +37,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             smartCollection,
             mediaItem,
             playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode,
+            preRollFiller,
+            midRollFiller,
+            postRollFiller,
+            tailFiller,
+            fallbackFiller)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
@@ -19,7 +20,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             NamedMediaItemViewModel mediaItem,
             PlaybackOrder playbackOrder,
             int count,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode,
+            FillerPresetViewModel preRollFiller,
+            FillerPresetViewModel midRollFiller,
+            FillerPresetViewModel postRollFiller,
+            FillerPresetViewModel tailFiller,
+            FillerPresetViewModel fallbackFiller) : base(
             id,
             index,
             startType,
@@ -31,7 +38,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             smartCollection,
             mediaItem,
             playbackOrder,
-            customTitle) =>
+            customTitle,
+            guideMode,
+            preRollFiller,
+            midRollFiller,
+            postRollFiller,
+            tailFiller,
+            fallbackFiller) =>
             Count = count;
 
         public int Count { get; }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
@@ -18,7 +19,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
             PlaybackOrder playbackOrder,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode,
+            FillerPresetViewModel preRollFiller,
+            FillerPresetViewModel midRollFiller,
+            FillerPresetViewModel postRollFiller,
+            FillerPresetViewModel tailFiller,
+            FillerPresetViewModel fallbackFiller) : base(
             id,
             index,
             startType,
@@ -30,7 +37,13 @@ namespace ErsatzTV.Application.ProgramSchedules
             smartCollection,
             mediaItem,
             playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode,
+            preRollFiller,
+            midRollFiller,
+            postRollFiller,
+            tailFiller,
+            fallbackFiller)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
@@ -17,7 +18,13 @@ namespace ErsatzTV.Application.ProgramSchedules
         SmartCollectionViewModel SmartCollection,
         NamedMediaItemViewModel MediaItem,
         PlaybackOrder PlaybackOrder,
-        string CustomTitle)
+        string CustomTitle,
+        GuideMode GuideMode,
+        FillerPresetViewModel PreRollFiller,
+        FillerPresetViewModel MidRollFiller,
+        FillerPresetViewModel PostRollFiller,
+        FillerPresetViewModel TailFiller,
+        FillerPresetViewModel FallbackFiller)
     {
         public string Name => CollectionType switch
         {

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs

@@ -45,6 +45,11 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                 .Include(i => i.MediaItem)
                 .ThenInclude(i => (i as Artist).ArtistMetadata)
                 .ThenInclude(am => am.Artwork)
+                .Include(i => i.PreRollFiller)
+                .Include(i => i.MidRollFiller)
+                .Include(i => i.PostRollFiller)
+                .Include(i => i.TailFiller)
+                .Include(i => i.FallbackFiller)
                 .ToListAsync(cancellationToken)
                 .Map(programScheduleItems => programScheduleItems.Map(ProjectToViewModel).ToList());
         }

ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs

@@ -44,18 +44,18 @@ namespace ErsatzTV.Application.Search.Commands
                 await _configElementRepository.GetValue<int>(ConfigElementKey.SearchIndexVersion) <
                 _searchIndex.Version)
             {
-                _logger.LogDebug("Migrating search index to version {Version}", _searchIndex.Version);
+                _logger.LogInformation("Migrating search index to version {Version}", _searchIndex.Version);
 
                 List<int> itemIds = await _searchRepository.GetItemIdsToIndex();
                 await _searchIndex.Rebuild(_searchRepository, itemIds);
 
                 await _configElementRepository.Upsert(ConfigElementKey.SearchIndexVersion, _searchIndex.Version);
 
-                _logger.LogDebug("Done migrating search index");
+                _logger.LogInformation("Done migrating search index");
             }
             else
             {
-                _logger.LogDebug("Search index is already version {Version}", _searchIndex.Version);
+                _logger.LogInformation("Search index is already version {Version}", _searchIndex.Version);
             }
 
             return Unit.Default;

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Search;
 using LanguageExt;
 using MediatR;
 
@@ -19,12 +20,13 @@ namespace ErsatzTV.Application.Search.Queries
             QuerySearchIndexAllItems request,
             CancellationToken cancellationToken) =>
             new(
-                await GetIds("movie", request.Query),
-                await GetIds("show", request.Query),
-                await GetIds("season", request.Query),
-                await GetIds("episode", request.Query),
-                await GetIds("artist", request.Query),
-                await GetIds("music_video", request.Query));
+                await GetIds(SearchIndex.MovieType, request.Query),
+                await GetIds(SearchIndex.ShowType, request.Query),
+                await GetIds(SearchIndex.SeasonType, request.Query),
+                await GetIds(SearchIndex.EpisodeType, request.Query),
+                await GetIds(SearchIndex.ArtistType, request.Query),
+                await GetIds(SearchIndex.MusicVideoType, request.Query),
+                await GetIds(SearchIndex.OtherVideoType, request.Query));
 
         private Task<List<int>> GetIds(string type, string query) =>
             _searchIndex.Search($"type:{type} AND ({query})", 0, 0)

ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.MediaCards;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexOtherVideos
+        (string Query, int PageNumber, int PageSize) : IRequest<OtherVideoCardResultsViewModel>;
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexOtherVideosHandler : IRequestHandler<QuerySearchIndexOtherVideos,
+            OtherVideoCardResultsViewModel>
+    {
+        private readonly IOtherVideoRepository _otherVideoRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
+        {
+            _searchIndex = searchIndex;
+            _otherVideoRepository = otherVideoRepository;
+        }
+
+        public async Task<OtherVideoCardResultsViewModel> Handle(
+            QuerySearchIndexOtherVideos request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<OtherVideoCardViewModel> items = await _otherVideoRepository
+                .GetOtherVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new OtherVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}

ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs

@@ -8,5 +8,6 @@ namespace ErsatzTV.Application.Search
         List<int> SeasonIds,
         List<int> EpisodeIds,
         List<int> ArtistIds,
-        List<int> MusicVideoIds);
+        List<int> MusicVideoIds,
+        List<int> OtherVideoIds);
 }

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -161,7 +161,7 @@ namespace ErsatzTV.Application.Streaming
 
                     Process process = processModel.Process;
 
-                    _logger.LogDebug(
+                    _logger.LogInformation(
                         "ffmpeg hls arguments {FFmpegArguments}",
                         string.Join(" ", process.StartInfo.ArgumentList));
 

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -75,6 +75,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
                 .ThenInclude(mv => mv.Streams)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .ThenInclude(ov => ov.MediaFiles)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .ThenInclude(ov => ov.Streams)
                 .ForChannelAndTime(channel.Id, now)
                 .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
                 .BindT(ValidatePlayoutItemPath);
@@ -87,6 +93,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         Movie m => m.MediaVersions.Head(),
                         Episode e => e.MediaVersions.Head(),
                         MusicVideo mv => mv.MediaVersions.Head(),
+                        OtherVideo ov => ov.MediaVersions.Head(),
                         _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                     };
 
@@ -107,12 +114,15 @@ namespace ErsatzTV.Application.Streaming.Queries
                         version,
                         playoutItemWithPath.Path,
                         playoutItemWithPath.PlayoutItem.StartOffset,
+                        playoutItemWithPath.PlayoutItem.FinishOffset,
                         request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
                         maybeGlobalWatermark,
                         channel.FFmpegProfile.VaapiDriver,
                         channel.FFmpegProfile.VaapiDevice,
-                        request.StartAtZero,
-                        request.HlsRealtime);
+                        request.HlsRealtime,
+                        playoutItemWithPath.PlayoutItem.FillerKind,
+                        playoutItemWithPath.PlayoutItem.InPoint,
+                        playoutItemWithPath.PlayoutItem.OutPoint);
 
                     var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
 
@@ -146,7 +156,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
-                                    "Channel is Offline");
+                                    "Channel is Offline",
+                                    request.HlsRealtime);
 
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
@@ -165,7 +176,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
-                                    error.Value);
+                                    error.Value,
+                                    request.HlsRealtime);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -183,7 +195,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
-                                    "Channel is Offline");
+                                    "Channel is Offline",
+                                    request.HlsRealtime);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -217,6 +230,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
                 MusicVideo mv => mv.MediaVersions.Head(),
+                OtherVideo ov => ov.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
             };
 

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -29,7 +29,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ThreadCount.Should().Be(7);
             }
@@ -46,7 +48,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ThreadCount.Should().Be(7);
             }
@@ -63,7 +67,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
                 actual.FormatFlags.Count.Should().Be(expected.Length);
@@ -82,7 +88,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
                 actual.FormatFlags.Count.Should().Be(expected.Length);
@@ -101,7 +109,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.RealtimeOutput.Should().BeTrue();
             }
@@ -118,7 +128,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.RealtimeOutput.Should().BeTrue();
             }
@@ -137,7 +149,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     now,
-                    now.AddMinutes(5));
+                    now.AddMinutes(5),
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.StreamSeek.IsSome.Should().BeTrue();
                 actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
@@ -157,7 +171,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     now,
-                    now.AddMinutes(5));
+                    now.AddMinutes(5),
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.StreamSeek.IsSome.Should().BeTrue();
                 actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
@@ -175,7 +191,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -199,7 +217,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -223,7 +243,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -247,7 +269,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -273,7 +297,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -298,7 +324,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 IDisplaySize scaledSize = actual.ScaledSize.IfNone(new MediaVersion { Width = 0, Height = 0 });
                 scaledSize.Width.Should().Be(1280);
@@ -326,7 +354,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -352,7 +382,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -379,7 +411,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -409,7 +443,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -439,7 +475,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -468,7 +506,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "libx264" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -498,7 +538,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -530,7 +572,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -560,7 +604,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -589,7 +635,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -617,7 +665,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -647,7 +697,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream { Codec = "mpeg2video" },
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -673,7 +725,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "aac" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("aac");
             }
@@ -696,7 +750,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("copy");
             }
@@ -720,7 +776,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("aac");
             }
@@ -744,7 +802,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("copy");
             }
@@ -769,7 +829,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioBitrate.IfNone(0).Should().Be(2424);
             }
@@ -794,7 +856,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioBufferSize.IfNone(0).Should().Be(2424);
             }
@@ -819,7 +883,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioChannels.IfNone(0).Should().Be(6);
             }
@@ -844,7 +910,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
@@ -868,7 +936,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioChannels.IfNone(0).Should().Be(6);
             }
@@ -892,7 +962,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
@@ -908,7 +980,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioCodec = "ac3"
                 };
 
-                var version = new MediaVersion { Duration = TimeSpan.FromMinutes(2) };
+                var version = new MediaVersion { Duration = TimeSpan.FromMinutes(5) }; // not pulled from here
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
@@ -917,7 +989,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.FromMinutes(2));
 
                 actual.AudioDuration.IfNone(TimeSpan.MinValue).Should().Be(TimeSpan.FromMinutes(2));
             }
@@ -941,7 +1015,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.NormalizeLoudness.Should().BeTrue();
             }
@@ -965,7 +1041,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.NormalizeLoudness.Should().BeFalse();
             }
@@ -991,7 +1069,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     new MediaStream(),
                     new MediaStream(),
                     DateTimeOffset.Now,
-                    DateTimeOffset.Now);
+                    DateTimeOffset.Now,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
 
                 actual.HardwareAcceleration.Should().Be(HardwareAccelerationKind.Qsv);
             }

ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs

@@ -5,6 +5,7 @@ using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
@@ -184,12 +185,15 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 v,
                 file,
                 now,
+                now + TimeSpan.FromSeconds(5),
                 now,
                 None,
                 VaapiDriver.Default,
                 "/dev/dri/renderD128",
                 false,
-                false);
+                FillerKind.None,
+                TimeSpan.Zero,
+                TimeSpan.FromSeconds(5));
 
             process.StartInfo.RedirectStandardError = true;
 

ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs

@@ -26,7 +26,8 @@ namespace ErsatzTV.Core.Tests.Metadata
 
             var input = new LocalStatisticsProvider.FFprobe(
                 new LocalStatisticsProvider.FFprobeFormat("123.45"),
-                new List<LocalStatisticsProvider.FFprobeStream>());
+                new List<LocalStatisticsProvider.FFprobeStream>(),
+                new List<LocalStatisticsProvider.FFprobeChapter>());
 
             MediaVersion result = provider.ProjectToMediaVersion("test", input);
 

ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Core.Tests.Fakes;
@@ -709,7 +710,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = fixedCollection.Id,
                     StartTime = TimeSpan.FromHours(2),
                     PlayoutDuration = TimeSpan.FromHours(2),
-                    OfflineTail = false, // immediately continue
+                    TailMode = TailMode.None, // immediately continue
                     PlaybackOrder = PlaybackOrder.Chronological
                 }
             };
@@ -807,7 +808,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = dynamicCollection.Id,
                     StartTime = null,
                     PlayoutDuration = TimeSpan.FromHours(2),
-                    OfflineTail = false, // immediately continue
+                    TailMode = TailMode.None, // immediately continue
                     PlaybackOrder = PlaybackOrder.Chronological
                 }
             };
@@ -1089,7 +1090,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionOne.Id,
                     StartTime = null,
                     PlayoutDuration = TimeSpan.FromHours(3),
-                    OfflineTail = false,
+                    TailMode = TailMode.None,
                     PlaybackOrder = PlaybackOrder.Chronological
                 },
                 new ProgramScheduleItemDuration
@@ -1100,7 +1101,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionTwo.Id,
                     StartTime = null,
                     PlayoutDuration = TimeSpan.FromHours(3),
-                    OfflineTail = false,
+                    TailMode = TailMode.None,
                     PlaybackOrder = PlaybackOrder.Chronological
                 }
             };
@@ -1151,6 +1152,218 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Anchor.NextScheduleItem.Should().Be(items[1]);
             result.Anchor.DurationFinish.Should().Be(HoursAfterMidnight(6).UtcDateTime);
         }
+        
+        [Test]
+        public async Task Alternating_Duration_With_Filler_Should_Alternate_Schedule_Items()
+        {
+            var collectionOne = new Collection
+            {
+                Id = 1,
+                Name = "Duration Items 1",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(1, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
+                }
+            };
+            
+            var collectionTwo = new Collection
+            {
+                Id = 2,
+                Name = "Duration Items 2",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(2, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
+                }
+            };
+            
+            var collectionThree = new Collection
+            {
+                Id = 3,
+                Name = "Filler Items",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(3, TimeSpan.FromMinutes(5), new DateTime(2020, 1, 1))
+                }
+            };
+            
+            var fakeRepository = new FakeMediaCollectionRepository(
+                Map(
+                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                    (collectionTwo.Id, collectionTwo.MediaItems.ToList()),
+                    (collectionThree.Id, collectionThree.MediaItems.ToList())));
+            
+            var items = new List<ProgramScheduleItem>
+            {
+                new ProgramScheduleItemDuration
+                {
+                    Id = 1,
+                    Index = 1,
+                    Collection = collectionOne,
+                    CollectionId = collectionOne.Id,
+                    StartTime = null,
+                    PlayoutDuration = TimeSpan.FromHours(3),
+                    PlaybackOrder = PlaybackOrder.Chronological,
+                    TailMode = TailMode.Filler,
+                    TailFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.Tail,
+                        Collection = collectionThree,
+                        CollectionId = collectionThree.Id
+                    }
+                },
+                new ProgramScheduleItemDuration
+                {
+                    Id = 2,
+                    Index = 2,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id,
+                    StartTime = null,
+                    PlayoutDuration = TimeSpan.FromHours(3),
+                    PlaybackOrder = PlaybackOrder.Chronological,
+                    TailMode = TailMode.Filler,
+                    TailFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.Tail,
+                        Collection = collectionThree,
+                        CollectionId = collectionThree.Id
+                    }
+                }
+            };
+            
+            var playout = new Playout
+            {
+                ProgramSchedule = new ProgramSchedule
+                {
+                    Items = items
+                },
+                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+            };
+            
+            var configRepo = new Mock<IConfigElementRepository>();
+            var televisionRepo = new FakeTelevisionRepository();
+            var artistRepo = new Mock<IArtistRepository>();
+            var builder = new PlayoutBuilder(
+                configRepo.Object,
+                fakeRepository,
+                televisionRepo,
+                artistRepo.Object,
+                _logger);
+            
+            DateTimeOffset start = HoursAfterMidnight(0);
+            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+            
+            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+            
+            result.Items.Count.Should().Be(12);
+            
+            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(0));
+            result.Items[0].MediaItemId.Should().Be(1);
+            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(55));
+            result.Items[1].MediaItemId.Should().Be(1);
+            result.Items[2].StartOffset.TimeOfDay.Should().Be(new TimeSpan(1, 50, 0));
+            result.Items[2].MediaItemId.Should().Be(1);
+            
+            result.Items[3].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 45, 0));
+            result.Items[3].MediaItemId.Should().Be(3);
+            result.Items[4].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 50, 0));
+            result.Items[4].MediaItemId.Should().Be(3);
+            result.Items[5].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 55, 0));
+            result.Items[5].MediaItemId.Should().Be(3);
+            
+            result.Items[6].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+            result.Items[6].MediaItemId.Should().Be(2);
+            result.Items[7].StartOffset.TimeOfDay.Should().Be(new TimeSpan(3, 55, 0));
+            result.Items[7].MediaItemId.Should().Be(2);
+            result.Items[8].StartOffset.TimeOfDay.Should().Be(new TimeSpan(4, 50, 0));
+            result.Items[8].MediaItemId.Should().Be(2);
+            
+            result.Items[9].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 45, 0));
+            result.Items[9].MediaItemId.Should().Be(3);
+            result.Items[10].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 50, 0));
+            result.Items[10].MediaItemId.Should().Be(3);
+            result.Items[11].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 55, 0));
+            result.Items[11].MediaItemId.Should().Be(3);
+            
+            result.Anchor.NextScheduleItem.Should().Be(items[0]);
+            result.Anchor.DurationFinish.Should().BeNull();
+        }
+        
+        [Test]
+        public async Task Duration_Should_Skip_Items_That_Are_Too_Long()
+        {
+            var collectionOne = new Collection
+            {
+                Id = 1,
+                Name = "Duration Items 1",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(1, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+                }
+            };
+
+            var fakeRepository =
+                new FakeMediaCollectionRepository(Map((collectionOne.Id, collectionOne.MediaItems.ToList())));
+
+            var items = new List<ProgramScheduleItem>
+            {
+                new ProgramScheduleItemDuration
+                {
+                    Id = 1,
+                    Index = 1,
+                    Collection = collectionOne,
+                    CollectionId = collectionOne.Id,
+                    StartTime = null,
+                    PlayoutDuration = TimeSpan.FromHours(1),
+                    PlaybackOrder = PlaybackOrder.Chronological,
+                    TailMode = TailMode.None,
+                }
+            };
+
+            var playout = new Playout
+            {
+                ProgramSchedule = new ProgramSchedule
+                {
+                    Items = items
+                },
+                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+            };
+
+            var configRepo = new Mock<IConfigElementRepository>();
+            var televisionRepo = new FakeTelevisionRepository();
+            var artistRepo = new Mock<IArtistRepository>();
+            var builder = new PlayoutBuilder(
+                configRepo.Object,
+                fakeRepository,
+                televisionRepo,
+                artistRepo.Object,
+                _logger);
+
+            DateTimeOffset start = HoursAfterMidnight(0);
+            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+            result.Items.Count.Should().Be(6);
+
+            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(0));
+            result.Items[0].MediaItemId.Should().Be(2);
+            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+            result.Items[1].MediaItemId.Should().Be(4);
+            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+            result.Items[2].MediaItemId.Should().Be(2);
+            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+            result.Items[3].MediaItemId.Should().Be(4);
+            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+            result.Items[4].MediaItemId.Should().Be(2);
+            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
+            result.Items[5].MediaItemId.Should().Be(4);
+
+            result.Anchor.NextScheduleItem.Should().Be(items[0]);
+            result.Anchor.DurationFinish.Should().BeNull();
+        }
 
         private static DateTimeOffset HoursAfterMidnight(int hours)
         {

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Scheduling;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class PlayoutModeSchedulerBaseTests
+    {
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Not_Touch_Enumerator()
+        {
+            var collection = new Collection
+            {
+                Id = 1,
+                Name = "Filler Items",
+                MediaItems = new List<MediaItem>()
+            };
+
+            for (var i = 0; i < 5; i++)
+            {
+                collection.MediaItems.Add(TestMovie(i + 1, TimeSpan.FromHours(i + 1), new DateTime(2020, 2, i + 1)));
+            }
+
+            var fillerPreset = new FillerPreset
+            {
+                FillerKind = FillerKind.PreRoll,
+                FillerMode = FillerMode.Count,
+                Count = 3,
+                Collection = collection,
+                CollectionId = collection.Id
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collection.MediaItems,
+                new CollectionEnumeratorState { Index = 0, Seed = 1 });
+
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>
+                    {
+                        { CollectionKey.ForFillerPreset(fillerPreset), enumerator }
+                    },
+                    new ProgramScheduleItemOne
+                    {
+                        PreRollFiller = fillerPreset
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 18, 12, 30, TimeSpan.FromHours(-5)));
+            enumerator.State.Index.Should().Be(0);
+            enumerator.State.Seed.Should().Be(1);
+        }
+
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_15()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 15
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 15, 0, TimeSpan.FromHours(-5)));
+        }
+        
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_30()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 15
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 16, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
+        }
+        
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_45()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 15
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 45, 0, TimeSpan.FromHours(-5)));
+        }
+        
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_00()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 15
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 46, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
+        }
+        
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_30()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 30
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
+        }
+        
+        [Test]
+        public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_00()
+        {
+            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+                .CalculateEndTimeWithFiller(
+                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                    new ProgramScheduleItemOne
+                    {
+                        MidRollFiller = new FillerPreset
+                        {
+                            FillerKind = FillerKind.MidRoll,
+                            FillerMode = FillerMode.Pad,
+                            PadToNearestMinute = 30
+                        }
+                    },
+                    new DateTimeOffset(2020, 2, 1, 12, 20, 0, TimeSpan.FromHours(-5)),
+                    new TimeSpan(0, 12, 30),
+                    new List<MediaChapter>());
+
+            result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
+        }
+
+        private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
+            new()
+            {
+                Id = id,
+                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
+                MediaVersions = new List<MediaVersion>
+                {
+                    new() { Duration = duration }
+                }
+            };
+    }
+}

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs

@@ -0,0 +1,552 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class PlayoutModeSchedulerDurationTests : SchedulerTestBase
+    {
+        [Test]
+        public void Should_Fill_Exact_Duration()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.None,
+                PlaybackOrder = PlaybackOrder.Chronological
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+        
+        [Test]
+        public void Should_Not_Have_Gap_Duration_Tail_Mode_None()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.None,
+                PlaybackOrder = PlaybackOrder.Chronological
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+        
+        [Test]
+        public void Should_Have_Gap_Duration_Tail_Mode_Offline_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.Offline,
+                PlaybackOrder = PlaybackOrder.Chronological
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            // duration block should end after exact duration, with gap
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+        
+        [Test]
+        public void Should_Not_Have_Gap_Duration_Tail_Mode_Offline_With_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.Offline,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+            
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_Exact_Duration()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.Filler,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+        
+        [Test]
+        public void Should_Have_Gap_Duration_Tail_Mode_Filler_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.Filler,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_With_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.Filler,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+            enumerator3.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(7);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+            
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[6].MediaItemId.Should().Be(5);
+            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].GuideGroup.Should().Be(1);
+            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+    }
+}

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs

@@ -0,0 +1,715 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class PlayoutModeSchedulerFloodTests : SchedulerTestBase
+    {
+        [Test]
+        public void Should_Fill_Exactly_To_Next_Schedule_Item()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+        
+        [Test]
+        public void Should_Fill_Exactly_To_Next_Schedule_Item_With_Post_Roll_Multiple_One()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                PostRollFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.PostRoll,
+                    FillerMode = FillerMode.Count,
+                    Count = 1,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                TailFiller = null,
+                FallbackFiller = null
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+            playoutItems[2].MediaItemId.Should().Be(2);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[2].GuideGroup.Should().Be(2);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(4);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 55, 0)));
+            playoutItems[3].GuideGroup.Should().Be(2);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+
+            playoutItems[4].MediaItemId.Should().Be(1);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[4].GuideGroup.Should().Be(3);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].GuideGroup.Should().Be(3);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.PostRoll);
+        }
+
+        [Test]
+        public void Should_Have_Gap_With_No_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Exact_Tail()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(3);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].GuideGroup.Should().Be(3);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].GuideGroup.Should().Be(3);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(3);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+        
+        [Test]
+        public void Should_Have_Gap_With_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(3);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(3);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(3);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+            enumerator3.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(7);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(3);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(3);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(3);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[6].MediaItemId.Should().Be(5);
+            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].GuideGroup.Should().Be(3);
+            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                NextScheduleItem
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(0);
+            enumerator3.State.Index.Should().Be(0);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+        {
+            StartTime = TimeSpan.FromHours(3)
+        };
+    }
+}

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs

@@ -0,0 +1,630 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class PlayoutModeSchedulerMultipleTests : SchedulerTestBase
+    {
+        [Test]
+        public void Should_Fill_Exactly_To_Next_Schedule_Item()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                CollectionType = ProgramScheduleItemCollectionType.Collection,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null,
+                Count = 3
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
+            }.ToMap();
+    
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        [Test]
+        public void Should_Have_Gap_With_No_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null,
+                Count = 3
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Exact_Tail()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null,
+                Count = 3
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                Count = 3
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionTwo.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+        
+        [Test]
+        public void Should_Have_Gap_With_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null,
+                Count = 3
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(6);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+            
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                },
+                Count = 3
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+            enumerator3.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(7);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+            
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(4);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        
+            playoutItems[5].MediaItemId.Should().Be(3);
+            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].GuideGroup.Should().Be(1);
+            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[6].MediaItemId.Should().Be(5);
+            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].GuideGroup.Should().Be(1);
+            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                },
+                Count = 3
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
+                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
+            }.ToMap();
+
+            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(0);
+            enumerator3.State.Index.Should().Be(0);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+        {
+            StartTime = TimeSpan.FromHours(3)
+        };
+    }
+}

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs

@@ -0,0 +1,635 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class PlayoutModeSchedulerOneTests : SchedulerTestBase
+    {
+        [Test]
+        public void Should_Have_Gap_With_No_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(1);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Exact_Tail()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[2].MediaItemId.Should().Be(4);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(2);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+        
+        [Test]
+        public void Should_Have_Gap_With_Tail_No_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = null
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[2].MediaItemId.Should().Be(4);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+            enumerator3.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(5);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[2].MediaItemId.Should().Be(4);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+            playoutItems[4].MediaItemId.Should().Be(5);
+            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[4].GuideGroup.Should().Be(1);
+            playoutItems[4].FillerKind.Should().Be(FillerKind.Fallback);
+        }
+
+        [Test]
+        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(3));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(
+                    scheduleItem,
+                    enumerator1,
+                    scheduleItem.TailFiller,
+                    enumerator2,
+                    scheduleItem.FallbackFiller,
+                    enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(0);
+            enumerator3.State.Index.Should().Be(0);
+
+            playoutItems.Count.Should().Be(1);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        }
+
+        [Test]
+        public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                PostRollFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.PostRoll,
+                    FillerMode = FillerMode.Pad,
+                    PadToNearestMinute = 30,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+            playoutItems[2].MediaItemId.Should().Be(4);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
+        
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+        }
+
+        [Test]
+        public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad_With_Chapters()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0), 2);
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                PostRollFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.PostRoll,
+                    FillerMode = FillerMode.Pad,
+                    PadToNearestMinute = 30,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id
+                },
+                FallbackFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Fallback,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            };
+
+            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+                collectionThree.MediaItems,
+                new CollectionEnumeratorState());
+
+            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator1.State.Index.Should().Be(1);
+            enumerator2.State.Index.Should().Be(1);
+            enumerator3.State.Index.Should().Be(0);
+
+            playoutItems.Count.Should().Be(4);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+            playoutItems[2].MediaItemId.Should().Be(4);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
+        
+            playoutItems[3].MediaItemId.Should().Be(3);
+            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].GuideGroup.Should().Be(1);
+            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+        }
+
+        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+        {
+            StartTime = TimeSpan.FromHours(3)
+        };
+    }
+}

ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Scheduling;
+using ErsatzTV.Core.Scheduling;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    public abstract class SchedulerTestBase
+    {
+        protected static PlayoutBuilderState StartState => new(
+            0,
+            Prelude.None,
+            Prelude.None,
+            false,
+            false,
+            1,
+            new DateTimeOffset(new DateTime(2020, 10, 18, 0, 0, 0, DateTimeKind.Local)));
+
+        protected virtual ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+        {
+            StartTime = null
+        };
+
+        protected static DateTimeOffset HardStop => StartState.CurrentTime.AddHours(6);
+
+        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator) =>
+            new()
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), enumerator }
+            };
+
+        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
+            FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2,
+            FillerPreset fillerPreset2, IMediaCollectionEnumerator enumerator3) =>
+            new()
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
+                { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 },
+                { CollectionKey.ForFillerPreset(fillerPreset2), enumerator3 }
+            };
+
+        private static Movie TestMovie(int id, TimeSpan duration, DateTime aired, int chapterCount = 0)
+        {
+            var result = new Movie()
+            {
+                Id = id,
+                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
+                MediaVersions = new List<MediaVersion>
+                {
+                    new() { Duration = duration, Chapters = new List<MediaChapter>() }
+                }
+            };
+
+            for (var i = 0; i < chapterCount; i++)
+            {
+                result.MediaVersions.Head().Chapters.Add(
+                    new MediaChapter
+                    {
+                        StartTime = TimeSpan.FromMilliseconds(i * duration.TotalMilliseconds / chapterCount),
+                        EndTime = TimeSpan.FromMilliseconds(i + 1 * duration.TotalMilliseconds / chapterCount)
+                    });
+            }
+
+            return result;
+        }
+
+        protected static Collection TwoItemCollection(int id1, int id2, TimeSpan duration, int chapterCount = 0) => new()
+        {
+            Id = id1,
+            Name = $"Collection of Items {id1}",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(id1, duration, new DateTime(2020, 1, 1), chapterCount),
+                TestMovie(id2, duration, new DateTime(2020, 1, 2), chapterCount)
+            }
+        };
+
+        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
+            FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2) =>
+            new()
+            {
+                { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
+                { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 }
+            };
+    }
+}

ErsatzTV.Core/Domain/ConfigElementKey.cs

@@ -25,8 +25,10 @@
         public static ConfigElementKey SchedulesDetailPageSize => new("pages.schedules.detail_page_size");
         public static ConfigElementKey PlayoutsPageSize => new("pages.playouts.page_size");
         public static ConfigElementKey PlayoutsDetailPageSize => new("pages.playouts.detail_page_size");
+        public static ConfigElementKey PlayoutsDetailShowFiller => new("pages.playouts.detail_show_filler");
         public static ConfigElementKey LogsPageSize => new("pages.logs.page_size");
         public static ConfigElementKey TraktListsPageSize => new("pages.trakt.lists_page_size");
+        public static ConfigElementKey FillerPresetsPageSize => new("pages.filler_presets.page_size");
         public static ConfigElementKey LibraryRefreshInterval => new("scanner.library_refresh_interval");
         public static ConfigElementKey PlayoutDaysToBuild => new("playout.days_to_build");
     }

ErsatzTV.Core/Domain/Filler/FillerKind.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Core.Domain.Filler
+{
+    public enum FillerKind
+    {
+        None = 0,
+        PreRoll = 1,
+        MidRoll = 2,
+        PostRoll = 3,
+        Tail = 4,
+        Fallback = 5
+    }
+}

ErsatzTV.Core/Domain/Filler/FillerMode.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Domain.Filler
+{
+    public enum FillerMode
+    {
+        None = 0,
+        Duration = 1,
+        Count = 2,
+        Pad = 3
+    }
+}

ErsatzTV.Core/Domain/Filler/FillerPreset.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace ErsatzTV.Core.Domain.Filler
+{
+    public class FillerPreset
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public FillerKind FillerKind { get; set; }
+        public FillerMode FillerMode { get; set; }
+        public TimeSpan? Duration { get; set; }
+        public int? Count { get; set; }
+        public int? PadToNearestMinute { get; set; }
+        public ProgramScheduleItemCollectionType CollectionType { get; set; }
+        public int? CollectionId { get; set; }
+        public Collection Collection { get; set; }
+        public int? MediaItemId { get; set; }
+        public MediaItem MediaItem { get; set; }
+        public int? MultiCollectionId { get; set; }
+        public MultiCollection MultiCollection { get; set; }
+        public int? SmartCollectionId { get; set; }
+        public SmartCollection SmartCollection { get; set; }
+    }
+}

ErsatzTV.Core/Domain/GuideMode.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public enum GuideMode
+    {
+        Normal = 0,
+        Filler = 1
+    }
+}

ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs

@@ -4,6 +4,7 @@
     {
         Movies = 1,
         Shows = 2,
-        MusicVideos = 3
+        MusicVideos = 3,
+        OtherVideos = 4
     }
 }

ErsatzTV.Core/Domain/MediaItem/MediaChapter.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class MediaChapter
+    {
+        public int Id { get; set; }
+        public int MediaVersionId { get; set; }
+        public MediaVersion MediaVersion { get; set; }
+        public long ChapterId { get; set; }
+        public TimeSpan StartTime { get; set; }
+        public TimeSpan EndTime { get; set; }
+        public string Title { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs

@@ -10,6 +10,7 @@ namespace ErsatzTV.Core.Domain
         public string Name { get; set; }
         public List<MediaFile> MediaFiles { get; set; }
         public List<MediaStream> Streams { get; set; }
+        public List<MediaChapter> Chapters { get; set; }
         public TimeSpan Duration { get; set; }
         public string SampleAspectRatio { get; set; }
         public string DisplayAspectRatio { get; set; }

ErsatzTV.Core/Domain/MediaItem/OtherVideo.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class OtherVideo : MediaItem
+    {
+        public List<OtherVideoMetadata> OtherVideoMetadata { get; set; }
+        public List<MediaVersion> MediaVersions { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Metadata/OtherVideoMetadata.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class OtherVideoMetadata : Metadata
+    {
+        public int OtherVideoId { get; set; }
+        public OtherVideo OtherVideo { get; set; }
+    }
+}

ErsatzTV.Core/Domain/PlayoutAnchor.cs

@@ -14,6 +14,8 @@ namespace ErsatzTV.Core.Domain
         public int? MultipleRemaining { get; set; }
         public DateTime? DurationFinish { get; set; }
         public bool InFlood { get; set; }
+        public bool InDurationFiller { get; set; }
+        public int NextGuideGroup { get; set; }
 
         public DateTimeOffset NextStartOffset => new DateTimeOffset(NextStart, TimeSpan.Zero).ToLocalTime();
 

ErsatzTV.Core/Domain/PlayoutItem.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Diagnostics;
+using ErsatzTV.Core.Domain.Filler;
 
 namespace ErsatzTV.Core.Domain
 {
+    [DebuggerDisplay("{MediaItemId} - {Start} - {Finish}")]
     public class PlayoutItem
     {
         public int Id { get; set; }
@@ -9,12 +12,38 @@ namespace ErsatzTV.Core.Domain
         public MediaItem MediaItem { get; set; }
         public DateTime Start { get; set; }
         public DateTime Finish { get; set; }
+        public DateTime? GuideFinish { get; set; }
         public string CustomTitle { get; set; }
-        public bool CustomGroup { get; set; }
+        public int GuideGroup { get; set; }
+        public FillerKind FillerKind { get; set; }
         public int PlayoutId { get; set; }
         public Playout Playout { get; set; }
+        public TimeSpan InPoint { get; set; }
+        public TimeSpan OutPoint { get; set; }
+        public string ChapterTitle { get; set; }
 
         public DateTimeOffset StartOffset => new DateTimeOffset(Start, TimeSpan.Zero).ToLocalTime();
         public DateTimeOffset FinishOffset => new DateTimeOffset(Finish, TimeSpan.Zero).ToLocalTime();
+        public DateTimeOffset? GuideFinishOffset => GuideFinish.HasValue
+            ? new DateTimeOffset(GuideFinish.Value, TimeSpan.Zero).ToLocalTime()
+            : null;
+
+        public PlayoutItem ForChapter(MediaChapter chapter) =>
+            new()
+            {
+                MediaItemId = MediaItemId,
+                MediaItem = MediaItem,
+                Start = Start,
+                Finish = Start + chapter.EndTime - chapter.StartTime,
+                GuideFinish = GuideFinish,
+                CustomTitle = CustomTitle,
+                GuideGroup = GuideGroup,
+                FillerKind = FillerKind,
+                PlayoutId = PlayoutId,
+                Playout = Playout,
+                InPoint = chapter.StartTime,
+                OutPoint = chapter.EndTime,
+                ChapterTitle = chapter.Title
+            };
     }
 }

ErsatzTV.Core/Domain/ProgramScheduleItem.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Core.Domain.Filler;
 
 namespace ErsatzTV.Core.Domain
 {
@@ -9,6 +10,7 @@ namespace ErsatzTV.Core.Domain
         public StartType StartType => StartTime.HasValue ? StartType.Fixed : StartType.Dynamic;
         public TimeSpan? StartTime { get; set; }
         public ProgramScheduleItemCollectionType CollectionType { get; set; }
+        public GuideMode GuideMode { get; set; }
         public string CustomTitle { get; set; }
         public int ProgramScheduleId { get; set; }
         public ProgramSchedule ProgramSchedule { get; set; }
@@ -21,5 +23,15 @@ namespace ErsatzTV.Core.Domain
         public int? SmartCollectionId { get; set; }
         public SmartCollection SmartCollection { get; set; }
         public PlaybackOrder PlaybackOrder { get; set; }
+        public int? PreRollFillerId { get; set; }
+        public FillerPreset PreRollFiller { get; set; }
+        public int? MidRollFillerId { get; set; }
+        public FillerPreset MidRollFiller { get; set; }
+        public int? PostRollFillerId { get; set; }
+        public FillerPreset PostRollFiller { get; set; }
+        public int? TailFillerId { get; set; }
+        public FillerPreset TailFiller { get; set; }
+        public int? FallbackFillerId { get; set; }
+        public FillerPreset FallbackFiller { get; set; }
     }
 }

ErsatzTV.Core/Domain/ProgramScheduleItemDuration.cs

@@ -5,6 +5,6 @@ namespace ErsatzTV.Core.Domain
     public class ProgramScheduleItemDuration : ProgramScheduleItem
     {
         public TimeSpan PlayoutDuration { get; set; }
-        public bool OfflineTail { get; set; }
+        public TailMode TailMode { get; set; }
     }
 }

ErsatzTV.Core/Domain/TailMode.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Domain
+{
+    public enum TailMode
+    {
+        None = 0,
+        Offline = 1,
+        Slate = 2,
+        Filler = 3
+    }
+}

ErsatzTV.Core/Emby/EmbyPathReplacementService.cs

@@ -68,7 +68,7 @@ namespace ErsatzTV.Core.Emby
 
                     if (log)
                     {
-                        _logger.LogDebug(
+                        _logger.LogInformation(
                             "Replacing emby path {EmbyPath} with {LocalPath} resulting in {FinalPath}",
                             replacement.EmbyPath,
                             replacement.LocalPath,

ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs

@@ -230,7 +230,13 @@ namespace ErsatzTV.Core.Emby
                         foreach (EmbySeason updated in await _televisionRepository.Update(incoming))
                         {
                             incoming.Show = show;
-                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { updated });
+                            
+                            foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
+                            {
+                                await _searchIndex.UpdateItems(
+                                    _searchRepository,
+                                    new List<MediaItem> { toIndex });
+                            }
                         }
                     },
                     async () =>

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs

@@ -49,7 +49,9 @@ namespace ErsatzTV.Core.FFmpeg
             MediaStream videoStream,
             Option<MediaStream> audioStream,
             DateTimeOffset start,
-            DateTimeOffset now)
+            DateTimeOffset now,
+            TimeSpan inPoint,
+            TimeSpan outPoint)
         {
             var result = new FFmpegPlaybackSettings
             {
@@ -57,9 +59,9 @@ namespace ErsatzTV.Core.FFmpeg
                 FormatFlags = CommonFormatFlags
             };
 
-            if (now != start)
+            if (now != start || inPoint != TimeSpan.Zero)
             {
-                result.StreamSeek = now - start;
+                result.StreamSeek = now - start + inPoint;
             }
 
             switch (streamingMode)
@@ -140,7 +142,7 @@ namespace ErsatzTV.Core.FFmpeg
                             });
 
                         result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
-                        result.AudioDuration = version.Duration;
+                        result.AudioDuration = outPoint - inPoint;
                         result.NormalizeLoudness = ffmpegProfile.NormalizeLoudness;
                     }
                     else
@@ -159,14 +161,24 @@ namespace ErsatzTV.Core.FFmpeg
             return result;
         }
 
-        public FFmpegPlaybackSettings CalculateErrorSettings(FFmpegProfile ffmpegProfile) =>
-            new()
+        public FFmpegPlaybackSettings CalculateErrorSettings(FFmpegProfile ffmpegProfile)
+        {
+            string softwareCodec = ffmpegProfile.VideoCodec switch
+            {
+                { } c when c.Contains("hevc") || c.Contains("265") => "libx265",
+                { } c when c.Contains("264") => "libx264",
+                { } c when c.Contains("mpeg2") => "mpeg2video",
+                _ => "libx264"
+            };
+            
+            return new FFmpegPlaybackSettings
             {
                 ThreadCount = ffmpegProfile.ThreadCount,
                 FormatFlags = CommonFormatFlags,
-                VideoCodec = "libx264",
+                VideoCodec = softwareCodec,
                 AudioCodec = ffmpegProfile.AudioCodec,
             };
+        }
 
         private static bool NeedToScale(FFmpegProfile ffmpegProfile, MediaVersion version) =>
             ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo &&

ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs

@@ -141,10 +141,14 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegProcessBuilder WithInfiniteLoop()
+        public FFmpegProcessBuilder WithInfiniteLoop(bool loop = true)
         {
-            _arguments.Add("-stream_loop");
-            _arguments.Add("-1");
+            if (loop)
+            {
+                _arguments.Add("-stream_loop");
+                _arguments.Add("-1");
+            }
+
             return this;
         }
 
@@ -324,22 +328,29 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegProcessBuilder WithHls(string channelNumber, MediaVersion mediaVersion, bool startAtZero)
+        public FFmpegProcessBuilder WithHls(string channelNumber, Option<MediaVersion> mediaVersion)
         {
             const int SEGMENT_SECONDS = 4;
-            
-            if (!int.TryParse(mediaVersion.RFrameRate, out int frameRate))
+
+            var frameRate = 24;
+
+            foreach (MediaVersion version in mediaVersion)
             {
-                string[] split = (mediaVersion.RFrameRate ?? string.Empty).Split("/");
-                if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
+                if (!int.TryParse(version.RFrameRate, out int fr))
                 {
-                    frameRate = (int)Math.Round(left / (double)right);
-                }
-                else
-                {
-                    _logger.LogInformation("Unable to detect framerate, using {FrameRate}", 24);
-                    frameRate = 24;
+                    string[] split = (version.RFrameRate ?? string.Empty).Split("/");
+                    if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
+                    {
+                        fr = (int)Math.Round(left / (double)right);
+                    }
+                    else
+                    {
+                        _logger.LogInformation("Unable to detect framerate, using {FrameRate}", 24);
+                        fr = 24;
+                    }
                 }
+
+                frameRate = fr;
             }
 
             _arguments.AddRange(
@@ -368,7 +379,8 @@ namespace ErsatzTV.Core.FFmpeg
             {
                 "-c:v", playbackSettings.VideoCodec,
                 "-flags", "cgop",
-                "-sc_threshold", "0" // disable scene change detection
+                // disable scene change detection except with mpeg2video
+                "-sc_threshold", playbackSettings.VideoCodec == "mpeg2video" ? "1000000000" : "0"
             };
 
             if (!string.IsNullOrWhiteSpace(_outputPixelFormat))

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -3,6 +3,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using LanguageExt;
@@ -37,12 +38,15 @@ namespace ErsatzTV.Core.FFmpeg
             MediaVersion version,
             string path,
             DateTimeOffset start,
+            DateTimeOffset finish,
             DateTimeOffset now,
             Option<ChannelWatermark> globalWatermark,
             VaapiDriver vaapiDriver,
             string vaapiDevice,
-            bool startAtZero,
-            bool hlsRealtime)
+            bool hlsRealtime,
+            FillerKind fillerKind,
+            TimeSpan inPoint,
+            TimeSpan outPoint)
         {
             MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, version);
             Option<MediaStream> maybeAudioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, version);
@@ -54,7 +58,9 @@ namespace ErsatzTV.Core.FFmpeg
                 videoStream,
                 maybeAudioStream,
                 start,
-                now);
+                now,
+                inPoint,
+                outPoint);
 
             (Option<ChannelWatermark> maybeWatermark, Option<string> maybeWatermarkPath) =
                 GetWatermarkOptions(channel, globalWatermark);
@@ -71,6 +77,7 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
                 .WithSeek(playbackSettings.StreamSeek)
+                .WithInfiniteLoop(fillerKind == FillerKind.Fallback)
                 .WithInputCodec(path, playbackSettings.VideoDecoder, videoStream.Codec, videoStream.PixelFormat)
                 .WithWatermark(maybeWatermark, maybeWatermarkPath, channel.FFmpegProfile.Resolution, isAnimated)
                 .WithVideoTrackTimeScale(playbackSettings.VideoTrackTimeScale)
@@ -115,13 +122,13 @@ namespace ErsatzTV.Core.FFmpeg
 
             builder = builder.WithPlaybackArgs(playbackSettings)
                 .WithMetadata(channel, maybeAudioStream)
-                .WithDuration(start + version.Duration - now);
+                .WithDuration(finish - now);
 
             switch (channel.StreamingMode)
             {
                 // HLS needs to segment and generate playlist
                 case StreamingMode.HttpLiveStreamingSegmenter:
-                    return builder.WithHls(channel.Number, version, startAtZero)
+                    return builder.WithHls(channel.Number, version)
                         .WithRealtimeOutput(hlsRealtime)
                         .Build();
                 default:
@@ -131,7 +138,12 @@ namespace ErsatzTV.Core.FFmpeg
             }
         }
 
-        public Process ForError(string ffmpegPath, Channel channel, Option<TimeSpan> duration, string errorMessage)
+        public Process ForError(
+            string ffmpegPath,
+            Channel channel,
+            Option<TimeSpan> duration,
+            string errorMessage,
+            bool hlsRealtime)
         {
             FFmpegPlaybackSettings playbackSettings =
                 _playbackSettingsCalculator.CalculateErrorSettings(channel.FFmpegProfile);
@@ -149,12 +161,22 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithErrorText(desiredResolution, errorMessage)
                 .WithPixfmt("yuv420p")
                 .WithPlaybackArgs(playbackSettings)
-                .WithMetadata(channel, None)
-                .WithFormat("mpegts");
+                .WithMetadata(channel, None);
 
             duration.IfSome(d => builder = builder.WithDuration(d));
 
-            return builder.WithPipe().Build();
+            switch (channel.StreamingMode)
+            {
+                // HLS needs to segment and generate playlist
+                case StreamingMode.HttpLiveStreamingSegmenter:
+                    return builder.WithHls(channel.Number, None)
+                        .WithRealtimeOutput(hlsRealtime)
+                        .Build();
+                default:
+                    return builder.WithFormat("mpegts")
+                        .WithPipe()
+                        .Build();
+            }
         }
 
         public Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)

ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs

@@ -11,6 +11,7 @@ namespace ErsatzTV.Core.Interfaces.Metadata
         List<EpisodeMetadata> GetFallbackMetadata(Episode episode);
         MovieMetadata GetFallbackMetadata(Movie movie);
         Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo);
+        Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo);
         string GetSortTitle(string title);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs

@@ -16,6 +16,7 @@ namespace ErsatzTV.Core.Interfaces.Metadata
         Task<bool> RefreshFallbackMetadata(Episode episode);
         Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder);
         Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo);
+        Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo);
         Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/IOtherVideoFolderScanner.cs

@@ -0,0 +1,15 @@
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Metadata
+{
+    public interface IOtherVideoFolderScanner
+    {
+        Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            decimal progressMin,
+            decimal progressMax);
+    }
+}

ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs

@@ -9,6 +9,10 @@ namespace ErsatzTV.Core.Interfaces.Plex
 {
     public interface IPlexServerApiClient
     {
+        Task<bool> Ping(
+            PlexConnection connection,
+            PlexServerAuthToken token);
+        
         Task<Either<BaseError, List<PlexLibrary>>> GetLibraries(
             PlexConnection connection,
             PlexServerAuthToken token);

ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs

@@ -18,7 +18,6 @@ namespace ErsatzTV.Core.Interfaces.Repositories
 
         Task Update(
             PlexMediaSource plexMediaSource,
-            List<PlexConnection> prioritizedConnections,
             List<PlexConnection> toAdd,
             List<PlexConnection> toDelete);
 

ErsatzTV.Core/Interfaces/Repositories/IOtherVideoRepository.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Repositories
+{
+    public interface IOtherVideoRepository
+    {
+        Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> GetOrAdd(LibraryPath libraryPath, string path);
+        Task<IEnumerable<string>> FindOtherVideoPaths(LibraryPath libraryPath);
+        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+        Task<bool> AddTag(OtherVideoMetadata metadata, Tag tag);
+        Task<List<OtherVideoMetadata>> GetOtherVideosForCards(List<int> ids);
+        // Task<int> GetOtherVideoCount(int artistId);
+        // Task<List<OtherVideoMetadata>> GetPagedOtherVideos(int artistId, int pageNumber, int pageSize);
+    }
+}

ErsatzTV.Core/Interfaces/Scheduling/IMediaCollectionEnumerator.cs

@@ -8,5 +8,6 @@ namespace ErsatzTV.Core.Interfaces.Scheduling
         CollectionEnumeratorState State { get; }
         Option<MediaItem> Current { get; }
         void MoveNext();
+        Option<MediaItem> Peek(int offset);
     }
 }

ErsatzTV.Core/Interfaces/Scheduling/IPlayoutModeScheduler.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Core.Interfaces.Scheduling
+{
+    public interface IPlayoutModeScheduler<in T> where T : ProgramScheduleItem
+    {
+        Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+            PlayoutBuilderState playoutBuilderState,
+            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+            T scheduleItem,
+            ProgramScheduleItem nextScheduleItem,
+            DateTimeOffset hardStop);
+    }
+}

ErsatzTV.Core/Iptv/ChannelGuide.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text;
 using System.Xml;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
 using LanguageExt;
@@ -70,25 +71,36 @@ namespace ErsatzTV.Core.Iptv
             foreach ((Channel channel, List<PlayoutItem> sorted) in sortedChannelItems.OrderBy(kvp => kvp.Key.Number))
             {
                 var i = 0;
+                while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None && sorted[i].FillerKind != FillerKind.PreRoll)
+                {
+                    i++;
+                }
+
                 while (i < sorted.Count)
                 {
                     PlayoutItem startItem = sorted[i];
+                    int j = i;
+                    while (j + 1 < sorted.Count && sorted[j].FillerKind != FillerKind.None)
+                    {
+                        j++;
+                    }
+                    PlayoutItem displayItem = sorted[j];
                     bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
 
                     int finishIndex = i;
-                    while (hasCustomTitle && finishIndex + 1 < sorted.Count && sorted[finishIndex + 1].CustomGroup)
+                    while (finishIndex + 1 < sorted.Count && sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup)
                     {
                         finishIndex++;
                     }
 
                     int customShowId = -1;
-                    if (sorted[i].MediaItem is Episode ep)
+                    if (displayItem.MediaItem is Episode ep)
                     {
                         customShowId = ep.Season.ShowId;
                     }
 
                     bool isSameCustomShow = hasCustomTitle;
-                    for (int x = i; x <= finishIndex; x++)
+                    for (int x = j; x <= finishIndex; x++)
                     {
                         isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
                                            customShowId == e.Season.ShowId;
@@ -97,15 +109,15 @@ namespace ErsatzTV.Core.Iptv
                     PlayoutItem finishItem = sorted[finishIndex];
                     i = finishIndex;
 
-                    // ReSharper disable once StringLiteralTypo
                     string start = startItem.StartOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
-                    // ReSharper disable once StringLiteralTypo
-                    string stop = finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
+                    string stop = displayItem.GuideFinishOffset.HasValue
+                        ? displayItem.GuideFinishOffset.Value.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty)
+                        : finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
 
-                    string title = GetTitle(startItem);
-                    string subtitle = GetSubtitle(startItem);
-                    string description = GetDescription(startItem);
-                    Option<ContentRating> contentRating = GetContentRating(startItem);
+                    string title = GetTitle(displayItem);
+                    string subtitle = GetSubtitle(displayItem);
+                    string description = GetDescription(displayItem);
+                    Option<ContentRating> contentRating = GetContentRating(displayItem);
 
                     xml.WriteStartElement("programme");
                     xml.WriteAttributeString("start", start);
@@ -136,7 +148,7 @@ namespace ErsatzTV.Core.Iptv
                         }
                     }
 
-                    if (!hasCustomTitle && startItem.MediaItem is Movie movie)
+                    if (!hasCustomTitle && displayItem.MediaItem is Movie movie)
                     {
                         foreach (MovieMetadata metadata in movie.MovieMetadata.HeadOrNone())
                         {
@@ -169,7 +181,40 @@ namespace ErsatzTV.Core.Iptv
                         }
                     }
 
-                    if (startItem.MediaItem is Episode episode && (!hasCustomTitle || isSameCustomShow))
+                    if (!hasCustomTitle && displayItem.MediaItem is MusicVideo musicVideo)
+                    {
+                        foreach (MusicVideoMetadata metadata in musicVideo.MusicVideoMetadata.HeadOrNone())
+                        {
+                            if (metadata.Year.HasValue)
+                            {
+                                xml.WriteStartElement("date");
+                                xml.WriteString(metadata.Year.Value.ToString());
+                                xml.WriteEndElement(); // date
+                            }
+                        }
+
+                        xml.WriteStartElement("category");
+                        xml.WriteAttributeString("lang", "en");
+                        xml.WriteString("Music");
+                        xml.WriteEndElement(); // category
+
+                        foreach (MusicVideoMetadata metadata in musicVideo.MusicVideoMetadata.HeadOrNone())
+                        {
+                            string thumbnail = Optional(metadata.Artwork).Flatten()
+                                .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
+                                .HeadOrNone()
+                                .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
+
+                            if (!string.IsNullOrWhiteSpace(thumbnail))
+                            {
+                                xml.WriteStartElement("icon");
+                                xml.WriteAttributeString("src", thumbnail);
+                                xml.WriteEndElement(); // icon
+                            }
+                        }
+                    }
+
+                    if (displayItem.MediaItem is Episode episode && (!hasCustomTitle || isSameCustomShow))
                     {
                         Option<ShowMetadata> maybeMetadata =
                             Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();

ErsatzTV.Core/Jellyfin/JellyfinPathReplacementService.cs

@@ -69,7 +69,7 @@ namespace ErsatzTV.Core.Jellyfin
 
                     if (log)
                     {
-                        _logger.LogDebug(
+                        _logger.LogInformation(
                             "Replacing jellyfin path {JellyfinPath} with {LocalPath} resulting in {FinalPath}",
                             replacement.JellyfinPath,
                             replacement.LocalPath,

ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs

@@ -230,7 +230,13 @@ namespace ErsatzTV.Core.Jellyfin
                         foreach (JellyfinSeason updated in await _televisionRepository.Update(incoming))
                         {
                             incoming.Show = show;
-                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { updated });
+
+                            foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
+                            {
+                                await _searchIndex.UpdateItems(
+                                    _searchRepository,
+                                    new List<MediaItem> { toIndex });
+                            }
                         }
                     },
                     async () =>

ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text.RegularExpressions;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -88,6 +89,20 @@ namespace ErsatzTV.Core.Metadata
 
             return GetMusicVideoMetadata(fileName, metadata);
         }
+        
+        public Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo)
+        {
+            string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
+            string fileName = Path.GetFileNameWithoutExtension(path);
+            var metadata = new OtherVideoMetadata
+            {
+                MetadataKind = MetadataKind.Fallback,
+                Title = fileName ?? path,
+                OtherVideo = otherVideo
+            };
+
+            return GetOtherVideoMetadata(path, metadata);
+        }
 
         public string GetSortTitle(string title)
         {
@@ -214,6 +229,43 @@ namespace ErsatzTV.Core.Metadata
                 return None;
             }
         }
+        
+        private Option<OtherVideoMetadata> GetOtherVideoMetadata(string path, OtherVideoMetadata metadata)
+        {
+            try
+            {
+                string folder = Path.GetDirectoryName(path);
+                if (folder == null)
+                {
+                    return None;
+                }
+
+                string libraryPath = metadata.OtherVideo.LibraryPath.Path;
+                string parent = Optional(Directory.GetParent(libraryPath)).Match(
+                    di => di.FullName,
+                    () => libraryPath);
+                
+                string diff = Path.GetRelativePath(parent, folder);
+                
+                var tags = diff.Split(Path.DirectorySeparatorChar)
+                    .Map(t => new Tag { Name = t })
+                    .ToList();
+                
+                metadata.Artwork = new List<Artwork>();
+                metadata.Actors = new List<Actor>();
+                metadata.Genres = new List<Genre>();
+                metadata.Tags = tags;
+                metadata.Studios = new List<Studio>();
+                metadata.DateUpdated = DateTime.UtcNow;
+                metadata.OriginalTitle = Path.GetRelativePath(libraryPath, path);
+
+                return metadata;
+            }
+            catch (Exception)
+            {
+                return None;
+            }
+        }
 
         private ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
         {

ErsatzTV.Core/Metadata/LocalFolderScanner.cs

@@ -73,6 +73,7 @@ namespace ErsatzTV.Core.Metadata
                     Movie m => m.MediaVersions.Head(),
                     Episode e => e.MediaVersions.Head(),
                     MusicVideo mv => mv.MediaVersions.Head(),
+                    OtherVideo ov => ov.MediaVersions.Head(),
                     _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                 };
 

ErsatzTV.Core/Metadata/LocalMetadataProvider.cs

@@ -30,6 +30,7 @@ namespace ErsatzTV.Core.Metadata
         private readonly IMetadataRepository _metadataRepository;
         private readonly IMovieRepository _movieRepository;
         private readonly IMusicVideoRepository _musicVideoRepository;
+        private readonly IOtherVideoRepository _otherVideoRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
         public LocalMetadataProvider(
@@ -38,6 +39,7 @@ namespace ErsatzTV.Core.Metadata
             ITelevisionRepository televisionRepository,
             IArtistRepository artistRepository,
             IMusicVideoRepository musicVideoRepository,
+            IOtherVideoRepository otherVideoRepository,
             IFallbackMetadataProvider fallbackMetadataProvider,
             ILocalFileSystem localFileSystem,
             IEpisodeNfoReader episodeNfoReader,
@@ -48,6 +50,7 @@ namespace ErsatzTV.Core.Metadata
             _televisionRepository = televisionRepository;
             _artistRepository = artistRepository;
             _musicVideoRepository = musicVideoRepository;
+            _otherVideoRepository = otherVideoRepository;
             _fallbackMetadataProvider = fallbackMetadataProvider;
             _localFileSystem = localFileSystem;
             _episodeNfoReader = episodeNfoReader;
@@ -136,6 +139,11 @@ namespace ErsatzTV.Core.Metadata
         public Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder) =>
             ApplyMetadataUpdate(artist, _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder));
 
+        public Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo) =>
+            _fallbackMetadataProvider.GetFallbackMetadata(otherVideo).Match(
+                metadata => ApplyMetadataUpdate(otherVideo, metadata),
+                () => Task.FromResult(false));
+
         public Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo) =>
             _fallbackMetadataProvider.GetFallbackMetadata(musicVideo).Match(
                 metadata => ApplyMetadataUpdate(musicVideo, metadata),
@@ -614,6 +622,45 @@ namespace ErsatzTV.Core.Metadata
 
                     return await _metadataRepository.Add(metadata);
                 });
+        
+        private Task<bool> ApplyMetadataUpdate(OtherVideo otherVideo, OtherVideoMetadata metadata) =>
+            Optional(otherVideo.OtherVideoMetadata).Flatten().HeadOrNone().Match(
+                async existing =>
+                {
+                    existing.Title = metadata.Title;
+
+                    if (existing.DateAdded == SystemTime.MinValueUtc)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+
+                    existing.DateUpdated = metadata.DateUpdated;
+                    existing.MetadataKind = metadata.MetadataKind;
+                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+                    existing.OriginalTitle = metadata.OriginalTitle;
+
+                    bool updated = await UpdateMetadataCollections(
+                        existing,
+                        metadata,
+                        (_, _) => Task.FromResult(false),
+                        _otherVideoRepository.AddTag,
+                        (_, _) => Task.FromResult(false),
+                        (_, _) => Task.FromResult(false));
+
+                    return await _metadataRepository.Update(existing) || updated;
+                },
+                async () =>
+                {
+                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+                    metadata.OtherVideoId = otherVideo.Id;
+                    otherVideo.OtherVideoMetadata = new List<OtherVideoMetadata> { metadata };
+
+                    return await _metadataRepository.Add(metadata);
+                });
 
         private async Task<Option<ShowMetadata>> LoadTelevisionShowMetadata(string nfoFileName)
         {

ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs

@@ -39,6 +39,7 @@ namespace ErsatzTV.Core.Metadata
                     Movie m => m.MediaVersions.Head().MediaFiles.Head().Path,
                     Episode e => e.MediaVersions.Head().MediaFiles.Head().Path,
                     MusicVideo mv => mv.MediaVersions.Head().MediaFiles.Head().Path,
+                    OtherVideo ov => ov.MediaVersions.Head().MediaFiles.Head().Path,
                     _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                 };
 
@@ -82,6 +83,7 @@ namespace ErsatzTV.Core.Metadata
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
                 MusicVideo mv => mv.MediaVersions.Head(),
+                OtherVideo ov => ov.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
             };
 
@@ -108,6 +110,7 @@ namespace ErsatzTV.Core.Metadata
             startInfo.ArgumentList.Add("json");
             startInfo.ArgumentList.Add("-show_format");
             startInfo.ArgumentList.Add("-show_streams");
+            startInfo.ArgumentList.Add("-show_chapters");
             startInfo.ArgumentList.Add("-i");
             startInfo.ArgumentList.Add(filePath);
 
@@ -136,9 +139,18 @@ namespace ErsatzTV.Core.Metadata
                     json =>
                     {
                         var version = new MediaVersion
-                            { Name = "Main", DateAdded = DateTime.UtcNow, Streams = new List<MediaStream>() };
+                        {
+                            Name = "Main",
+                            DateAdded = DateTime.UtcNow,
+                            Streams = new List<MediaStream>(),
+                            Chapters = new List<MediaChapter>()
+                        };
 
-                        if (double.TryParse(json.format.duration, NumberStyles.Number, CultureInfo.InvariantCulture, out double duration))
+                        if (double.TryParse(
+                            json.format.duration,
+                            NumberStyles.Number,
+                            CultureInfo.InvariantCulture,
+                            out double duration))
                         {
                             var seconds = TimeSpan.FromSeconds(duration);
                             version.Duration = seconds;
@@ -238,10 +250,56 @@ namespace ErsatzTV.Core.Metadata
                             version.Streams.Add(stream);
                         }
 
+                        foreach (FFprobeChapter probedChapter in json.chapters)
+                        {
+                            if (double.TryParse(
+                                    probedChapter.start_time,
+                                    NumberStyles.Number,
+                                    CultureInfo.InvariantCulture,
+                                    out double startTime)
+                                && double.TryParse(
+                                    probedChapter.end_time,
+                                    NumberStyles.Number,
+                                    CultureInfo.InvariantCulture,
+                                    out double endTime))
+                            {
+                                var chapter = new MediaChapter
+                                {
+                                    MediaVersionId = version.Id,
+                                    ChapterId = probedChapter.id,
+                                    StartTime = TimeSpan.FromSeconds(startTime),
+                                    EndTime = TimeSpan.FromSeconds(endTime),
+                                    Title = probedChapter?.tags?.title
+                                };
+
+                                version.Chapters.Add(chapter);
+                            }
+                            else
+                            {
+                                _logger.LogWarning(
+                                    "Media item at {Path} has a missing or invalid chapter start/end time",
+                                    path);
+                            }
+                        }
+
+                        if (version.Chapters.Any())
+                        {
+                            MediaChapter last = version.Chapters.Last();
+                            if (last.EndTime != version.Duration)
+                            {
+                                last.EndTime = version.Duration;
+                            }
+                        }
+
                         return version;
                     },
                     _ => new MediaVersion
-                        { Name = "Main", DateAdded = DateTime.UtcNow, Streams = new List<MediaStream>() });
+                    {
+                        Name = "Main",
+                        DateAdded = DateTime.UtcNow,
+                        Streams = new List<MediaStream>(),
+                        Chapters = new List<MediaChapter>()
+                    });
 
         private VideoScanKind ScanKindFromFieldOrder(string fieldOrder) =>
             fieldOrder?.ToLowerInvariant() switch
@@ -252,13 +310,13 @@ namespace ErsatzTV.Core.Metadata
             };
 
         // ReSharper disable InconsistentNaming
-        public record FFprobe(FFprobeFormat format, List<FFprobeStream> streams);
+        public record FFprobe(FFprobeFormat format, List<FFprobeStream> streams, List<FFprobeChapter> chapters);
 
         public record FFprobeFormat(string duration);
 
         public record FFprobeDisposition(int @default, int forced);
 
-        public record FFProbeTags(string language, string title);
+        public record FFprobeTags(string language, string title);
 
         public record FFprobeStream(
             int index,
@@ -275,7 +333,13 @@ namespace ErsatzTV.Core.Metadata
             string r_frame_rate,
             string bits_per_raw_sample,
             FFprobeDisposition disposition,
-            FFProbeTags tags);
+            FFprobeTags tags);
+
+        public record FFprobeChapter(
+            long id,
+            string start_time,
+            string end_time,
+            FFprobeTags tags);
         // ReSharper restore InconsistentNaming
     }
 }

ErsatzTV.Core/Metadata/OtherVideoFolderScanner.cs

@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Images;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Core.Metadata
+{
+    public class OtherVideoFolderScanner : LocalFolderScanner, IOtherVideoFolderScanner
+    {
+        private readonly ILocalFileSystem _localFileSystem;
+        private readonly ILocalMetadataProvider _localMetadataProvider;
+        private readonly IMediator _mediator;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ISearchRepository _searchRepository;
+        private readonly IOtherVideoRepository _otherVideoRepository;
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ILogger<OtherVideoFolderScanner> _logger;
+
+        public OtherVideoFolderScanner(
+            ILocalFileSystem localFileSystem,
+            ILocalStatisticsProvider localStatisticsProvider,
+            ILocalMetadataProvider localMetadataProvider,
+            IMetadataRepository metadataRepository,
+            IImageCache imageCache,
+            IMediator mediator,
+            ISearchIndex searchIndex,
+            ISearchRepository searchRepository,
+            IOtherVideoRepository otherVideoRepository,
+            ILibraryRepository libraryRepository,
+            ILogger<OtherVideoFolderScanner> logger) : base(
+            localFileSystem,
+            localStatisticsProvider,
+            metadataRepository,
+            imageCache,
+            logger)
+        {
+            _localFileSystem = localFileSystem;
+            _localMetadataProvider = localMetadataProvider;
+            _mediator = mediator;
+            _searchIndex = searchIndex;
+            _searchRepository = searchRepository;
+            _otherVideoRepository = otherVideoRepository;
+            _libraryRepository = libraryRepository;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            decimal progressMin,
+            decimal progressMax)
+        {
+            decimal progressSpread = progressMax - progressMin;
+
+            if (!_localFileSystem.IsLibraryPathAccessible(libraryPath))
+            {
+                return new MediaSourceInaccessible();
+            }
+
+            var foldersCompleted = 0;
+
+            var folderQueue = new Queue<string>();
+            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+                .Filter(ShouldIncludeFolder)
+                .OrderBy(identity))
+            {
+                folderQueue.Enqueue(folder);
+            }
+
+            while (folderQueue.Count > 0)
+            {
+                decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
+                await _mediator.Publish(
+                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+
+                string otherVideoFolder = folderQueue.Dequeue();
+                foldersCompleted++;
+
+                var filesForEtag = _localFileSystem.ListFiles(otherVideoFolder).ToList();
+
+                var allFiles = filesForEtag
+                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                    .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+                    .ToList();
+
+                foreach (string subdirectory in _localFileSystem.ListSubdirectories(otherVideoFolder)
+                    .Filter(ShouldIncludeFolder)
+                    .OrderBy(identity))
+                {
+                    folderQueue.Enqueue(subdirectory);
+                }
+
+                string etag = FolderEtag.Calculate(otherVideoFolder, _localFileSystem);
+                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                    .Filter(f => f.Path == otherVideoFolder)
+                    .HeadOrNone();
+
+                // skip folder if etag matches
+                if (!allFiles.Any() || await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
+                {
+                    continue;
+                }
+
+                _logger.LogDebug(
+                    "UPDATE: Etag has changed for folder {Folder}",
+                    otherVideoFolder);
+
+                foreach (string file in allFiles.OrderBy(identity))
+                {
+                    Either<BaseError, MediaItemScanResult<OtherVideo>> maybeVideo = await _otherVideoRepository
+                        .GetOrAdd(libraryPath, file)
+                        .BindT(video => UpdateStatistics(video, ffprobePath))
+                        .BindT(UpdateMetadata);
+
+                    await maybeVideo.Match(
+                        async result =>
+                        {
+                            if (result.IsAdded)
+                            {
+                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
+                            {
+                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                            }
+
+                            await _libraryRepository.SetEtag(libraryPath, knownFolder, otherVideoFolder, etag);
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning("Error processing other video at {Path}: {Error}", file, error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+            }
+
+            foreach (string path in await _otherVideoRepository.FindOtherVideoPaths(libraryPath))
+            {
+                if (!_localFileSystem.FileExists(path))
+                {
+                    _logger.LogInformation("Removing missing other video at {Path}", path);
+                    List<int> otherVideoIds = await _otherVideoRepository.DeleteByPath(libraryPath, path);
+                    await _searchIndex.RemoveItems(otherVideoIds);
+                }
+                else if (Path.GetFileName(path).StartsWith("._"))
+                {
+                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                    List<int> otherVideoIds = await _otherVideoRepository.DeleteByPath(libraryPath, path);
+                    await _searchIndex.RemoveItems(otherVideoIds);
+                }
+            }
+
+            _searchIndex.Commit();
+            return Unit.Default;
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> UpdateMetadata(
+            MediaItemScanResult<OtherVideo> result)
+        {
+            try
+            {
+                OtherVideo otherVideo = result.Item;
+                if (!Optional(otherVideo.OtherVideoMetadata).Flatten().Any())
+                {
+                    otherVideo.OtherVideoMetadata ??= new List<OtherVideoMetadata>();
+
+                    string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
+                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                    if (await _localMetadataProvider.RefreshFallbackMetadata(otherVideo))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+    }
+}

ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
@@ -36,5 +37,8 @@ namespace ErsatzTV.Core.Scheduling
         public Option<MediaItem> Current => _sortedMediaItems.Any() ? _sortedMediaItems[State.Index] : None;
 
         public void MoveNext() => State.Index = (State.Index + 1) % _sortedMediaItems.Count;
+
+        public Option<MediaItem> Peek(int offset) =>
+            _sortedMediaItems.Any() ? _sortedMediaItems[(State.Index + offset) % _sortedMediaItems.Count] : None;
     }
 }

ErsatzTV.Core/Scheduling/CollectionKey.cs

@@ -0,0 +1,88 @@
+using System;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Scheduling
+{
+    public class CollectionKey : Record<CollectionKey>
+    {
+        public static CollectionKey ForScheduleItem(ProgramScheduleItem item) =>
+            item.CollectionType switch
+            {
+                ProgramScheduleItemCollectionType.Collection => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    CollectionId = item.CollectionId
+                },
+                ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    MediaItemId = item.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    MediaItemId = item.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.Artist => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    MediaItemId = item.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    MultiCollectionId = item.MultiCollectionId
+                },
+                ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
+                {
+                    CollectionType = item.CollectionType,
+                    SmartCollectionId = item.SmartCollectionId
+                },
+                _ => throw new ArgumentOutOfRangeException(nameof(item))
+            };
+        
+        public static CollectionKey ForFillerPreset(FillerPreset filler) =>
+            filler.CollectionType switch
+            {
+                ProgramScheduleItemCollectionType.Collection => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    CollectionId = filler.CollectionId
+                },
+                ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    MediaItemId = filler.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    MediaItemId = filler.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.Artist => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    MediaItemId = filler.MediaItemId
+                },
+                ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    MultiCollectionId = filler.MultiCollectionId
+                },
+                ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
+                {
+                    CollectionType = filler.CollectionType,
+                    SmartCollectionId = filler.SmartCollectionId
+                },
+                _ => throw new ArgumentOutOfRangeException(nameof(filler))
+            };
+        
+        public ProgramScheduleItemCollectionType CollectionType { get; set; }
+        public int? CollectionId { get; set; }
+        public int? MultiCollectionId { get; set; }
+        public int? SmartCollectionId { get; set; }
+        public int? MediaItemId { get; set; }
+    }
+}