refactor namespaces and imports (#670)

* re-namespace * optimize usings * more usings * more of the same * more implicit/global usings * cleanup all usings * minor fixes
2022-03-03 15:36:07 -06:00
parent 748581bf5a
commit 1ab98578ab
1164 changed files with 50127 additions and 53816 deletions
@@ -3,6 +3,7 @@
    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <NoWarn>VSTHRD200</NoWarn>
+        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>

    <ItemGroup>
@@ -1,32 +1,31 @@
-using System;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+public class HlsPlaylistFilterTests
 {
-    [TestFixture]
-    public class HlsPlaylistFilterTests
+    private HlsPlaylistFilter _hlsPlaylistFilter;
+        
+    [SetUp]
+    public void SetUp()
    {
-        private HlsPlaylistFilter _hlsPlaylistFilter;
-        
-        [SetUp]
-        public void SetUp()
-        {
-            _hlsPlaylistFilter = new HlsPlaylistFilter(
-                new Mock<ITempFilePool>().Object,
-                new Mock<ILogger<HlsPlaylistFilter>>().Object
-            );
-        }
+        _hlsPlaylistFilter = new HlsPlaylistFilter(
+            new Mock<ITempFilePool>().Object,
+            new Mock<ILogger<HlsPlaylistFilter>>().Object
+        );
+    }

-        [Test]
-        public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -42,12 +41,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);

-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -64,13 +63,13 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
+    }
        
-        [Test]
-        public void _hlsPlaylistFilter_ShouldLimitSegments()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldLimitSegments()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -86,12 +85,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);

-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -105,13 +104,13 @@ live001137.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
 live001138.ts
 "));
-        }
+    }
        
-        [Test]
-        public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -127,17 +126,17 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(
-                start,
-                start.AddSeconds(-30),
-                input,
-                int.MaxValue,
-                true);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(
+            start,
+            start.AddSeconds(-30),
+            input,
+            int.MaxValue,
+            true);

-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -155,13 +154,13 @@ live001138.ts
 live001139.ts
 #EXT-X-DISCONTINUITY
 "));
-        }
+    }

-        [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldSegments()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldFilterOldSegments()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -177,12 +176,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);

-            result.PlaylistStart.Should().Be(start.AddSeconds(8));
-            result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start.AddSeconds(8));
+        result.Sequence.Should().Be(1139);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1139
@@ -193,13 +192,13 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
+    }
        
-        [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -216,12 +215,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);

-            result.PlaylistStart.Should().Be(start.AddSeconds(8));
-            result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start.AddSeconds(8));
+        result.Sequence.Should().Be(1139);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1139
@@ -232,14 +231,13 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
-
-        private static string NormalizeLineEndings(string str)
-        {
-            return str
-                .Replace("\r\n", "\n")
-                .Replace("\r", "\n")
-                .Replace("\n", Environment.NewLine);
-        }
    }
-}
+
+    private static string NormalizeLineEndings(string str)
+    {
+        return str
+            .Replace("\r\n", "\n")
+            .Replace("\r", "\n")
+            .Replace("\n", Environment.NewLine);
+    }
+}
@@ -1,12 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
+using System.Diagnostics;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.FFmpeg;
@@ -15,173 +9,171 @@ using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 using Serilog;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+[Explicit]
+public class TranscodingTests
 {
-    [TestFixture]
-    [Explicit]
-    public class TranscodingTests
-    {
-        private static readonly ILoggerFactory LoggerFactory;
+    private static readonly ILoggerFactory LoggerFactory;
        
-        static TranscodingTests()
-        {
-            Log.Logger = new LoggerConfiguration()
-                .MinimumLevel.Debug()
-                .WriteTo.Console()
-                .CreateLogger();
+    static TranscodingTests()
+    {
+        Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Debug()
+            .WriteTo.Console()
+            .CreateLogger();

-            LoggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
+        LoggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
+    }
+
+    [Test]
+    [Explicit]
+    public void DeleteTestVideos()
+    {
+        foreach (string file in Directory.GetFiles(TestContext.CurrentContext.TestDirectory, "*.mkv"))
+        {
+            File.Delete(file);
        }

-        [Test]
-        [Explicit]
-        public void DeleteTestVideos()
+        Assert.Pass();
+    }
+
+    public record InputFormat(string Encoder, string PixelFormat);
+
+    public enum Padding
+    {
+        NoPadding,
+        WithPadding
+    }
+
+    public enum Watermark
+    {
+        None,
+        PermanentOpaque,
+        PermanentTransparent,
+        IntermittentOpaque,
+        IntermittentTransparent
+        // TODO: animated vs static
+    }
+
+    private class TestData
+    {
+        public static Watermark[] Watermarks =
        {
-            foreach (string file in Directory.GetFiles(TestContext.CurrentContext.TestDirectory, "*.mkv"))
-            {
-                File.Delete(file);
-            }
-
-            Assert.Pass();
-        }
-
-        public record InputFormat(string Encoder, string PixelFormat);
-
-        public enum Padding
-        {
-            NoPadding,
-            WithPadding
-        }
-
-        public enum Watermark
-        {
-            None,
-            PermanentOpaque,
-            PermanentTransparent,
-            IntermittentOpaque,
-            IntermittentTransparent
-            // TODO: animated vs static
-        }
-
-        private class TestData
-        {
-            public static Watermark[] Watermarks =
-            {
-                Watermark.None,
-                Watermark.PermanentOpaque,
-                Watermark.PermanentTransparent
-            };
+            Watermark.None,
+            Watermark.PermanentOpaque,
+            Watermark.PermanentTransparent
+        };
            
-            public static Padding[] Paddings =
-            {
-                Padding.NoPadding,
-                Padding.WithPadding
-            };
+        public static Padding[] Paddings =
+        {
+            Padding.NoPadding,
+            Padding.WithPadding
+        };

-            public static VideoScanKind[] VideoScanKinds =
-            {
-                VideoScanKind.Progressive,
-                VideoScanKind.Interlaced
-            };
+        public static VideoScanKind[] VideoScanKinds =
+        {
+            VideoScanKind.Progressive,
+            VideoScanKind.Interlaced
+        };

-            public static InputFormat[] InputFormats =
-            {
-                new("libx264", "yuv420p"),
-                new("libx264", "yuvj420p"),
-                new("libx264", "yuv420p10le"),
-                // new("libx264", "yuv444p10le"),
+        public static InputFormat[] InputFormats =
+        {
+            new("libx264", "yuv420p"),
+            new("libx264", "yuvj420p"),
+            new("libx264", "yuv420p10le"),
+            // new("libx264", "yuv444p10le"),

-                new("mpeg1video", "yuv420p"),
+            new("mpeg1video", "yuv420p"),

-                new("mpeg2video", "yuv420p"),
+            new("mpeg2video", "yuv420p"),

-                new("libx265", "yuv420p"),
-                new("libx265", "yuv420p10le"),
+            new("libx265", "yuv420p"),
+            new("libx265", "yuv420p10le"),

-                new("mpeg4", "yuv420p"),
+            new("mpeg4", "yuv420p"),

-                new("libvpx-vp9", "yuv420p"),
+            new("libvpx-vp9", "yuv420p"),

-                // new("libaom-av1", "yuv420p")
-                // av1    yuv420p10le    51
+            // new("libaom-av1", "yuv420p")
+            // av1    yuv420p10le    51

-                new("msmpeg4v2", "yuv420p"),
-                new("msmpeg4v3", "yuv420p")
+            new("msmpeg4v2", "yuv420p"),
+            new("msmpeg4v3", "yuv420p")

-                // wmv3    yuv420p    1
-            };
+            // wmv3    yuv420p    1
+        };
            
-            public static Resolution[] Resolutions =
-            {
-                new() { Width = 1920, Height = 1080 },
-                new() { Width = 1280, Height = 720 }
-            };
+        public static Resolution[] Resolutions =
+        {
+            new() { Width = 1920, Height = 1080 },
+            new() { Width = 1280, Height = 720 }
+        };

-            public static string[] SoftwareCodecs =
-            {
-                "libx264",
-                "libx265"
-            };
+        public static string[] SoftwareCodecs =
+        {
+            "libx264",
+            "libx265"
+        };

-            public static HardwareAccelerationKind[] NoAcceleration =
-            {
-                HardwareAccelerationKind.None
-            };
+        public static HardwareAccelerationKind[] NoAcceleration =
+        {
+            HardwareAccelerationKind.None
+        };

-            public static string[] NvidiaCodecs =
-            {
-                "h264_nvenc",
-                "hevc_nvenc"
-            };
+        public static string[] NvidiaCodecs =
+        {
+            "h264_nvenc",
+            "hevc_nvenc"
+        };

-            public static HardwareAccelerationKind[] NvidiaAcceleration =
-            {
-                HardwareAccelerationKind.Nvenc
-            };
+        public static HardwareAccelerationKind[] NvidiaAcceleration =
+        {
+            HardwareAccelerationKind.Nvenc
+        };

-            public static string[] VaapiCodecs =
-            {
-                "h264_vaapi",
-                "hevc_vaapi"
-            };
+        public static string[] VaapiCodecs =
+        {
+            "h264_vaapi",
+            "hevc_vaapi"
+        };

-            public static HardwareAccelerationKind[] VaapiAcceleration =
-            {
-                HardwareAccelerationKind.Vaapi
-            };
+        public static HardwareAccelerationKind[] VaapiAcceleration =
+        {
+            HardwareAccelerationKind.Vaapi
+        };

-            public static string[] VideoToolboxCodecs =
-            {
-                "h264_videotoolbox",
-                "hevc_videotoolbox"
-            };
+        public static string[] VideoToolboxCodecs =
+        {
+            "h264_videotoolbox",
+            "hevc_videotoolbox"
+        };

-            public static HardwareAccelerationKind[] VideoToolboxAcceleration =
-            {
-                HardwareAccelerationKind.VideoToolbox
-            };
+        public static HardwareAccelerationKind[] VideoToolboxAcceleration =
+        {
+            HardwareAccelerationKind.VideoToolbox
+        };

-            public static string[] QsvCodecs =
-            {
-                "h264_qsv",
-                "hevc_qsv"
-            };
+        public static string[] QsvCodecs =
+        {
+            "h264_qsv",
+            "hevc_qsv"
+        };

-            public static HardwareAccelerationKind[] QsvAcceleration =
-            {
-                HardwareAccelerationKind.Qsv
-            };
-        }
+        public static HardwareAccelerationKind[] QsvAcceleration =
+        {
+            HardwareAccelerationKind.Qsv
+        };
+    }

-        [Test, Combinatorial]
-        public async Task Transcode(
+    [Test, Combinatorial]
+    public async Task Transcode(
            [ValueSource(typeof(TestData), nameof(TestData.InputFormats))]
            InputFormat inputFormat,
            [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
@@ -196,280 +188,279 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            // [ValueSource(typeof(TestData), nameof(TestData.NoAcceleration))] HardwareAccelerationKind profileAcceleration)
            [ValueSource(typeof(TestData), nameof(TestData.NvidiaCodecs))] string profileCodec,
            [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
+    {
+        if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
        {
-            if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
+            if (videoScanKind == VideoScanKind.Interlaced)
            {
-                if (videoScanKind == VideoScanKind.Interlaced)
-                {
-                    Assert.Inconclusive($"{inputFormat.Encoder} does not support interlaced content");
-                    return;
-                }
-            }
-
-            string name = GetStringSha256Hash(
-                $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
-
-            string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
-            if (!File.Exists(file))
-            {
-                string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
-
-                string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
-                string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
-                
-                string args =
-                    $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
-                var p1 = new Process
-                {
-                    StartInfo = new ProcessStartInfo
-                    {
-                        FileName = ExecutableName("ffmpeg"),
-                        Arguments = args
-                    }
-                };
-
-                p1.Start();
-                await p1.WaitForExitAsync();
-                // ReSharper disable once MethodHasAsyncOverload
-                p1.WaitForExit();
-                p1.ExitCode.Should().Be(0);
-            }
-
-            var imageCache = new Mock<IImageCache>();
-            
-            // always return the static watermark resource
-            imageCache.Setup(
-                    ic => ic.GetPathForImage(
-                        It.IsAny<string>(),
-                        It.Is<ArtworkKind>(x => x == ArtworkKind.Watermark),
-                        It.IsAny<Option<int>>()))
-                .Returns(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "ErsatzTV.png"));
-
-            var oldService = new FFmpegProcessService(
-                new FFmpegPlaybackSettingsCalculator(),
-                new FakeStreamSelector(),
-                imageCache.Object,
-                new Mock<ITempFilePool>().Object,
-                LoggerFactory.CreateLogger<FFmpegProcessService>());
-
-            var service = new FFmpegLibraryProcessService(
-                oldService,
-                new FFmpegPlaybackSettingsCalculator(),
-                new FakeStreamSelector(),
-                LoggerFactory.CreateLogger<FFmpegLibraryProcessService>());
-
-            var v = new MediaVersion
-            {
-                MediaFiles = new List<MediaFile>
-                {
-                    new() { Path = file }
-                }
-            };
-
-            var metadataRepository = new Mock<IMetadataRepository>();
-            metadataRepository
-                .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-                .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
-                {
-                    version.MediaFiles = v.MediaFiles;
-                    v = version;
-                });
-
-            var localStatisticsProvider = new LocalStatisticsProvider(
-                metadataRepository.Object,
-                new LocalFileSystem(LoggerFactory.CreateLogger<LocalFileSystem>()),
-                LoggerFactory.CreateLogger<LocalStatisticsProvider>());
-
-            await localStatisticsProvider.RefreshStatistics(
-                ExecutableName("ffprobe"),
-                new Movie
-                {
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = file }
-                            }
-                        }
-                    }
-                });
-
-            DateTimeOffset now = DateTimeOffset.Now;
-
-            Option<ChannelWatermark> channelWatermark = Option<ChannelWatermark>.None;
-            switch (watermark)
-            {
-                case Watermark.None:
-                    break;
-                case Watermark.IntermittentOpaque:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Intermittent,
-                        // TODO: how do we make sure this actually appears
-                        FrequencyMinutes = 1,
-                        DurationSeconds = 2,
-                        Opacity = 100
-                    };
-                    break;
-                case Watermark.IntermittentTransparent:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Intermittent,
-                        // TODO: how do we make sure this actually appears
-                        FrequencyMinutes = 1,
-                        DurationSeconds = 2,
-                        Opacity = 80
-                    };
-                    break;
-                case Watermark.PermanentOpaque:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Permanent,
-                        Opacity = 100
-                    };
-                    break;
-                case Watermark.PermanentTransparent:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Permanent,
-                        Opacity = 80
-                    };
-                    break;
-            }
-
-            Process process = await service.ForPlayoutItem(
-                ExecutableName("ffmpeg"),
-                false,
-                new Channel(Guid.NewGuid())
-                {
-                    Number = "1",
-                    FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
-                    {
-                        HardwareAcceleration = profileAcceleration,
-                        VideoCodec = profileCodec,
-                        AudioCodec = "aac"
-                    },
-                    StreamingMode = StreamingMode.TransportStream
-                },
-                v,
-                v,
-                file,
-                file,
-                now,
-                now + TimeSpan.FromSeconds(5),
-                now,
-                channelWatermark,
-                VaapiDriver.Default,
-                "/dev/dri/renderD128",
-                false,
-                FillerKind.None,
-                TimeSpan.Zero,
-                TimeSpan.FromSeconds(5),
-                0,
-                None);
-
-            process.StartInfo.RedirectStandardError = true;
-            process.EnableRaisingEvents = true;
-            
-            // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
-
-            process.Start().Should().BeTrue();
-
-            string[] unsupportedMessages =
-            {
-                "No support for codec",
-                "No usable",
-                "Provided device doesn't support"
-            };
-
-            var errorBuffer = new StringBuilder();
-            
-            process.ErrorDataReceived += (_, errorLine) =>
-            {
-                string data = errorLine.Data ?? string.Empty;
-                errorBuffer.AppendLine(data);
-            };
-
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
-            // string error = await process.StandardError.ReadToEndAsync();
-
-            var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
-            try
-            {
-                await process.WaitForExitAsync(timeoutSignal.Token);
-                // ReSharper disable once MethodHasAsyncOverload
-                process.WaitForExit();
-            }
-            catch (OperationCanceledException)
-            {
-                process.Kill();
-
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
+                Assert.Inconclusive($"{inputFormat.Encoder} does not support interlaced content");
                return;
            }
+        }

-            var error = errorBuffer.ToString();
-            bool isUnsupported = unsupportedMessages.Any(error.Contains); 
+        string name = GetStringSha256Hash(
+            $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");

-            if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
+        string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
+        if (!File.Exists(file))
+        {
+            string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
+
+            string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
+            string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
+                
+            string args =
+                $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
+            var p1 = new Process
            {
-                var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-                process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
-                Assert.Warn($"Unsupported on this hardware: ffmpeg {string.Join(" ", quotedArgs)}");
-            }
-            else if (error.Contains("Impossible to convert between"))
-            {
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                Assert.Fail($"Transcode failure: ffmpeg {string.Join(" ", quotedArgs)}");
-            }
-            else
-            {
-                var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-                process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
-                if (process.ExitCode == 0)
+                StartInfo = new ProcessStartInfo
                {
-                    Console.WriteLine(string.Join(" ", quotedArgs));
+                    FileName = ExecutableName("ffmpeg"),
+                    Arguments = args
                }
-            }
+            };
+
+            p1.Start();
+            await p1.WaitForExitAsync();
+            // ReSharper disable once MethodHasAsyncOverload
+            p1.WaitForExit();
+            p1.ExitCode.Should().Be(0);
        }
-        
-        private static string GetStringSha256Hash(string text)
+
+        var imageCache = new Mock<IImageCache>();
+            
+        // always return the static watermark resource
+        imageCache.Setup(
+                ic => ic.GetPathForImage(
+                    It.IsAny<string>(),
+                    It.Is<ArtworkKind>(x => x == ArtworkKind.Watermark),
+                    It.IsAny<Option<int>>()))
+            .Returns(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "ErsatzTV.png"));
+
+        var oldService = new FFmpegProcessService(
+            new FFmpegPlaybackSettingsCalculator(),
+            new FakeStreamSelector(),
+            imageCache.Object,
+            new Mock<ITempFilePool>().Object,
+            LoggerFactory.CreateLogger<FFmpegProcessService>());
+
+        var service = new FFmpegLibraryProcessService(
+            oldService,
+            new FFmpegPlaybackSettingsCalculator(),
+            new FakeStreamSelector(),
+            LoggerFactory.CreateLogger<FFmpegLibraryProcessService>());
+
+        var v = new MediaVersion
        {
-            if (string.IsNullOrEmpty(text))
+            MediaFiles = new List<MediaFile>
            {
-                return string.Empty;
+                new() { Path = file }
            }
+        };

-            using var sha = SHA256.Create();
-            byte[] textData = Encoding.UTF8.GetBytes(text);
-            byte[] hash = sha.ComputeHash(textData);
-            return BitConverter.ToString(hash).Replace("-", string.Empty);
-        }
+        var metadataRepository = new Mock<IMetadataRepository>();
+        metadataRepository
+            .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+            .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
+            {
+                version.MediaFiles = v.MediaFiles;
+                v = version;
+            });

-        private class FakeStreamSelector : IFFmpegStreamSelector
+        var localStatisticsProvider = new LocalStatisticsProvider(
+            metadataRepository.Object,
+            new LocalFileSystem(LoggerFactory.CreateLogger<LocalFileSystem>()),
+            LoggerFactory.CreateLogger<LocalStatisticsProvider>());
+
+        await localStatisticsProvider.RefreshStatistics(
+            ExecutableName("ffprobe"),
+            new Movie
+            {
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = file }
+                        }
+                    }
+                }
+            });
+
+        DateTimeOffset now = DateTimeOffset.Now;
+
+        Option<ChannelWatermark> channelWatermark = Option<ChannelWatermark>.None;
+        switch (watermark)
        {
-            public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
-                version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
-
-            public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
-                Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+            case Watermark.None:
+                break;
+            case Watermark.IntermittentOpaque:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Intermittent,
+                    // TODO: how do we make sure this actually appears
+                    FrequencyMinutes = 1,
+                    DurationSeconds = 2,
+                    Opacity = 100
+                };
+                break;
+            case Watermark.IntermittentTransparent:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Intermittent,
+                    // TODO: how do we make sure this actually appears
+                    FrequencyMinutes = 1,
+                    DurationSeconds = 2,
+                    Opacity = 80
+                };
+                break;
+            case Watermark.PermanentOpaque:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Permanent,
+                    Opacity = 100
+                };
+                break;
+            case Watermark.PermanentTransparent:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Permanent,
+                    Opacity = 80
+                };
+                break;
        }

-        private static string ExecutableName(string baseName) =>
-            OperatingSystem.IsWindows() ? $"{baseName}.exe" : baseName;
+        Process process = await service.ForPlayoutItem(
+            ExecutableName("ffmpeg"),
+            false,
+            new Channel(Guid.NewGuid())
+            {
+                Number = "1",
+                FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
+                {
+                    HardwareAcceleration = profileAcceleration,
+                    VideoCodec = profileCodec,
+                    AudioCodec = "aac"
+                },
+                StreamingMode = StreamingMode.TransportStream
+            },
+            v,
+            v,
+            file,
+            file,
+            now,
+            now + TimeSpan.FromSeconds(5),
+            now,
+            channelWatermark,
+            VaapiDriver.Default,
+            "/dev/dri/renderD128",
+            false,
+            FillerKind.None,
+            TimeSpan.Zero,
+            TimeSpan.FromSeconds(5),
+            0,
+            None);
+
+        process.StartInfo.RedirectStandardError = true;
+        process.EnableRaisingEvents = true;
+            
+        // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
+
+        process.Start().Should().BeTrue();
+
+        string[] unsupportedMessages =
+        {
+            "No support for codec",
+            "No usable",
+            "Provided device doesn't support"
+        };
+
+        var errorBuffer = new StringBuilder();
+            
+        process.ErrorDataReceived += (_, errorLine) =>
+        {
+            string data = errorLine.Data ?? string.Empty;
+            errorBuffer.AppendLine(data);
+        };
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+        // string error = await process.StandardError.ReadToEndAsync();
+
+        var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        try
+        {
+            await process.WaitForExitAsync(timeoutSignal.Token);
+            // ReSharper disable once MethodHasAsyncOverload
+            process.WaitForExit();
+        }
+        catch (OperationCanceledException)
+        {
+            process.Kill();
+
+            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+            Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
+            return;
+        }
+
+        var error = errorBuffer.ToString();
+        bool isUnsupported = unsupportedMessages.Any(error.Contains); 
+
+        if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
+        {
+            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
+            process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
+            Assert.Warn($"Unsupported on this hardware: ffmpeg {string.Join(" ", quotedArgs)}");
+        }
+        else if (error.Contains("Impossible to convert between"))
+        {
+            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+            Assert.Fail($"Transcode failure: ffmpeg {string.Join(" ", quotedArgs)}");
+        }
+        else
+        {
+            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
+            process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
+            if (process.ExitCode == 0)
+            {
+                Console.WriteLine(string.Join(" ", quotedArgs));
+            }
+        }
    }
-}
+        
+    private static string GetStringSha256Hash(string text)
+    {
+        if (string.IsNullOrEmpty(text))
+        {
+            return string.Empty;
+        }
+
+        using var sha = SHA256.Create();
+        byte[] textData = Encoding.UTF8.GetBytes(text);
+        byte[] hash = sha.ComputeHash(textData);
+        return BitConverter.ToString(hash).Replace("-", string.Empty);
+    }
+
+    private class FakeStreamSelector : IFFmpegStreamSelector
+    {
+        public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
+            version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+
+        public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
+            Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+    }
+
+    private static string ExecutableName(string baseName) =>
+        OperatingSystem.IsWindows() ? $"{baseName}.exe" : baseName;
+}
@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.FFmpeg;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

 namespace ErsatzTV.Core.Tests.FFmpeg;

@@ -1,9 +1,6 @@
-using System;
+namespace ErsatzTV.Core.Tests.Fakes;

-namespace ErsatzTV.Core.Tests.Fakes
+public record FakeFileEntry(string Path)
 {
-    public record FakeFileEntry(string Path)
-    {
-        public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
-    }
-}
+    public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
+}
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Tests.Fakes
-{
-    public record FakeFolderEntry(string Path);
-}
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public record FakeFolderEntry(string Path);
@@ -1,83 +1,75 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using LanguageExt;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeLocalFileSystem : ILocalFileSystem
 {
-    public class FakeLocalFileSystem : ILocalFileSystem
+    public static readonly byte[] TestBytes = { 1, 2, 3, 4, 5 };
+
+    private readonly List<FakeFileEntry> _files;
+    private readonly List<FakeFolderEntry> _folders;
+
+    public FakeLocalFileSystem(List<FakeFileEntry> files) : this(files, new List<FakeFolderEntry>())
    {
-        public static readonly byte[] TestBytes = { 1, 2, 3, 4, 5 };
+    }

-        private readonly List<FakeFileEntry> _files;
-        private readonly List<FakeFolderEntry> _folders;
+    public FakeLocalFileSystem(List<FakeFileEntry> files, List<FakeFolderEntry> folders)
+    {
+        _files = files;

-        public FakeLocalFileSystem(List<FakeFileEntry> files) : this(files, new List<FakeFolderEntry>())
+        var allFolders = new List<string>(folders.Map(f => f.Path));
+        foreach (FakeFileEntry file in _files)
        {
+            List<DirectoryInfo> moreFolders =
+                Split(new DirectoryInfo(Path.GetDirectoryName(file.Path) ?? string.Empty));
+            allFolders.AddRange(moreFolders.Map(i => i.FullName));
        }

-        public FakeLocalFileSystem(List<FakeFileEntry> files, List<FakeFolderEntry> folders)
+        _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
+    }
+
+    public Unit EnsureFolderExists(string folder) => Unit.Default;
+
+    public DateTime GetLastWriteTime(string path) =>
+        Optional(_files.SingleOrDefault(f => f.Path == path))
+            .Map(f => f.LastWriteTime)
+            .IfNone(SystemTime.MinValueUtc);
+
+    public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
+        _folders.Any(f => f.Path == libraryPath.Path);
+
+    public IEnumerable<string> ListSubdirectories(string folder) =>
+        _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
+
+    public IEnumerable<string> ListFiles(string folder) =>
+        _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
+
+    public bool FileExists(string path) => _files.Any(f => f.Path == path);
+    public bool FolderExists(string folder) => false;
+
+    public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
+
+    public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
+        Task.FromResult(Right<BaseError, Unit>(Unit.Default));
+
+    public Unit EmptyFolder(string folder) => Unit.Default;
+
+    private static List<DirectoryInfo> Split(DirectoryInfo path)
+    {
+        var result = new List<DirectoryInfo>();
+        if (path == null || string.IsNullOrWhiteSpace(path.FullName))
        {
-            _files = files;
-
-            var allFolders = new List<string>(folders.Map(f => f.Path));
-            foreach (FakeFileEntry file in _files)
-            {
-                List<DirectoryInfo> moreFolders =
-                    Split(new DirectoryInfo(Path.GetDirectoryName(file.Path) ?? string.Empty));
-                allFolders.AddRange(moreFolders.Map(i => i.FullName));
-            }
-
-            _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
-        }
-
-        public Unit EnsureFolderExists(string folder) => Unit.Default;
-
-        public DateTime GetLastWriteTime(string path) =>
-            Optional(_files.SingleOrDefault(f => f.Path == path))
-                .Map(f => f.LastWriteTime)
-                .IfNone(SystemTime.MinValueUtc);
-
-        public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
-            _folders.Any(f => f.Path == libraryPath.Path);
-
-        public IEnumerable<string> ListSubdirectories(string folder) =>
-            _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
-
-        public IEnumerable<string> ListFiles(string folder) =>
-            _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
-
-        public bool FileExists(string path) => _files.Any(f => f.Path == path);
-        public bool FolderExists(string folder) => false;
-
-        public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
-
-        public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
-            Task.FromResult(Right<BaseError, Unit>(Unit.Default));
-
-        public Unit EmptyFolder(string folder) => Unit.Default;
-
-        private static List<DirectoryInfo> Split(DirectoryInfo path)
-        {
-            var result = new List<DirectoryInfo>();
-            if (path == null || string.IsNullOrWhiteSpace(path.FullName))
-            {
-                return result;
-            }
-
-            if (path.Parent != null)
-            {
-                result.AddRange(Split(path.Parent));
-            }
-
-            result.Add(path);
-
            return result;
        }
+
+        if (path.Parent != null)
+        {
+            result.AddRange(Split(path.Parent));
+        }
+
+        result.Add(path);
+
+        return result;
    }
-}
+}
@@ -1,42 +1,36 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
-using LanguageExt;

-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeMediaCollectionRepository : IMediaCollectionRepository
 {
-    public class FakeMediaCollectionRepository : IMediaCollectionRepository
-    {
-        private readonly Map<int, List<MediaItem>> _data;
+    private readonly Map<int, List<MediaItem>> _data;

-        public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;
+    public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;

-        public Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id) =>
-            throw new NotSupportedException();
+    public Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id) =>
+        throw new NotSupportedException();

-        public Task<List<MediaItem>> GetItems(int id) => _data[id].ToList().AsTask();
-        public Task<List<MediaItem>> GetMultiCollectionItems(int id) => throw new NotSupportedException();
-        public Task<List<MediaItem>> GetSmartCollectionItems(int id) => throw new NotSupportedException();
+    public Task<List<MediaItem>> GetItems(int id) => _data[id].ToList().AsTask();
+    public Task<List<MediaItem>> GetMultiCollectionItems(int id) => throw new NotSupportedException();
+    public Task<List<MediaItem>> GetSmartCollectionItems(int id) => throw new NotSupportedException();

-        public Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id) =>
-            throw new NotSupportedException();
+    public Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id) =>
+        throw new NotSupportedException();

-        public Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId) =>
+        throw new NotSupportedException();

-        public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) => throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) => throw new NotSupportedException();

-        public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
+        throw new NotSupportedException();

-        public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
+        throw new NotSupportedException();

-        public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
-        public Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection) => Option<string>.None.AsTask();
-    }
-}
+    public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
+    public Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection) => Option<string>.None.AsTask();
+}
@@ -1,26 +1,24 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;

-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeMovieWithPath : MediaItemScanResult<Movie>
 {
-    public class FakeMovieWithPath : MediaItemScanResult<Movie>
-    {
-        public FakeMovieWithPath(string path)
-            : base(
-                new Movie
+    public FakeMovieWithPath(string path)
+        : base(
+            new Movie
+            {
+                MediaVersions = new List<MediaVersion>
                {
-                    MediaVersions = new List<MediaVersion>
+                    new()
                    {
-                        new()
+                        MediaFiles = new List<MediaFile>
                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
+                            new() { Path = path }
                        }
                    }
-                }) =>
-            IsAdded = true;
-    }
-}
+                }
+            }) =>
+        IsAdded = true;
+}
@@ -1,102 +1,97 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;

-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeTelevisionRepository : ITelevisionRepository
 {
-    public class FakeTelevisionRepository : ITelevisionRepository
-    {
-        public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
-        public Task<bool> AllSeasonsExist(List<int> seasonIds) => throw new NotSupportedException();
+    public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
+    public Task<bool> AllSeasonsExist(List<int> seasonIds) => throw new NotSupportedException();

-        public Task<bool> AllEpisodesExist(List<int> episodeIds) => throw new NotSupportedException();
+    public Task<bool> AllEpisodesExist(List<int> episodeIds) => throw new NotSupportedException();

-        public Task<List<Show>> GetAllShows() => throw new NotSupportedException();
+    public Task<List<Show>> GetAllShows() => throw new NotSupportedException();

-        public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();
+    public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();

-        public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
-        public Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids) => throw new NotSupportedException();

-        public Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids) => throw new NotSupportedException();

-        public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();
+    public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();

-        public Task<List<Season>> GetAllSeasons() => throw new NotSupportedException();
+    public Task<List<Season>> GetAllSeasons() => throw new NotSupportedException();

-        public Task<Option<Season>> GetSeason(int seasonId) => throw new NotSupportedException();
+    public Task<Option<Season>> GetSeason(int seasonId) => throw new NotSupportedException();

-        public Task<int> GetSeasonCount(int showId) => throw new NotSupportedException();
+    public Task<int> GetSeasonCount(int showId) => throw new NotSupportedException();

-        public Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize) =>
-            throw new NotSupportedException();
+    public Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize) =>
+        throw new NotSupportedException();

-        public Task<List<Episode>> GetSeasonItems(int seasonId) => throw new NotSupportedException();
+    public Task<List<Episode>> GetSeasonItems(int seasonId) => throw new NotSupportedException();

-        public Task<int> GetEpisodeCount(int seasonId) => throw new NotSupportedException();
+    public Task<int> GetEpisodeCount(int seasonId) => throw new NotSupportedException();

-        public Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize) =>
-            throw new NotSupportedException();
+    public Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize) =>
+        throw new NotSupportedException();

-        public Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata) =>
+        throw new NotSupportedException();

-        public Task<Either<BaseError, MediaItemScanResult<Show>>>
-            AddShow(int libraryPathId, string showFolder, ShowMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, MediaItemScanResult<Show>>>
+        AddShow(int libraryPathId, string showFolder, ShowMetadata metadata) =>
+        throw new NotSupportedException();

-        public Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber) =>
+        throw new NotSupportedException();

-        public Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path) =>
+        throw new NotSupportedException();

-        public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) => throw new NotSupportedException();

-        public Task<Unit> DeleteByPath(LibraryPath libraryPath, string path) => throw new NotSupportedException();
+    public Task<Unit> DeleteByPath(LibraryPath libraryPath, string path) => throw new NotSupportedException();

-        public Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath) => throw new NotSupportedException();

-        public Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();

-        public Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
-            PlexLibrary library,
-            PlexShow item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
+        PlexLibrary library,
+        PlexShow item) =>
+        throw new NotSupportedException();

-        public Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item) =>
+        throw new NotSupportedException();

-        public Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item) =>
+        throw new NotSupportedException();

-        public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
-        public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();
+    public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
+    public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();

-        public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
-        public Task<bool> AddActor(ShowMetadata metadata, Actor actor) => throw new NotSupportedException();
+    public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
+    public Task<bool> AddActor(ShowMetadata metadata, Actor actor) => throw new NotSupportedException();

-        public Task<bool> AddActor(EpisodeMetadata metadata, Actor actor) => throw new NotSupportedException();
+    public Task<bool> AddActor(EpisodeMetadata metadata, Actor actor) => throw new NotSupportedException();

-        public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
-            throw new NotSupportedException();
+    public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
+        throw new NotSupportedException();

-        public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
-            throw new NotSupportedException();
+    public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
+        throw new NotSupportedException();

-        public Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys) =>
-            throw new NotSupportedException();
+    public Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys) =>
+        throw new NotSupportedException();

-        public Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata) =>
+        throw new NotSupportedException();

-        public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) => throw new NotSupportedException();
+    public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) => throw new NotSupportedException();

-        public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) => throw new NotSupportedException();
-        public Task<Unit> UpdatePath(int mediaFileId, string path) => throw new NotSupportedException();
-    }
-}
+    public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) => throw new NotSupportedException();
+    public Task<Unit> UpdatePath(int mediaFileId, string path) => throw new NotSupportedException();
+}
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
@@ -1,211 +1,207 @@
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Jellyfin;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Jellyfin
+namespace ErsatzTV.Core.Tests.Jellyfin;
+
+[TestFixture]
+public class JellyfinPathReplacementServiceTests
 {
-    [TestFixture]
-    public class JellyfinPathReplacementServiceTests
+    [Test]
+    public async Task JellyfinWindows_To_EtvWindows()
    {
-        [Test]
-        public async Task JellyfinWindows_To_EtvWindows()
+        var replacements = new List<JellyfinPathReplacement>
        {
-            var replacements = new List<JellyfinPathReplacement>
+            new()
            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
+                Id = 1,
+                JellyfinPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };

-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());

-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);

-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);

-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");

-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux_UncPath()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
-                    LocalPath = @"/mnt/something else/Some Shared Folder/",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinLinux_To_EtvWindows()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinLinux_To_EtvLinux()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
    }
-}
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux_UncPath()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                LocalPath = @"/mnt/something else/Some Shared Folder/",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinLinux_To_EtvWindows()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinLinux_To_EtvLinux()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+}
@@ -1,121 +1,118 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Jellyfin;
 using FluentAssertions;
 using Flurl;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Jellyfin
+namespace ErsatzTV.Core.Tests.Jellyfin;
+
+public class JellyfinUrlTests
 {
-    public class JellyfinUrlTests
+    [Test]
+    public void Should_Work_Without_Trailing_Slash()
    {
-        [Test]
-        public void Should_Work_Without_Trailing_Slash()
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server";
+        var mediaSource = new JellyfinMediaSource
        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server";
-            var mediaSource = new JellyfinMediaSource
+            Connections = new List<JellyfinConnection>
            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
+                new() { Address = address }
+            }
+        };

-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);

-            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Port_Without_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server:1000";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Port_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server:1000/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Path_Prefix_Without_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/jellyfin";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Path_Prefix_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/jellyfin/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
-        }
+        url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
    }
-}
+
+    [Test]
+    public void Should_Work_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Port_Without_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server:1000";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Port_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server:1000/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Path_Prefix_Without_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/jellyfin";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Path_Prefix_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/jellyfin/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+    }
+}
@@ -1,122 +1,120 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
 using FluentAssertions;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Metadata
+namespace ErsatzTV.Core.Tests.Metadata;
+
+[TestFixture]
+public class FallbackMetadataProviderTests
 {
-    [TestFixture]
-    public class FallbackMetadataProviderTests
+    [SetUp]
+    public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider();
+
+    private FallbackMetadataProvider _fallbackMetadataProvider;
+
+    [Test]
+    [TestCase("Awesome Show - s01e02.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2.mkv", 1, 2)]
+    [TestCase("Awesome Show - s01e02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - s01e02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - S01E02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - s1e2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - S1E2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - s01e02 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase(
+        "Awesome Show (2021) - S01E02 - Description; More Description (1080p QUALITY codec GROUP).mkv",
+        1,
+        2)]
+    [TestCase(
+        "Awesome.Show.S01E02.Description.more.Description.QUAlity.codec.CODEC-GROUP.mkv",
+        1,
+        2)]
+    public void GetFallbackMetadata_ShouldHandleVariousFormats(string path, int season, int episode)
    {
-        [SetUp]
-        public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider();
-
-        private FallbackMetadataProvider _fallbackMetadataProvider;
-
-        [Test]
-        [TestCase("Awesome Show - s01e02.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2.mkv", 1, 2)]
-        [TestCase("Awesome Show - s01e02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - s01e02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - S01E02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - s1e2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - S1E2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - s01e02 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase(
-            "Awesome Show (2021) - S01E02 - Description; More Description (1080p QUALITY codec GROUP).mkv",
-            1,
-            2)]
-        [TestCase(
-            "Awesome.Show.S01E02.Description.more.Description.QUAlity.codec.CODEC-GROUP.mkv",
-            1,
-            2)]
-        public void GetFallbackMetadata_ShouldHandleVariousFormats(string path, int season, int episode)
-        {
-            List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Episode
+        List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Episode
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
                {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
+                    new()
                    {
-                        new()
+                        MediaFiles = new List<MediaFile>
                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
+                            new() { Path = path }
                        }
                    }
-                });
+                }
+            });

-            metadata.Count.Should().Be(1);
-            // TODO: how can we test season number? do we need to?
-            // metadata.Season.Should().Be(season);
-            metadata.Head().EpisodeNumber.Should().Be(episode);
-        }
-
-        [Test]
-        [TestCase("Awesome Show - s01e02-s01e03.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02-whatever-s01e03-whatever2.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02e03.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02-03.mkv", 1, 2, 3)]
-        public void GetFallbackMetadata_Should_Handle_Two_Episode_Formats(
-            string path,
-            int season,
-            int episode1,
-            int episode2)
-        {
-            List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Episode
-                {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
-                        }
-                    }
-                });
-
-            metadata.Count.Should().Be(2);
-            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
-        }
-
-        [Test]
-        [TestCase("Something (2021).mkv", "Something")]
-        [TestCase("Something Else (2021).mkv", "Something Else")]
-        public void GetFallbackMetadata_Should_Set_Proper_Movie_Title(string path, string expectedTitle)
-        {
-            MovieMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Movie
-                {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
-                        }
-                    }
-                });
-
-            metadata.Should().NotBeNull();
-            metadata.Title.Should().Be(expectedTitle);
-        }
+        metadata.Count.Should().Be(1);
+        // TODO: how can we test season number? do we need to?
+        // metadata.Season.Should().Be(season);
+        metadata.Head().EpisodeNumber.Should().Be(episode);
    }
-}
+
+    [Test]
+    [TestCase("Awesome Show - s01e02-s01e03.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02-whatever-s01e03-whatever2.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02e03.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02-03.mkv", 1, 2, 3)]
+    public void GetFallbackMetadata_Should_Handle_Two_Episode_Formats(
+        string path,
+        int season,
+        int episode1,
+        int episode2)
+    {
+        List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Episode
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        }
+                    }
+                }
+            });
+
+        metadata.Count.Should().Be(2);
+        metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
+    }
+
+    [Test]
+    [TestCase("Something (2021).mkv", "Something")]
+    [TestCase("Something Else (2021).mkv", "Something Else")]
+    public void GetFallbackMetadata_Should_Set_Proper_Movie_Title(string path, string expectedTitle)
+    {
+        MovieMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Movie
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        }
+                    }
+                }
+            });
+
+        metadata.Should().NotBeNull();
+        metadata.Title.Should().Be(expectedTitle);
+    }
+}
@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
@@ -9,29 +7,28 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Metadata
+namespace ErsatzTV.Core.Tests.Metadata;
+
+[TestFixture]
+public class LocalStatisticsProviderTests
 {
-    [TestFixture]
-    public class LocalStatisticsProviderTests
+    [Test]
+    // this needs to be a culture where '.' is a group separator
+    [SetCulture("it-IT")] 
+    public void Test()
    {
-        [Test]
-        // this needs to be a culture where '.' is a group separator
-        [SetCulture("it-IT")] 
-        public void Test()
-        {
-            var provider = new LocalStatisticsProvider(
-                new Mock<IMetadataRepository>().Object,
-                new Mock<ILocalFileSystem>().Object,
-                new Mock<ILogger<LocalStatisticsProvider>>().Object);
+        var provider = new LocalStatisticsProvider(
+            new Mock<IMetadataRepository>().Object,
+            new Mock<ILocalFileSystem>().Object,
+            new Mock<ILogger<LocalStatisticsProvider>>().Object);

-            var input = new LocalStatisticsProvider.FFprobe(
-                new LocalStatisticsProvider.FFprobeFormat("123.45", null),
-                new List<LocalStatisticsProvider.FFprobeStream>(),
-                new List<LocalStatisticsProvider.FFprobeChapter>());
+        var input = new LocalStatisticsProvider.FFprobe(
+            new LocalStatisticsProvider.FFprobeFormat("123.45", null),
+            new List<LocalStatisticsProvider.FFprobeStream>(),
+            new List<LocalStatisticsProvider.FFprobeChapter>());

-            MediaVersion result = provider.ProjectToMediaVersion("test", input);
+        MediaVersion result = provider.ProjectToMediaVersion("test", input);

-            result.Duration.Should().Be(TimeSpan.FromSeconds(123.45));
-        }
+        result.Duration.Should().Be(TimeSpan.FromSeconds(123.45));
    }
-}
+}
@@ -1,40 +1,36 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Metadata.Nfo;
 using FluentAssertions;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Metadata.Nfo
+namespace ErsatzTV.Core.Tests.Metadata.Nfo;
+
+[TestFixture]
+public class EpisodeNfoReaderTests
 {
-    [TestFixture]
-    public class EpisodeNfoReaderTests
+    [Test]
+    public async Task One()
    {
-        [Test]
-        public async Task One()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+    }

-        [Test]
-        public async Task Two()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Two()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <showtitle>show</showtitle>
@@ -49,61 +45,61 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
  <season>1</season>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(2);
-            result.All(nfo => nfo.ShowTitle == "show").Should().BeTrue();
-            result.All(nfo => nfo.Season == 1).Should().BeTrue();
-            result.Count(nfo => nfo.Title == "episode-one" && nfo.Episode == 1).Should().Be(1);
-            result.Count(nfo => nfo.Title == "episode-two" && nfo.Episode == 2).Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.All(nfo => nfo.ShowTitle == "show").Should().BeTrue();
+        result.All(nfo => nfo.Season == 1).Should().BeTrue();
+        result.Count(nfo => nfo.Title == "episode-one" && nfo.Episode == 1).Should().Be(1);
+        result.Count(nfo => nfo.Title == "episode-two" && nfo.Episode == 2).Should().Be(1);
+    }

-        [Test]
-        public async Task UniqueIds()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task UniqueIds()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <uniqueid default=""true"" type=""tvdb"">12345</uniqueid>
  <uniqueid default=""false"" type=""imdb"">tt54321</uniqueid>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-            result[0].UniqueIds.Count.Should().Be(2);
-            result[0].UniqueIds.Count(id => id.Default && id.Type == "tvdb" && id.Guid == "12345").Should().Be(1);
-            result[0].UniqueIds.Count(id => !id.Default && id.Type == "imdb" && id.Guid == "tt54321").Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+        result[0].UniqueIds.Count.Should().Be(2);
+        result[0].UniqueIds.Count(id => id.Default && id.Type == "tvdb" && id.Guid == "12345").Should().Be(1);
+        result[0].UniqueIds.Count(id => !id.Default && id.Type == "imdb" && id.Guid == "tt54321").Should().Be(1);
+    }

-        [Test]
-        public async Task No_ContentRating()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task No_ContentRating()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <mpaa/>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-            result[0].ContentRating.Should().BeNullOrEmpty();
-        }
+        result.Count.Should().Be(1);
+        result[0].ContentRating.Should().BeNullOrEmpty();
+    }

-        [Test]
-        public async Task ContentRating()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task ContentRating()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <mpaa>US:Something</mpaa>
@@ -112,56 +108,56 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
  <mpaa>US:Something / US:SomethingElse</mpaa>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.ContentRating == "US:Something").Should().Be(1);
-            result.Count(nfo => nfo.ContentRating == "US:Something / US:SomethingElse").Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.ContentRating == "US:Something").Should().Be(1);
+        result.Count(nfo => nfo.ContentRating == "US:Something / US:SomethingElse").Should().Be(1);
+    }

-        [Test]
-        public async Task No_Plot()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task No_Plot()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <plot/>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-            result[0].Plot.Should().BeNullOrEmpty();
-        }
+        result.Count.Should().Be(1);
+        result[0].Plot.Should().BeNullOrEmpty();
+    }

-        [Test]
-        public async Task Plot()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Plot()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <plot>Some Plot</plot>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-            result[0].Plot.Should().Be("Some Plot");
-        }
+        result.Count.Should().Be(1);
+        result[0].Plot.Should().Be("Some Plot");
+    }

-        [Test]
-        public async Task Actors()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Actors()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <actor>
@@ -176,23 +172,23 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
  </actor>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(1);
-            result[0].Actors.Count.Should().Be(2);
-            result[0].Actors.Count(a => a.Name == "Name 1" && a.Role == "Role 1" && a.Thumb == "Thumb 1")
-                .Should().Be(1);
-            result[0].Actors.Count(a => a.Name == "Name 2" && a.Role == "Role 2" && a.Thumb == "Thumb 2")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+        result[0].Actors.Count.Should().Be(2);
+        result[0].Actors.Count(a => a.Name == "Name 1" && a.Role == "Role 1" && a.Thumb == "Thumb 1")
+            .Should().Be(1);
+        result[0].Actors.Count(a => a.Name == "Name 2" && a.Role == "Role 2" && a.Thumb == "Thumb 2")
+            .Should().Be(1);
+    }

-        [Test]
-        public async Task Writers()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Writers()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <credits>Writer 1</credits>
@@ -202,21 +198,21 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
  <credits>Writer 3</credits>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.Writers.Count == 1 && nfo.Writers[0] == "Writer 1").Should().Be(1);
-            result.Count(nfo => nfo.Writers.Count == 2 && nfo.Writers[0] == "Writer 2" && nfo.Writers[1] == "Writer 3")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.Writers.Count == 1 && nfo.Writers[0] == "Writer 1").Should().Be(1);
+        result.Count(nfo => nfo.Writers.Count == 2 && nfo.Writers[0] == "Writer 2" && nfo.Writers[1] == "Writer 3")
+            .Should().Be(1);
+    }

-        [Test]
-        public async Task Directors()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Directors()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
  <director>Director 1</director>
@@ -226,14 +222,13 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
  <director>Director 3</director>
 </episodedetails>"));

-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);

-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.Directors.Count == 1 && nfo.Directors[0] == "Director 1").Should().Be(1);
-            result.Count(
-                    nfo => nfo.Directors.Count == 2 && nfo.Directors[0] == "Director 2" &&
-                           nfo.Directors[1] == "Director 3")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.Directors.Count == 1 && nfo.Directors[0] == "Director 1").Should().Be(1);
+        result.Count(
+                nfo => nfo.Directors.Count == 2 && nfo.Directors[0] == "Director 2" &&
+                       nfo.Directors[1] == "Director 3")
+            .Should().Be(1);
    }
-}
+}
@@ -1,211 +1,207 @@
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Plex;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Plex
+namespace ErsatzTV.Core.Tests.Plex;
+
+[TestFixture]
+public class PlexPathReplacementServiceTests
 {
-    [TestFixture]
-    public class PlexPathReplacementServiceTests
+    [Test]
+    public async Task PlexWindows_To_EtvWindows()
    {
-        [Test]
-        public async Task PlexWindows_To_EtvWindows()
+        var replacements = new List<PlexPathReplacement>
        {
-            var replacements = new List<PlexPathReplacement>
+            new()
            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
+                Id = 1,
+                PlexPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };

-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());

-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);

-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);

-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");

-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux_UncPath()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux_UncPathWithTrailingSlash()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder\",
-                    LocalPath = @"/mnt/something else/Some Shared Folder/",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexLinux_To_EtvWindows()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexLinux_To_EtvLinux()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
    }
-}
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux_UncPath()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux_UncPathWithTrailingSlash()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                LocalPath = @"/mnt/something else/Some Shared Folder/",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexLinux_To_EtvWindows()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexLinux_To_EtvLinux()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+}
@@ -1,92 +1,87 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ChronologicalContentTests
 {
-    [TestFixture]
-    public class ChronologicalContentTests
+    [Test]
+    public void Episodes_Should_Sort_By_Aired()
    {
-        [Test]
-        public void Episodes_Should_Sort_By_Aired()
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 1; i <= 10; i++)
        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 1; i <= 10; i++)
-            {
-                chronologicalContent.Current.IsSome.Should().BeTrue();
-                chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                chronologicalContent.MoveNext();
-            }
+            chronologicalContent.Current.IsSome.Should().BeTrue();
+            chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            chronologicalContent.MoveNext();
        }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                chronologicalContent.State.Index.Should().Be(i % 10);
-                chronologicalContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5 };
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 6; i <= 10; i++)
-            {
-                chronologicalContent.Current.IsSome.Should().BeTrue();
-                chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                chronologicalContent.State.Index.Should().Be(i - 1);
-                chronologicalContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Should_Reset_When_Invalid()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10 };
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            chronologicalContent.State.Index.Should().Be(0);
-            chronologicalContent.State.Seed.Should().Be(0);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
    }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            chronologicalContent.State.Index.Should().Be(i % 10);
+            chronologicalContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5 };
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 6; i <= 10; i++)
+        {
+            chronologicalContent.Current.IsSome.Should().BeTrue();
+            chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            chronologicalContent.State.Index.Should().Be(i - 1);
+            chronologicalContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Should_Reset_When_Invalid()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10 };
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        chronologicalContent.State.Index.Should().Be(0);
+        chronologicalContent.State.Seed.Should().Be(0);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
@@ -1,100 +1,95 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public class CustomOrderContentTests
 {
-    public class CustomOrderContentTests
+    [Test]
+    public void MediaItems_Should_Sort_By_CustomOrder()
    {
-        [Test]
-        public void MediaItems_Should_Sort_By_CustomOrder()
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 10; i >= 1; i--)
        {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 10; i >= 1; i--)
-            {
-                customOrderContent.Current.IsSome.Should().BeTrue();
-                customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                customOrderContent.MoveNext();
-            }
+            customOrderContent.Current.IsSome.Should().BeTrue();
+            customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            customOrderContent.MoveNext();
        }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                customOrderContent.State.Index.Should().Be(i % 10);
-                customOrderContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5 };
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 5; i >= 1; i--)
-            {
-                customOrderContent.Current.IsSome.Should().BeTrue();
-                customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                customOrderContent.State.Index.Should().Be(5 - i + 5); // 5 through 10
-                customOrderContent.MoveNext();
-            }
-        }
-
-        private static Collection CreateCollection(int episodeCount)
-        {
-            var collection = new Collection { CollectionItems = new List<CollectionItem>() };
-
-            for (var i = 1; i <= episodeCount; i++)
-            {
-                collection.CollectionItems.Add(
-                    new CollectionItem
-                    {
-                        MediaItemId = i,
-                        // reverse order
-                        CustomIndex = episodeCount - i
-                    });
-            }
-
-            return collection;
-        }
-
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
    }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            customOrderContent.State.Index.Should().Be(i % 10);
+            customOrderContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5 };
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 5; i >= 1; i--)
+        {
+            customOrderContent.Current.IsSome.Should().BeTrue();
+            customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            customOrderContent.State.Index.Should().Be(5 - i + 5); // 5 through 10
+            customOrderContent.MoveNext();
+        }
+    }
+
+    private static Collection CreateCollection(int episodeCount)
+    {
+        var collection = new Collection { CollectionItems = new List<CollectionItem>() };
+
+        for (var i = 1; i <= episodeCount; i++)
+        {
+            collection.CollectionItems.Add(
+                new CollectionItem
+                {
+                    MediaItemId = i,
+                    // reverse order
+                    CustomIndex = episodeCount - i
+                });
+        }
+
+        return collection;
+    }
+
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
@@ -1,337 +1,333 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public class MultiPartEpisodeGrouperTests
 {
-    public class MultiPartEpisodeGrouperTests
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (1)", "Episode 3 (2)", "Episode 4")]
+    [TestCase("Episode 1 - More", "Episode 2 (1) - Title", "Episode 3 (2) - After", "Episode 4 - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 1", "Episode 3 Part 2", "Episode 4")]
+    [TestCase("Episode 1", "Episode 2 (Part 1)", "Episode 3 (Part 2)", "Episode 4")]
+    public void NotGrouped_Grouped_NotGrouped(string one, string two, string three, string four)
    {
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (1)", "Episode 3 (2)", "Episode 4")]
-        [TestCase("Episode 1 - More", "Episode 2 (1) - Title", "Episode 3 (2) - After", "Episode 4 - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 1", "Episode 3 Part 2", "Episode 4")]
-        [TestCase("Episode 1", "Episode 2 (Part 1)", "Episode 3 (Part 2)", "Episode 4")]
-        public void NotGrouped_Grouped_NotGrouped(string one, string two, string three, string four)
+        var mediaItems = new List<MediaItem>
        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };

-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);

-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 - Part 2", "Episode 3")]
-        [TestCase("Episode 1 Part 1", "Episode 2 (2) - More", "Episode 3 - After")]
-        [TestCase("Episode 1 Part 1", "Episode 2 (II)", "Episode 3")]
-        [TestCase("Episode 1 Part One", "Episode 2 (II)", "Episode 3")]
-        [TestCase("Episode 1 (1)", "Episode 2 (Part 2)", "Episode 3")]
-        public void MixedNaming_Group(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (5)", "Episode 2 - (6)", "Episode 3")]
-        [TestCase("Episode 1 Part 5", "Episode 2 Part 6", "Episode 3 - After")]
-        [TestCase("Episode 1 Part (V)", "Episode 2 (VI)", "Episode 3")]
-        [TestCase("Episode 1 (Part 5)", "Episode 2 (Part 6)", "Episode 3")]
-        public void Only_Later_Parts(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3")]
-        [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 - After")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3")]
-        public void Grouped_NotGrouped(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3", "Episode 4 (1)", "Episode 5 (2)")]
-        [TestCase(
-            "Episode 1 (1) - More",
-            "Episode 2 (2) - Title",
-            "Episode 3 - After",
-            "Episode 4 (1) - Dash",
-            "Episode 5 (2) - Again")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3", "Episode 4 Part 1", "Episode 5 Part 2")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3", "Episode 4 (Part 1)", "Episode 5 (Part 2)")]
-        public void Grouped_NotGrouped_Grouped(string one, string two, string three, string four, string five)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4),
-                NamedEpisode(five, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-            ShouldHaveTwoItems(result, mediaItems[3], mediaItems[4]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
-        [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
-        public void Grouped_Grouped(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
-        [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
-        [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
-        public void Part2_Without_Part1(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (3)", "Episode 4")]
-        [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (3) - After", "Episode 4 - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 3", "Episode 4")]
-        [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 3)", "Episode 4")]
-        public void Part2And3_Without_Part1(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 3 (3)", "Episode 4", "Episode 5")]
-        [TestCase("Episode 1 (1) - More", "Episode 3 (3) - Title", "Episode 4 - After", "Episode 5 - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 3 Part 3", "Episode 4", "Episode 5")]
-        [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 3)", "Episode 4", "Episode 5")]
-        public void Skip_Part(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 3),
-                NamedEpisode(three, 1, 1, 4),
-                NamedEpisode(four, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(4);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 3 (1)", "Episode 4 (2)", "Episode 5")]
-        [TestCase("Episode 1 (1) - More", "Episode 3 (1) - Title", "Episode 4 (2) - After", "Episode 5 - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 3 Part 1", "Episode 4 Part 2", "Episode 5")]
-        [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 1)", "Episode 4 (Part 2)", "Episode 5")]
-        public void Repeat_Part(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 3),
-                NamedEpisode(three, 1, 1, 4),
-                NamedEpisode(four, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (1)", "S1 Episode 2 (2)", "S1 Episode 5")]
-        [TestCase(
-            "S1 Episode 1 (1) - More",
-            "S2 Episode 3 (1) - Title",
-            "S1 Episode 2 (2) - After",
-            "S1 Episode 5 - Dash")]
-        [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 1", "S1 Episode 2 Part 2", "S1 Episode 5")]
-        [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 1)", "S1 Episode 2 (Part 2)", "S1 Episode 5")]
-        public void Mixed_Shows_Chronologically(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
-                NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
-                NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
-                NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (2)", "S1 Episode 2 (3)", "S1 Episode 5")]
-        [TestCase(
-            "S1 Episode 1 (1) - More",
-            "S2 Episode 3 (2) - Title",
-            "S1 Episode 2 (3) - After",
-            "S1 Episode 5 - Dash")]
-        [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 2", "S1 Episode 2 Part 3", "S1 Episode 5")]
-        [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 2)", "S1 Episode 2 (Part 3)", "S1 Episode 5")]
-        public void Mixed_Shows_Chronologically_Crossover(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
-                NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
-                NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
-                NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, true);
-
-            result.Count.Should().Be(2);
-            ShouldHaveMultipleItems(result, mediaItems[0], new List<MediaItem> { mediaItems[1], mediaItems[2] });
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        private static Episode NamedEpisode(
-            string title,
-            int showId,
-            int season,
-            int episode,
-            DateTime? releaseDate = null) =>
-            new()
-            {
-                EpisodeMetadata = new List<EpisodeMetadata>
-                {
-                    new() { Title = title, ReleaseDate = releaseDate, EpisodeNumber = episode }
-                },
-                Season = new Season
-                {
-                    SeasonNumber = season,
-                    Show = new Show { Id = showId },
-                    ShowId = showId
-                }
-            };
-
-        private static void ShouldHaveOneItem(IEnumerable<GroupedMediaItem> result, MediaItem item) =>
-            result.Filter(g => g.First == item && Optional(g.Additional).Flatten().HeadOrNone() == None)
-                .Should().HaveCount(1);
-
-        private static void ShouldHaveTwoItems(
-            IEnumerable<GroupedMediaItem> result,
-            MediaItem first,
-            MediaItem additional) =>
-            result.Filter(g => g.First == first && Optional(g.Additional).Flatten().HeadOrNone() == Some(additional))
-                .Should().HaveCount(1);
-
-        private static void ShouldHaveMultipleItems(
-            IEnumerable<GroupedMediaItem> result,
-            MediaItem first,
-            List<MediaItem> additional) =>
-            result.Filter(
-                    g => g.First == first && g.Additional != null && g.Additional.Count == additional.Count &&
-                         additional.ForAll(g.Additional.Contains))
-                .Should().HaveCount(1);
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
    }
-}
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 - Part 2", "Episode 3")]
+    [TestCase("Episode 1 Part 1", "Episode 2 (2) - More", "Episode 3 - After")]
+    [TestCase("Episode 1 Part 1", "Episode 2 (II)", "Episode 3")]
+    [TestCase("Episode 1 Part One", "Episode 2 (II)", "Episode 3")]
+    [TestCase("Episode 1 (1)", "Episode 2 (Part 2)", "Episode 3")]
+    public void MixedNaming_Group(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (5)", "Episode 2 - (6)", "Episode 3")]
+    [TestCase("Episode 1 Part 5", "Episode 2 Part 6", "Episode 3 - After")]
+    [TestCase("Episode 1 Part (V)", "Episode 2 (VI)", "Episode 3")]
+    [TestCase("Episode 1 (Part 5)", "Episode 2 (Part 6)", "Episode 3")]
+    public void Only_Later_Parts(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3")]
+    [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 - After")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3")]
+    public void Grouped_NotGrouped(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3", "Episode 4 (1)", "Episode 5 (2)")]
+    [TestCase(
+        "Episode 1 (1) - More",
+        "Episode 2 (2) - Title",
+        "Episode 3 - After",
+        "Episode 4 (1) - Dash",
+        "Episode 5 (2) - Again")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3", "Episode 4 Part 1", "Episode 5 Part 2")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3", "Episode 4 (Part 1)", "Episode 5 (Part 2)")]
+    public void Grouped_NotGrouped_Grouped(string one, string two, string three, string four, string five)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4),
+            NamedEpisode(five, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+        ShouldHaveTwoItems(result, mediaItems[3], mediaItems[4]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
+    [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
+    public void Grouped_Grouped(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
+    [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
+    [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
+    public void Part2_Without_Part1(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (3)", "Episode 4")]
+    [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (3) - After", "Episode 4 - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 3", "Episode 4")]
+    [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 3)", "Episode 4")]
+    public void Part2And3_Without_Part1(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 3 (3)", "Episode 4", "Episode 5")]
+    [TestCase("Episode 1 (1) - More", "Episode 3 (3) - Title", "Episode 4 - After", "Episode 5 - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 3 Part 3", "Episode 4", "Episode 5")]
+    [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 3)", "Episode 4", "Episode 5")]
+    public void Skip_Part(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 3),
+            NamedEpisode(three, 1, 1, 4),
+            NamedEpisode(four, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(4);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 3 (1)", "Episode 4 (2)", "Episode 5")]
+    [TestCase("Episode 1 (1) - More", "Episode 3 (1) - Title", "Episode 4 (2) - After", "Episode 5 - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 3 Part 1", "Episode 4 Part 2", "Episode 5")]
+    [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 1)", "Episode 4 (Part 2)", "Episode 5")]
+    public void Repeat_Part(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 3),
+            NamedEpisode(three, 1, 1, 4),
+            NamedEpisode(four, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (1)", "S1 Episode 2 (2)", "S1 Episode 5")]
+    [TestCase(
+        "S1 Episode 1 (1) - More",
+        "S2 Episode 3 (1) - Title",
+        "S1 Episode 2 (2) - After",
+        "S1 Episode 5 - Dash")]
+    [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 1", "S1 Episode 2 Part 2", "S1 Episode 5")]
+    [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 1)", "S1 Episode 2 (Part 2)", "S1 Episode 5")]
+    public void Mixed_Shows_Chronologically(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
+            NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
+            NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
+            NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (2)", "S1 Episode 2 (3)", "S1 Episode 5")]
+    [TestCase(
+        "S1 Episode 1 (1) - More",
+        "S2 Episode 3 (2) - Title",
+        "S1 Episode 2 (3) - After",
+        "S1 Episode 5 - Dash")]
+    [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 2", "S1 Episode 2 Part 3", "S1 Episode 5")]
+    [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 2)", "S1 Episode 2 (Part 3)", "S1 Episode 5")]
+    public void Mixed_Shows_Chronologically_Crossover(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
+            NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
+            NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
+            NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, true);
+
+        result.Count.Should().Be(2);
+        ShouldHaveMultipleItems(result, mediaItems[0], new List<MediaItem> { mediaItems[1], mediaItems[2] });
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    private static Episode NamedEpisode(
+        string title,
+        int showId,
+        int season,
+        int episode,
+        DateTime? releaseDate = null) =>
+        new()
+        {
+            EpisodeMetadata = new List<EpisodeMetadata>
+            {
+                new() { Title = title, ReleaseDate = releaseDate, EpisodeNumber = episode }
+            },
+            Season = new Season
+            {
+                SeasonNumber = season,
+                Show = new Show { Id = showId },
+                ShowId = showId
+            }
+        };
+
+    private static void ShouldHaveOneItem(IEnumerable<GroupedMediaItem> result, MediaItem item) =>
+        result.Filter(g => g.First == item && Optional(g.Additional).Flatten().HeadOrNone() == None)
+            .Should().HaveCount(1);
+
+    private static void ShouldHaveTwoItems(
+        IEnumerable<GroupedMediaItem> result,
+        MediaItem first,
+        MediaItem additional) =>
+        result.Filter(g => g.First == first && Optional(g.Additional).Flatten().HeadOrNone() == Some(additional))
+            .Should().HaveCount(1);
+
+    private static void ShouldHaveMultipleItems(
+        IEnumerable<GroupedMediaItem> result,
+        MediaItem first,
+        List<MediaItem> additional) =>
+        result.Filter(
+                g => g.First == first && g.Additional != null && g.Additional.Count == additional.Count &&
+                     additional.ForAll(g.Additional.Contains))
+            .Should().HaveCount(1);
+}
@@ -1,205 +1,202 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+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
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerBaseTests
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerBaseTests
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Not_Touch_Enumerator()
    {
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Not_Touch_Enumerator()
+        var collection = new Collection
        {
-            var collection = new Collection
-            {
-                Id = 1,
-                Name = "Filler Items",
-                MediaItems = new List<MediaItem>()
-            };
+            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);
+        for (var i = 0; i < 5; i++)
+        {
+            collection.MediaItems.Add(TestMovie(i + 1, TimeSpan.FromHours(i + 1), new DateTime(2020, 2, i + 1)));
        }

-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_15()
+        var fillerPreset = new FillerPreset
        {
-            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>());
+            FillerKind = FillerKind.PreRoll,
+            FillerMode = FillerMode.Count,
+            Count = 3,
+            Collection = collection,
+            CollectionId = collection.Id
+        };

-            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>());
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collection.MediaItems,
+            new CollectionEnumeratorState { Index = 0, Seed = 1 });

-            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>
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>
                {
-                    new() { Duration = duration }
-                }
-            };
+                    { 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 }
+            }
+        };
+}
@@ -1,107 +1,102 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class RandomizedContentTests
 {
-    [TestFixture]
-    public class RandomizedContentTests
+    private const int KnownSeed = 22295;
+
+    private readonly List<int> _expected = new()
    {
-        private const int KnownSeed = 22295;
+        5, 7, 7, 8, 6, 7, 8, 9, 10, 7, 5, 1, 7, 2, 5, 6, 1, 4, 5, 6, 4, 5, 1, 6, 5, 7, 1, 3, 9, 9, 9, 3,
+        3, 2, 3, 4, 5, 6, 9, 3, 6, 9, 7, 1, 2, 10, 3, 8, 3, 8, 8, 3, 1, 5, 4, 3, 6, 4, 6, 2, 9, 8, 3, 1, 8, 5,
+        1, 8, 2, 1, 1, 5, 5, 5, 3, 5, 8, 10, 4, 8, 7, 3, 3, 4, 4, 9, 2, 8, 8, 10, 8, 4, 3, 10, 7, 8, 9, 9
+    };

-        private readonly List<int> _expected = new()
+    [Test]
+    public void Episodes_Should_Randomize()
+    {
+        List<MediaItem> contents = Episodes(10);
+
+        var state = new CollectionEnumeratorState();
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
        {
-            5, 7, 7, 8, 6, 7, 8, 9, 10, 7, 5, 1, 7, 2, 5, 6, 1, 4, 5, 6, 4, 5, 1, 6, 5, 7, 1, 3, 9, 9, 9, 3,
-            3, 2, 3, 4, 5, 6, 9, 3, 6, 9, 7, 1, 2, 10, 3, 8, 3, 8, 8, 3, 1, 5, 4, 3, 6, 4, 6, 2, 9, 8, 3, 1, 8, 5,
-            1, 8, 2, 1, 1, 5, 5, 5, 3, 5, 8, 10, 4, 8, 7, 3, 3, 4, 4, 9, 2, 8, 8, 10, 8, 4, 3, 10, 7, 8, 9, 9
-        };
+            randomizedContent.Current.IsSome.Should().BeTrue();
+            randomizedContent.Current.Do(c => list.Add(c.Id));

-        [Test]
-        public void Episodes_Should_Randomize()
-        {
-            List<MediaItem> contents = Episodes(10);
-
-            var state = new CollectionEnumeratorState();
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
-            {
-                randomizedContent.Current.IsSome.Should().BeTrue();
-                randomizedContent.Current.Do(c => list.Add(c.Id));
-
-                randomizedContent.MoveNext();
-            }
-
-            list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-            list.Should().NotEqual(new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 });
+            randomizedContent.MoveNext();
        }

-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            for (var i = 1; i <= 10; i++)
-            {
-                randomizedContent.State.Index.Should().Be(i);
-
-                randomizedContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5, Seed = KnownSeed };
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            for (var i = 6; i <= 99; i++)
-            {
-                randomizedContent.Current.IsSome.Should().BeTrue();
-                // this test data setup/expectation is confusing
-                randomizedContent.Current.Map(c => c.Id).IfNone(-1).Should().Be(_expected[i - 2]);
-                randomizedContent.State.Index.Should().Be(i);
-
-                randomizedContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Index_Should_Continue_Past_End_Of_Items()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10, Seed = KnownSeed };
-
-            var _ = new RandomizedMediaCollectionEnumerator(contents, state);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
+        list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+        list.Should().NotEqual(new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 });
    }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        for (var i = 1; i <= 10; i++)
+        {
+            randomizedContent.State.Index.Should().Be(i);
+
+            randomizedContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5, Seed = KnownSeed };
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        for (var i = 6; i <= 99; i++)
+        {
+            randomizedContent.Current.IsSome.Should().BeTrue();
+            // this test data setup/expectation is confusing
+            randomizedContent.Current.Map(c => c.Id).IfNone(-1).Should().Be(_expected[i - 2]);
+            randomizedContent.State.Index.Should().Be(i);
+
+            randomizedContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Index_Should_Continue_Past_End_Of_Items()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10, Seed = KnownSeed };
+
+        var _ = new RandomizedMediaCollectionEnumerator(contents, state);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
@@ -1,93 +1,89 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+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
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public abstract class SchedulerTestBase
 {
-    public abstract class SchedulerTestBase
-    {
-        protected static PlayoutBuilderState StartState(IScheduleItemsEnumerator scheduleItemsEnumerator) => new(
-            scheduleItemsEnumerator,
-            Prelude.None,
-            Prelude.None,
-            false,
-            false,
-            1,
-            new DateTimeOffset(new DateTime(2020, 10, 18, 0, 0, 0, DateTimeKind.Local)));
+    protected static PlayoutBuilderState StartState(IScheduleItemsEnumerator scheduleItemsEnumerator) => new(
+        scheduleItemsEnumerator,
+        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
+    protected virtual ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    {
+        StartTime = null
+    };
+
+    protected static DateTimeOffset HardStop(IScheduleItemsEnumerator scheduleItemsEnumerator) =>
+        StartState(scheduleItemsEnumerator).CurrentTime.AddHours(6);
+
+    protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+        ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator) =>
+        new()
        {
-            StartTime = null
+            { CollectionKey.ForScheduleItem(scheduleItem), enumerator }
        };

-        protected static DateTimeOffset HardStop(IScheduleItemsEnumerator scheduleItemsEnumerator) =>
-            StartState(scheduleItemsEnumerator).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)
+    protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+        ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
+        FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2,
+        FillerPreset fillerPreset2, IMediaCollectionEnumerator enumerator3) =>
+        new()
        {
-            var result = new Movie()
-            {
-                Id = id,
-                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
-                MediaVersions = new List<MediaVersion>
-                {
-                    new() { Duration = duration, Chapters = new List<MediaChapter>() }
-                }
-            };
+            { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
+            { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 },
+            { CollectionKey.ForFillerPreset(fillerPreset2), enumerator3 }
+        };

-            for (var i = 0; i < chapterCount; i++)
+    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>
            {
-                result.MediaVersions.Head().Chapters.Add(
-                    new MediaChapter
-                    {
-                        StartTime = TimeSpan.FromMilliseconds(i * duration.TotalMilliseconds / chapterCount),
-                        EndTime = TimeSpan.FromMilliseconds(i + 1 * duration.TotalMilliseconds / chapterCount)
-                    });
+                new() { Duration = duration, Chapters = new List<MediaChapter>() }
            }
+        };

-            return result;
+        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)
+                });
        }

-        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 }
-            };
+        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 }
+        };
+}
@@ -1,154 +1,149 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ShuffledContentTests
 {
-    [TestFixture]
-    public class ShuffledContentTests
+    // this seed will produce (shuffle) 1-10 in order
+    private const int MagicSeed = 670596;
+
+    [Test]
+    public void Episodes_Should_Not_Duplicate_When_Reshuffling()
    {
-        // this seed will produce (shuffle) 1-10 in order
-        private const int MagicSeed = 670596;
+        List<MediaItem> contents = Episodes(10);

-        [Test]
-        public void Episodes_Should_Not_Duplicate_When_Reshuffling()
+        // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
+        var state = new CollectionEnumeratorState { Seed = 8 };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 1000; i++)
        {
-            List<MediaItem> contents = Episodes(10);
-
-            // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
-            var state = new CollectionEnumeratorState { Seed = 8 };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 1000; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            for (var i = 0; i < list.Count - 1; i++)
-            {
-                if (list[i] == list[i + 1])
-                {
-                    Assert.Fail("List contains duplicate items");
-                }
-            }
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
        }

-        [Test]
-        [Timeout(2000)]
-        public void Duplicate_Check_Should_Ignore_Single_Item()
+        for (var i = 0; i < list.Count - 1; i++)
        {
-            List<MediaItem> contents = Episodes(1);
-
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
+            if (list[i] == list[i + 1])
            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            list.Should().Equal(1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
-        }
-
-        [Test]
-        public void Episodes_Should_Shuffle()
-        {
-            List<MediaItem> contents = Episodes(10);
-
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-            list.Should().BeEquivalentTo(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-        }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                shuffledContent.State.Index.Should().Be(i);
-                shuffledContent.MoveNext();
+                Assert.Fail("List contains duplicate items");
            }
        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5, Seed = MagicSeed };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            for (var i = 6; i <= 10; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                shuffledContent.State.Index.Should().Be(i - 1);
-                shuffledContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Should_Reset_When_Invalid()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10, Seed = MagicSeed };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            shuffledContent.State.Index.Should().Be(0);
-            shuffledContent.State.Seed.Should().NotBe(MagicSeed);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
    }
-}
+
+    [Test]
+    [Timeout(2000)]
+    public void Duplicate_Check_Should_Ignore_Single_Item()
+    {
+        List<MediaItem> contents = Episodes(1);
+
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
+        }
+
+        list.Should().Equal(1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+    }
+
+    [Test]
+    public void Episodes_Should_Shuffle()
+    {
+        List<MediaItem> contents = Episodes(10);
+
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
+        }
+
+        list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+        list.Should().BeEquivalentTo(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+    }
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            shuffledContent.State.Index.Should().Be(i);
+            shuffledContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5, Seed = MagicSeed };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        for (var i = 6; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            shuffledContent.State.Index.Should().Be(i - 1);
+            shuffledContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Should_Reset_When_Invalid()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10, Seed = MagicSeed };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        shuffledContent.State.Index.Should().Be(0);
+        shuffledContent.State.Seed.Should().NotBe(MagicSeed);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
@@ -1,90 +1,87 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using NUnit.Framework;

-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ShuffledMediaCollectionEnumeratorTests
 {
-    [TestFixture]
-    public class ShuffledMediaCollectionEnumeratorTests
+    private readonly List<GroupedMediaItem> _mediaItems = new()
    {
-        private readonly List<GroupedMediaItem> _mediaItems = new()
-        {
-            new GroupedMediaItem(new MediaItem { Id = 1 }, new List<MediaItem>()),
-            new GroupedMediaItem(new MediaItem { Id = 2 }, new List<MediaItem>()),
-            new GroupedMediaItem(new MediaItem { Id = 3 }, new List<MediaItem>())
-        };
+        new GroupedMediaItem(new MediaItem { Id = 1 }, new List<MediaItem>()),
+        new GroupedMediaItem(new MediaItem { Id = 2 }, new List<MediaItem>()),
+        new GroupedMediaItem(new MediaItem { Id = 3 }, new List<MediaItem>())
+    };
        
-        [Test]
-        public void Peek_Zero_Should_Match_Current()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+    [Test]
+    public void Peek_Zero_Should_Match_Current()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);

-            Option<MediaItem> peek = enumerator.Peek(0);
-            Option<MediaItem> current = enumerator.Current;
+        Option<MediaItem> peek = enumerator.Peek(0);
+        Option<MediaItem> current = enumerator.Current;

-            peek.IsSome.Should().BeTrue();
-            current.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(1);
-            current.ValueUnsafe().Id.Should().Be(1);
-        }
-        
-        [Test]
-        public void Peek_One_Should_Match_Next()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(1);
-
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(2);
-            next.ValueUnsafe().Id.Should().Be(2);
-        }
-        
-        [Test]
-        public void Peek_Two_Should_Match_NextNext()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(2);
-
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(3);
-            next.ValueUnsafe().Id.Should().Be(3);
-        }
-        
-        [Test]
-        public void Peek_Three_Should_Match_NextNextNext()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(3);
-
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(2);
-            next.ValueUnsafe().Id.Should().Be(2);
-        }
+        peek.IsSome.Should().BeTrue();
+        current.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(1);
+        current.ValueUnsafe().Id.Should().Be(1);
    }
-}
+        
+    [Test]
+    public void Peek_One_Should_Match_Next()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(1);
+
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(2);
+        next.ValueUnsafe().Id.Should().Be(2);
+    }
+        
+    [Test]
+    public void Peek_Two_Should_Match_NextNext()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(2);
+
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(3);
+        next.ValueUnsafe().Id.Should().Be(3);
+    }
+        
+    [Test]
+    public void Peek_Three_Should_Match_NextNextNext()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(3);
+
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(2);
+        next.ValueUnsafe().Id.Should().Be(2);
+    }
+}