use full preferred language names in ui (#137)

* add library scan progress detail

* scan plex libraries on plex thread

.github/workflows/ci.yml

@@ -51,16 +51,17 @@ jobs:
           final="${tag2/prealpha/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
 
-      - name: Set up Docker Buildx
+      - name: Set up Docker Buildx Base
         uses: docker/setup-buildx-action@v1
+        id: builder-base
 
-      - name: Cache Docker layers
-        uses: actions/cache@v2.1.4
-        with:
-          path: /tmp/.buildx-cache
-          key: ${{ runner.os }}-buildx-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-buildx-
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
 
       - name: Login to DockerHub
         uses: docker/login-action@v1
@@ -71,6 +72,7 @@ jobs:
       - name: Build and push base
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-base.outputs.name }}
           context: .
           file: ./docker/Dockerfile
           push: true
@@ -79,12 +81,11 @@ jobs:
           tags: |
             jasongdove/ersatztv:develop
             jasongdove/ersatztv:${{ github.sha }}
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
 
       - name: Build and push nvidia
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
           context: .
           file: ./docker/nvidia/Dockerfile
           push: true
@@ -93,12 +94,11 @@ jobs:
           tags: |
             jasongdove/ersatztv:develop-nvidia
             jasongdove/ersatztv:${{ github.sha }}-nvidia
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
 
       - name: Build and push vaapi
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
           context: .
           file: ./docker/vaapi/Dockerfile
           push: true
@@ -107,5 +107,3 @@ jobs:
           tags: |
             jasongdove/ersatztv:develop-vaapi
             jasongdove/ersatztv:${{ github.sha }}-vaapi
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max

.github/workflows/release.yml

@@ -83,16 +83,17 @@ jobs:
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
           echo "DOCKER_TAG=${tag/-prealpha/}" >> $GITHUB_ENV
 
-      - name: Set up Docker Buildx
+      - name: Set up Docker Buildx Base
         uses: docker/setup-buildx-action@v1
+        id: builder-base
 
-      - name: Cache Docker layers
-        uses: actions/cache@v2.1.4
-        with:
-          path: /tmp/.buildx-cache
-          key: ${{ runner.os }}-buildx-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-buildx-
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
 
       - name: Login to DockerHub
         uses: docker/login-action@v1
@@ -103,6 +104,7 @@ jobs:
       - name: Build and push base
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-base.outputs.name }}
           context: .
           file: ./docker/Dockerfile
           push: true
@@ -111,12 +113,11 @@ jobs:
           tags: |
             jasongdove/ersatztv:latest
             jasongdove/ersatztv:${{ env.DOCKER_TAG }}
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
 
       - name: Build and push nvidia
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
           context: .
           file: ./docker/nvidia/Dockerfile
           push: true
@@ -125,12 +126,11 @@ jobs:
           tags: |
             jasongdove/ersatztv:latest-nvidia
             jasongdove/ersatztv:${{ env.DOCKER_TAG }}-nvidia
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
 
       - name: Build and push vaapi
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
           context: .
           file: ./docker/vaapi/Dockerfile
           push: true
@@ -139,5 +139,3 @@ jobs:
           tags: |
             jasongdove/ersatztv:latest-vaapi
             jasongdove/ersatztv:${{ env.DOCKER_TAG }}-vaapi
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max

.gitignore

@@ -40,3 +40,6 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+
+docker-compose.override.yml
+

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -4,9 +4,10 @@ namespace ErsatzTV.Application.Channels
 {
     public record ChannelViewModel(
         int Id,
-        int Number,
+        string Number,
         string Name,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -8,8 +8,9 @@ namespace ErsatzTV.Application.Channels.Commands
     public record CreateChannel
     (
         string Name,
-        int Number,
+        string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -8,6 +11,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Commands
 {
@@ -35,9 +39,10 @@ namespace ErsatzTV.Application.Channels.Commands
             _channelRepository.Add(c).Map(ProjectToViewModel);
 
         private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
-            (ValidateName(request), ValidateNumber(request), await FFmpegProfileMustExist(request))
+            (ValidateName(request), await ValidateNumber(request), await FFmpegProfileMustExist(request),
+                ValidatePreferredLanguage(request))
             .Apply(
-                (name, number, ffmpegProfileId) =>
+                (name, number, ffmpegProfileId, preferredLanguageCode) =>
                 {
                     var artwork = new List<Artwork>();
                     if (!string.IsNullOrWhiteSpace(request.Logo))
@@ -58,7 +63,8 @@ namespace ErsatzTV.Application.Channels.Commands
                         Number = number,
                         FFmpegProfileId = ffmpegProfileId,
                         StreamingMode = request.StreamingMode,
-                        Artwork = artwork
+                        Artwork = artwork,
+                        PreferredLanguageCode = preferredLanguageCode
                     };
                 });
 
@@ -66,9 +72,28 @@ namespace ErsatzTV.Application.Channels.Commands
             createChannel.NotEmpty(c => c.Name)
                 .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
-        // TODO: validate number does not exist?
-        private Validation<BaseError, int> ValidateNumber(CreateChannel createChannel) =>
-            createChannel.AtLeast(1)(c => c.Number);
+        private Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
+            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
+
+        private async Task<Validation<BaseError, string>> ValidateNumber(CreateChannel createChannel)
+        {
+            Option<Channel> maybeExistingChannel = await _channelRepository.GetByNumber(createChannel.Number);
+            return maybeExistingChannel.Match<Validation<BaseError, string>>(
+                _ => BaseError.New("Channel number must be unique"),
+                () =>
+                {
+                    if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
+                    {
+                        return createChannel.Number;
+                    }
+
+                    return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+                });
+        }
 
         private async Task<Validation<BaseError, int>> FFmpegProfileMustExist(CreateChannel createChannel) =>
             (await _ffmpegProfileRepository.Get(createChannel.FFmpegProfileId))

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -9,8 +9,9 @@ namespace ErsatzTV.Application.Channels.Commands
     (
         int ChannelId,
         string Name,
-        int Number,
+        string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -31,6 +33,7 @@ namespace ErsatzTV.Application.Channels.Commands
             c.Name = update.Name;
             c.Number = update.Number;
             c.FFmpegProfileId = update.FFmpegProfileId;
+            c.PreferredLanguageCode = update.PreferredLanguageCode;
 
             if (!string.IsNullOrWhiteSpace(update.Logo))
             {
@@ -64,8 +67,9 @@ namespace ErsatzTV.Application.Channels.Commands
         }
 
         private async Task<Validation<BaseError, Channel>> Validate(UpdateChannel request) =>
-            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request))
-            .Apply((channelToUpdate, _, _) => channelToUpdate);
+            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request),
+                ValidatePreferredLanguage(request))
+            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
 
         private Task<Validation<BaseError, Channel>> ChannelMustExist(UpdateChannel updateChannel) =>
             _channelRepository.Get(updateChannel.ChannelId)
@@ -75,16 +79,28 @@ namespace ErsatzTV.Application.Channels.Commands
             updateChannel.NotEmpty(c => c.Name)
                 .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
 
-        private async Task<Validation<BaseError, int>> ValidateNumber(UpdateChannel updateChannel)
+        private async Task<Validation<BaseError, string>> ValidateNumber(UpdateChannel updateChannel)
         {
             Option<Channel> match = await _channelRepository.GetByNumber(updateChannel.Number);
-            int matchId = match.Map(c => c.Id).IfNone(updateChannel.ChannelId);
+            int matchId = await match.Map(c => c.Id).IfNoneAsync(updateChannel.ChannelId);
             if (matchId == updateChannel.ChannelId)
             {
-                return updateChannel.AtLeast(1)(c => c.Number);
+                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+                {
+                    return updateChannel.Number;
+                }
+
+                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
             }
 
             return BaseError.New("Channel number must be unique");
         }
+
+        private Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
     }
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -13,6 +13,7 @@ namespace ErsatzTV.Application.Channels
                 channel.Name,
                 channel.FFmpegProfileId,
                 GetLogo(channel),
+                channel.PreferredLanguageCode,
                 channel.StreamingMode);
 
         private static string GetLogo(Channel channel) =>

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -3,9 +3,9 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Queries
 {
@@ -15,7 +15,7 @@ namespace ErsatzTV.Application.Channels.Queries
 
         public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll().Map(channels => channels.Map(ProjectToViewModel).ToList());
+        public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
+            Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
     }
 }

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -2,11 +2,20 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="MediatR" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -11,17 +11,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -43,19 +43,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     Transcode = request.Transcode,
                     HardwareAcceleration = request.HardwareAcceleration,
                     ResolutionId = resolutionId,
-                    NormalizeResolution = request.NormalizeResolution,
+                    NormalizeVideo = request.NormalizeVideo,
                     VideoCodec = request.VideoCodec,
-                    NormalizeVideoCodec = request.NormalizeVideoCodec,
                     VideoBitrate = request.VideoBitrate,
                     VideoBufferSize = request.VideoBufferSize,
                     AudioCodec = request.AudioCodec,
-                    NormalizeAudioCodec = request.NormalizeAudioCodec,
                     AudioBitrate = request.AudioBitrate,
                     AudioBufferSize = request.AudioBufferSize,
-                    AudioVolume = request.AudioVolume,
+                    NormalizeLoudness = request.NormalizeLoudness,
                     AudioChannels = request.AudioChannels,
                     AudioSampleRate = request.AudioSampleRate,
-                    NormalizeAudio = request.NormalizeAudio
+                    NormalizeAudio = request.NormalizeAudio,
+                    FrameRate = request.FrameRate
                 });
 
         private Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
@@ -63,7 +62,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => createFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
-            createFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(CreateFFmpegProfile createFFmpegProfile) =>
             (await _resolutionRepository.Get(createFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -12,17 +12,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -37,19 +37,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.Transcode = update.Transcode;
             p.HardwareAcceleration = update.HardwareAcceleration;
             p.ResolutionId = update.ResolutionId;
-            p.NormalizeResolution = update.NormalizeResolution;
+            p.NormalizeVideo = update.NormalizeVideo;
             p.VideoCodec = update.VideoCodec;
-            p.NormalizeVideoCodec = update.NormalizeVideoCodec;
             p.VideoBitrate = update.VideoBitrate;
             p.VideoBufferSize = update.VideoBufferSize;
             p.AudioCodec = update.AudioCodec;
-            p.NormalizeAudioCodec = update.NormalizeAudioCodec;
             p.AudioBitrate = update.AudioBitrate;
             p.AudioBufferSize = update.AudioBufferSize;
-            p.AudioVolume = update.AudioVolume;
+            p.NormalizeLoudness = update.NormalizeLoudness;
             p.AudioChannels = update.AudioChannels;
             p.AudioSampleRate = update.AudioSampleRate;
             p.NormalizeAudio = update.NormalizeAudio;
+            p.FrameRate = update.FrameRate;
             await _ffmpegProfileRepository.Update(p);
             return ProjectToViewModel(p);
         }
@@ -69,7 +68,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
-            updateFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(UpdateFFmpegProfile updateFFmpegProfile) =>
             (await _resolutionRepository.Get(updateFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs

@@ -1,6 +1,7 @@
-using MediatR;
+using ErsatzTV.Core;
+using LanguageExt;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
 {
-    public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : IRequest;
+    public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,70 +1,102 @@
-using System.Threading;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using MediatR;
-using Unit = MediatR.Unit;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
 {
-    public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings>
+    public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
     {
         private readonly IConfigElementRepository _configElementRepository;
+        private readonly ILocalFileSystem _localFileSystem;
 
-        public UpdateFFmpegSettingsHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<Unit> Handle(UpdateFFmpegSettings request, CancellationToken cancellationToken)
+        public UpdateFFmpegSettingsHandler(
+            IConfigElementRepository configElementRepository,
+            ILocalFileSystem localFileSystem)
         {
-            Option<ConfigElement> ffmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
-            Option<ConfigElement> ffprobePath = await _configElementRepository.Get(ConfigElementKey.FFprobePath);
-            Option<ConfigElement> defaultFFmpegProfileId =
-                await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId);
-
-            ffmpegPath.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFmpegPath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFmpegPath.Key, Value = request.Settings.FFmpegPath };
-                    _configElementRepository.Add(ce);
-                });
-
-            ffprobePath.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFprobePath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFprobePath.Key, Value = request.Settings.FFprobePath };
-                    _configElementRepository.Add(ce);
-                });
-
-            defaultFFmpegProfileId.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.DefaultFFmpegProfileId.ToString();
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                    {
-                        Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
-                        Value = request.Settings.DefaultFFmpegProfileId.ToString()
-                    };
-                    _configElementRepository.Add(ce);
-                });
-
-            return Unit.Value;
+            _configElementRepository = configElementRepository;
+            _localFileSystem = localFileSystem;
         }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateFFmpegSettings request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyUpdate(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
+            (await FFmpegMustExist(request), await FFprobeMustExist(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
+            ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
+
+        private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
+            ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
+
+        private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
+        {
+            if (!_localFileSystem.FileExists(path))
+            {
+                return BaseError.New($"{name} path does not exist");
+            }
+
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = path,
+                Arguments = "-version",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false
+            };
+
+            var test = new Process
+            {
+                StartInfo = startInfo
+            };
+
+            test.Start();
+            string output = await test.StandardOutput.ReadToEndAsync();
+            await test.WaitForExitAsync();
+            return test.ExitCode == 0 && output.Contains($"{name} version")
+                ? Unit.Default
+                : BaseError.New($"Unable to verify {name} version");
+        }
+
+        private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
+        {
+            await Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
+            await Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
+            await Upsert(ConfigElementKey.FFmpegDefaultProfileId, request.Settings.DefaultFFmpegProfileId.ToString());
+            await Upsert(ConfigElementKey.FFmpegSaveReports, request.Settings.SaveReports.ToString());
+
+            if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
+            {
+                Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
+            }
+
+            await Upsert(ConfigElementKey.FFmpegPreferredLanguageCode, request.Settings.PreferredLanguageCode);
+
+            return Unit.Default;
+        }
+
+        private Task Upsert(ConfigElementKey key, string value) =>
+            _configElementRepository.Get(key).Match(
+                ce =>
+                {
+                    ce.Value = value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = key.Key, Value = value };
+                    return _configElementRepository.Add(ce);
+                });
     }
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -10,17 +10,16 @@ namespace ErsatzTV.Application.FFmpegProfiles
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         ResolutionViewModel Resolution,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio);
+        bool NormalizeAudio,
+        string FrameRate);
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -5,5 +5,7 @@
         public string FFmpegPath { get; set; }
         public string FFprobePath { get; set; }
         public int DefaultFFmpegProfileId { get; set; }
+        public string PreferredLanguageCode { get; set; }
+        public bool SaveReports { get; set; }
     }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -13,19 +13,18 @@ namespace ErsatzTV.Application.FFmpegProfiles
                 profile.Transcode,
                 profile.HardwareAcceleration,
                 Project(profile.Resolution),
-                profile.NormalizeResolution,
+                profile.NormalizeVideo,
                 profile.VideoCodec,
-                profile.NormalizeVideoCodec,
                 profile.VideoBitrate,
                 profile.VideoBufferSize,
                 profile.AudioCodec,
-                profile.NormalizeAudioCodec,
                 profile.AudioBitrate,
                 profile.AudioBufferSize,
-                profile.AudioVolume,
+                profile.NormalizeLoudness,
                 profile.AudioChannels,
                 profile.AudioSampleRate,
-                profile.NormalizeAudio);
+                profile.NormalizeAudio,
+                profile.FrameRate);
 
         private static ResolutionViewModel Project(Resolution resolution) =>
             new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -22,12 +22,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
             Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath);
             Option<int> defaultFFmpegProfileId =
                 await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId);
+            Option<bool> saveReports =
+                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
+            Option<string> preferredLanguageCode =
+                await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
 
             return new FFmpegSettingsViewModel
             {
-                FFmpegPath = ffmpegPath.IfNone(string.Empty),
-                FFprobePath = ffprobePath.IfNone(string.Empty),
-                DefaultFFmpegProfileId = defaultFFmpegProfileId.IfNone(0)
+                FFmpegPath = await ffmpegPath.IfNoneAsync(string.Empty),
+                FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
+                DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
+                SaveReports = await saveReports.IfNoneAsync(false),
+                PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng")
             };
         }
     }

ErsatzTV.Application/Images/Queries/GetImageContentsHandler.cs

@@ -42,6 +42,7 @@ namespace ErsatzTV.Application.Images.Queries
                             ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
                             ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
                             ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
+                            ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
                             _ => FileSystemLayout.LegacyImageCacheFolder
                         };
 

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

@@ -1,8 +1,10 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using LanguageExt;
 
 namespace ErsatzTV.Application.Libraries.Commands
@@ -11,9 +13,13 @@ namespace ErsatzTV.Application.Libraries.Commands
         DeleteLocalLibraryPathHandler : MediatR.IRequestHandler<DeleteLocalLibraryPath, Either<BaseError, Unit>>
     {
         private readonly ILibraryRepository _libraryRepository;
+        private readonly ISearchIndex _searchIndex;
 
-        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository, ISearchIndex searchIndex)
+        {
             _libraryRepository = libraryRepository;
+            _searchIndex = searchIndex;
+        }
 
         public Task<Either<BaseError, Unit>> Handle(
             DeleteLocalLibraryPath request,
@@ -22,8 +28,13 @@ namespace ErsatzTV.Application.Libraries.Commands
                 .MapT(DoDeletion)
                 .Bind(t => t.ToEitherAsync());
 
-        private Task<Unit> DoDeletion(LibraryPath libraryPath) =>
-            _libraryRepository.DeleteLocalPath(libraryPath.Id).ToUnit();
+        private async Task<Unit> DoDeletion(LibraryPath libraryPath)
+        {
+            List<int> ids = await _libraryRepository.GetMediaIdsByLocalPath(libraryPath.Id);
+            await _searchIndex.RemoveItems(ids);
+            await _libraryRepository.DeleteLocalPath(libraryPath.Id);
+            return Unit.Default;
+        }
 
         private async Task<Validation<BaseError, LibraryPath>> MediaSourceMustExist(DeleteLocalLibraryPath request) =>
             (await _libraryRepository.GetPath(request.LocalLibraryPathId))

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -18,7 +18,11 @@ namespace ErsatzTV.Application.Libraries.Queries
 
         public Task<List<LibraryViewModel>> Handle(GetAllLibraries request, CancellationToken cancellationToken) =>
             _libraryRepository.GetAll()
-                .Map(list => list.Filter(ShouldIncludeLibrary).Map(ProjectToViewModel).ToList());
+                .Map(
+                    list => list.Filter(ShouldIncludeLibrary)
+                        .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
+                        .ThenBy(l => l.MediaKind)
+                        .Map(ProjectToViewModel).ToList());
 
         private static bool ShouldIncludeLibrary(Library library) =>
             library switch

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -7,5 +7,9 @@ namespace ErsatzTV.Application.MediaCards
         List<MovieCardViewModel> MovieCards,
         List<TelevisionShowCardViewModel> ShowCards,
         List<TelevisionSeasonCardViewModel> SeasonCards,
-        List<TelevisionEpisodeCardViewModel> EpisodeCards);
+        List<TelevisionEpisodeCardViewModel> EpisodeCards,
+        List<MusicVideoCardViewModel> MusicVideoCards)
+    {
+        public bool UseCustomPlaybackOrder { get; set; }
+    }
 }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -18,7 +18,7 @@ namespace ErsatzTV.Application.MediaCards
 
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(Season season) =>
             new(
-                season.Show.ShowMetadata.HeadOrNone().Map(m => m.Title).IfNone(string.Empty),
+                season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
                 season.Id,
                 season.SeasonNumber,
                 GetSeasonName(season.SeasonNumber),
@@ -32,12 +32,17 @@ namespace ErsatzTV.Application.MediaCards
             new(
                 episodeMetadata.EpisodeId,
                 episodeMetadata.ReleaseDate ?? DateTime.MinValue,
-                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Map(m => m.Title).IfNone(string.Empty),
+                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
+                    m => m.Title ?? string.Empty,
+                    () => string.Empty),
+                episodeMetadata.Episode.Season.ShowId,
+                episodeMetadata.Episode.SeasonId,
+                episodeMetadata.Episode.EpisodeNumber,
                 episodeMetadata.Title,
-                $"Episode {episodeMetadata.Episode.EpisodeNumber}",
-                episodeMetadata.Episode.EpisodeNumber.ToString(),
-                GetThumbnail(episodeMetadata),
-                episodeMetadata.Episode.EpisodeNumber.ToString());
+                episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
+                    em => em.Plot ?? string.Empty,
+                    () => string.Empty),
+                GetThumbnail(episodeMetadata));
 
         internal static MovieCardViewModel ProjectToViewModel(MovieMetadata movieMetadata) =>
             new(
@@ -47,15 +52,34 @@ namespace ErsatzTV.Application.MediaCards
                 movieMetadata.SortTitle,
                 GetPoster(movieMetadata));
 
+        internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
+            new(
+                musicVideoMetadata.MusicVideoId,
+                $"{musicVideoMetadata.Title} ({musicVideoMetadata.Artist})",
+                musicVideoMetadata.Year?.ToString(),
+                musicVideoMetadata.SortTitle,
+                GetThumbnail(musicVideoMetadata));
+
         internal static CollectionCardResultsViewModel
             ProjectToViewModel(Collection collection) =>
             new(
                 collection.Name,
-                collection.MediaItems.OfType<Movie>().Map(m => ProjectToViewModel(m.MovieMetadata.Head())).ToList(),
+                collection.MediaItems.OfType<Movie>().Map(
+                    m => ProjectToViewModel(m.MovieMetadata.Head()) with
+                    {
+                        CustomIndex = GetCustomIndex(collection, m.Id)
+                    }).ToList(),
                 collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
                 collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
-                    .ToList());
+                    .ToList(),
+                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
+                    .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
+
+        private static int GetCustomIndex(Collection collection, int mediaItemId) =>
+            Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
+                .Map(ci => ci.CustomIndex ?? 0)
+                .IfNone(0);
 
         internal static SearchCardResultsViewModel ProjectToSearchResults(List<MediaItem> items) =>
             new(

ErsatzTV.Application/MediaCards/MediaCardViewModel.cs

@@ -1,4 +1,4 @@
 namespace ErsatzTV.Application.MediaCards
 {
-    public record MediaCardViewModel(string Title, string Subtitle, string SortTitle, string Poster);
+    public record MediaCardViewModel(int MediaItemId, string Title, string Subtitle, string SortTitle, string Poster);
 }

ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

@@ -2,10 +2,12 @@
 {
     public record MovieCardViewModel
         (int MovieId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            MovieId,
             Title,
             Subtitle,
             SortTitle,
             Poster)
     {
+        public int CustomIndex { get; set; }
     }
 }

ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

@@ -0,0 +1,13 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MusicVideoCardViewModel
+        (int MusicVideoId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            MusicVideoId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster)
+    {
+        public int CustomIndex { get; set; }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -16,11 +16,11 @@ namespace ErsatzTV.Application.MediaCards.Queries
         public GetCollectionCardsHandler(IMediaCollectionRepository collectionRepository) =>
             _collectionRepository = collectionRepository;
 
-        public async Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
+        public Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
             GetCollectionCards request,
             CancellationToken cancellationToken) =>
-            (await _collectionRepository.GetCollectionWithItemsUntracked(request.Id))
-            .ToEither(BaseError.New("Unable to load collection"))
-            .Map(ProjectToViewModel);
+            _collectionRepository.GetCollectionWithItemsUntracked(request.Id)
+                .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
+                .MapT(ProjectToViewModel);
     }
 }

ErsatzTV.Application/MediaCards/Queries/GetMovieCards.cs

@@ -1,6 +0,0 @@
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetMovieCards(int PageNumber, int PageSize) : IRequest<MovieCardResultsViewModel>;
-}

ErsatzTV.Application/MediaCards/Queries/GetMovieCardsHandler.cs

@@ -1,30 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-using static ErsatzTV.Application.MediaCards.Mapper;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public class
-        GetMovieCardsHandler : IRequestHandler<GetMovieCards, MovieCardResultsViewModel>
-    {
-        private readonly IMovieRepository _movieRepository;
-
-        public GetMovieCardsHandler(IMovieRepository movieRepository) => _movieRepository = movieRepository;
-
-        public async Task<MovieCardResultsViewModel> Handle(GetMovieCards request, CancellationToken cancellationToken)
-        {
-            int count = await _movieRepository.GetMovieCount();
-
-            List<MovieCardViewModel> results = await _movieRepository
-                .GetPagedMovies(request.PageNumber, request.PageSize)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new MovieCardResultsViewModel(count, results);
-        }
-    }
-}

ErsatzTV.Application/MediaCards/Queries/GetSearchCards.cs

@@ -1,8 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetSearchCards(string Query) : IRequest<Either<BaseError, SearchCardResultsViewModel>>;
-}

ErsatzTV.Application/MediaCards/Queries/GetSearchCardsHandler.cs

@@ -1,25 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-using static ErsatzTV.Application.MediaCards.Mapper;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public class GetSearchCardsHandler : IRequestHandler<GetSearchCards, Either<BaseError, SearchCardResultsViewModel>>
-    {
-        private readonly ISearchRepository _searchRepository;
-
-        public GetSearchCardsHandler(ISearchRepository searchRepository) => _searchRepository = searchRepository;
-
-        public Task<Either<BaseError, SearchCardResultsViewModel>> Handle(
-            GetSearchCards request,
-            CancellationToken cancellationToken) =>
-            Try(_searchRepository.SearchMediaItems(request.Query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-    }
-}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionShowCards.cs

@@ -1,6 +0,0 @@
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetTelevisionShowCards(int PageNumber, int PageSize) : IRequest<TelevisionShowCardResultsViewModel>;
-}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionShowCardsHandler.cs

@@ -1,33 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-using static ErsatzTV.Application.MediaCards.Mapper;
-
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public class
-        GetTelevisionShowCardsHandler : IRequestHandler<GetTelevisionShowCards, TelevisionShowCardResultsViewModel>
-    {
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public GetTelevisionShowCardsHandler(ITelevisionRepository televisionRepository) =>
-            _televisionRepository = televisionRepository;
-
-        public async Task<TelevisionShowCardResultsViewModel> Handle(
-            GetTelevisionShowCards request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _televisionRepository.GetShowCount();
-
-            List<TelevisionShowCardViewModel> results = await _televisionRepository
-                .GetPagedShows(request.PageNumber, request.PageSize)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new TelevisionShowCardResultsViewModel(count, results);
-        }
-    }
-}

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -7,14 +7,16 @@ namespace ErsatzTV.Application.MediaCards
         int EpisodeId,
         DateTime Aired,
         string ShowTitle,
+        int ShowId,
+        int SeasonId,
+        int Episode,
         string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        string Placeholder) : MediaCardViewModel(
+        string Plot,
+        string Poster) : MediaCardViewModel(
+        EpisodeId,
         Title,
-        Subtitle,
-        SortTitle,
+        $"Episode {Episode}",
+        $"Episode {Episode}",
         Poster)
     {
     }

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -10,6 +10,7 @@
         string SortTitle,
         string Poster,
         string Placeholder) : MediaCardViewModel(
+        TelevisionSeasonId,
         Title,
         Subtitle,
         SortTitle,

ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -2,6 +2,7 @@
 {
     public record TelevisionShowCardViewModel
         (int TelevisionShowId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            TelevisionShowId,
             Title,
             Subtitle,
             SortTitle,

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddItemsToCollection
+    (
+        int CollectionId,
+        List<int> MovieIds,
+        List<int> ShowIds,
+        List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -0,0 +1,80 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddItemsToCollectionHandler : MediatR.IRequestHandler<AddItemsToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly IMovieRepository _movieRepository;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public AddItemsToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IMovieRepository movieRepository,
+            ITelevisionRepository televisionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _movieRepository = movieRepository;
+            _televisionRepository = televisionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddItemsToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddItemsRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddItemsRequest(AddItemsToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItems(
+                request.CollectionId,
+                request.MovieIds.Append(request.ShowIds).Append(request.MusicVideoIds).ToList()))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddItemsToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMovies(request), await ValidateShows(request))
+            .Apply((_, _, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddItemsToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateMovies(AddItemsToCollection request) =>
+            _movieRepository.AllMoviesExist(request.MovieIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
+
+        private Task<Validation<BaseError, Unit>> ValidateShows(AddItemsToCollection request) =>
+            _televisionRepository.AllShowsExist(request.ShowIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Show does not exist"));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs

@@ -0,0 +1,68 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddMusicVideoToCollectionHandler : MediatR.IRequestHandler<AddMusicVideoToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly IMusicVideoRepository _musicVideoRepository;
+
+        public AddMusicVideoToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IMusicVideoRepository musicVideoRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _musicVideoRepository = musicVideoRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddMusicVideoToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddMusicVideoRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddMusicVideoRequest(AddMusicVideoToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.MusicVideoId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddMusicVideoToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMusicVideo(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddMusicVideoToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateMusicVideo(AddMusicVideoToCollection request) =>
+            LoadMusicVideo(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Music video does not exist"));
+
+        private Task<Option<MusicVideo>> LoadMusicVideo(AddMusicVideoToCollection request) =>
+            _musicVideoRepository.GetMusicVideo(request.MusicVideoId);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs

@@ -1,8 +1,12 @@
 using ErsatzTV.Core;
 using LanguageExt;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
     public record UpdateCollection
-        (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>;
+        (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>
+    {
+        public Option<bool> UseCustomPlaybackOrder { get; set; } = None;
+    }
 }

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateCollectionCustomOrder
+    (
+        int CollectionId,
+        List<MediaItemCustomOrder> MediaItemCustomOrders) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record MediaItemCustomOrder(int MediaItemId, int CustomIndex);
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        UpdateCollectionCustomOrderHandler : MediatR.IRequestHandler<UpdateCollectionCustomOrder,
+            Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateCollectionCustomOrderHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateCollectionCustomOrder request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(c => ApplyUpdateRequest(c, request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollectionCustomOrder request)
+        {
+            foreach (MediaItemCustomOrder updateItem in request.MediaItemCustomOrders)
+            {
+                Option<CollectionItem> maybeCollectionItem =
+                    c.CollectionItems.FirstOrDefault(ci => ci.MediaItemId == updateItem.MediaItemId);
+
+                await maybeCollectionItem.IfSomeAsync(ci => ci.CustomIndex = updateItem.CustomIndex);
+            }
+
+            if (await _mediaCollectionRepository.Update(c))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
+                    request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private Task<Validation<BaseError, Collection>> Validate(UpdateCollectionCustomOrder request) =>
+            CollectionMustExist(request);
+
+        private Task<Validation<BaseError, Collection>> CollectionMustExist(
+            UpdateCollectionCustomOrder request) =>
+            _mediaCollectionRepository.Get(request.CollectionId)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -1,5 +1,7 @@
 using System.Threading;
+using System.Threading.Channels;
 using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -9,10 +11,16 @@ namespace ErsatzTV.Application.MediaCollections.Commands
 {
     public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
     {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public UpdateCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public UpdateCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
             _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
 
         public Task<Either<BaseError, Unit>> Handle(
             UpdateCollection request,
@@ -21,10 +29,21 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                 .MapT(c => ApplyUpdateRequest(c, request))
                 .Bind(v => v.ToEitherAsync());
 
-        private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollection update)
+        private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollection request)
         {
-            c.Name = update.Name;
-            await _mediaCollectionRepository.Update(c);
+            c.Name = request.Name;
+            await request.UseCustomPlaybackOrder.IfSomeAsync(
+                useCustomPlaybackOrder => c.UseCustomPlaybackOrder = useCustomPlaybackOrder);
+            if (await _mediaCollectionRepository.Update(c) && request.UseCustomPlaybackOrder.IsSome)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
+                    request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
             return Unit.Default;
         }
 

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

@@ -3,6 +3,7 @@
 namespace ErsatzTV.Application.MediaCollections
 {
     public record MediaCollectionViewModel(int Id, string Name) : MediaCardViewModel(
+        Id,
         Name,
         string.Empty,
         Name,

ErsatzTV.Application/MediaItems/Mapper.cs

@@ -1,5 +1,4 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaItems
 {
@@ -8,59 +7,6 @@ namespace ErsatzTV.Application.MediaItems
         internal static MediaItemViewModel ProjectToViewModel(MediaItem mediaItem) =>
             new(mediaItem.Id, mediaItem.LibraryPathId);
 
-        internal static MediaItemSearchResultViewModel ProjectToSearchViewModel(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Episode e => ProjectToSearchViewModel(e),
-                Movie m => ProjectToSearchViewModel(m),
-                _ => throw new ArgumentOutOfRangeException()
-            };
-
-        private static MediaItemSearchResultViewModel ProjectToSearchViewModel(Episode mediaItem) =>
-            new(
-                mediaItem.Id,
-                GetLibraryName(mediaItem),
-                "TV Show",
-                GetDisplayTitle(mediaItem),
-                GetDisplayDuration(mediaItem));
-
-        private static MediaItemSearchResultViewModel ProjectToSearchViewModel(Movie mediaItem) =>
-            new(
-                mediaItem.Id,
-                GetLibraryName(mediaItem),
-                "Movie",
-                GetDisplayTitle(mediaItem),
-                GetDisplayDuration(mediaItem));
-
-
-        private static string GetDisplayTitle(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone()
-                    .Map(em => $"{em.Title} - s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00}")
-                    .IfNone("[unknown episode]"),
-                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]"),
-                _ => string.Empty
-            };
-
-        private static string GetDisplayDuration(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem switch
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
-            };
-
-            return string.Format(
-                version.Duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                version.Duration);
-        }
-
-        // TODO: fix this when search is reimplemented
-        private static string GetLibraryName(MediaItem item) =>
-            "Library Name";
-
         public static NamedMediaItemViewModel ProjectToViewModel(Show show) =>
             new(show.Id, show.ShowMetadata.HeadOrNone().Map(sm => $"{sm?.Title} ({sm?.Year})").IfNone("???"));
 

ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodes.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using System.Globalization;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaItems.Queries
+{
+    public record GetAllLanguageCodes : IRequest<List<CultureInfo>>;
+}

ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaItems.Queries
+{
+    public class GetAllLanguageCodesHandler : IRequestHandler<GetAllLanguageCodes, List<CultureInfo>>
+    {
+        private readonly IMediaItemRepository _mediaItemRepository;
+
+        public GetAllLanguageCodesHandler(IMediaItemRepository mediaItemRepository) =>
+            _mediaItemRepository = mediaItemRepository;
+
+        public async Task<List<CultureInfo>> Handle(GetAllLanguageCodes request, CancellationToken cancellationToken)
+        {
+            var result = new List<CultureInfo>();
+
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
+            List<string> allLanguageCodes = await _mediaItemRepository.GetAllLanguageCodes();
+            foreach (string code in allLanguageCodes)
+            {
+                Option<CultureInfo> maybeCulture = allCultures.Find(
+                    ci => string.Equals(code, ci.ThreeLetterISOLanguageName, StringComparison.OrdinalIgnoreCase));
+                await maybeCulture.IfSomeAsync(cultureInfo => result.Add(cultureInfo));
+            }
+
+            return result;
+        }
+    }
+}

ErsatzTV.Application/MediaItems/Queries/SearchAllMediaItems.cs

@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaItems.Queries
-{
-    public record SearchAllMediaItems(string SearchString) : IRequest<List<MediaItemSearchResultViewModel>>;
-}

ErsatzTV.Application/MediaItems/Queries/SearchAllMediaItemsHandler.cs

@@ -1,23 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-using static ErsatzTV.Application.MediaItems.Mapper;
-
-namespace ErsatzTV.Application.MediaItems.Queries
-{
-    public class SearchAllMediaItemsHandler : IRequestHandler<SearchAllMediaItems, List<MediaItemSearchResultViewModel>>
-    {
-        private readonly IMediaItemRepository _mediaItemRepository;
-
-        public SearchAllMediaItemsHandler(IMediaItemRepository mediaItemRepository) =>
-            _mediaItemRepository = mediaItemRepository;
-
-        public Task<List<MediaItemSearchResultViewModel>>
-            Handle(SearchAllMediaItems request, CancellationToken cancellationToken) =>
-            _mediaItemRepository.Search(request.SearchString).Map(list => list.Map(ProjectToSearchViewModel).ToList());
-    }
-}

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -7,6 +8,7 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
@@ -21,7 +23,9 @@ namespace ErsatzTV.Application.MediaSources.Commands
         private readonly IEntityLocker _entityLocker;
         private readonly ILibraryRepository _libraryRepository;
         private readonly ILogger<ScanLocalLibraryHandler> _logger;
+        private readonly IMediator _mediator;
         private readonly IMovieFolderScanner _movieFolderScanner;
+        private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
         private readonly ITelevisionFolderScanner _televisionFolderScanner;
 
         public ScanLocalLibraryHandler(
@@ -29,14 +33,18 @@ namespace ErsatzTV.Application.MediaSources.Commands
             IConfigElementRepository configElementRepository,
             IMovieFolderScanner movieFolderScanner,
             ITelevisionFolderScanner televisionFolderScanner,
+            IMusicVideoFolderScanner musicVideoFolderScanner,
             IEntityLocker entityLocker,
+            IMediator mediator,
             ILogger<ScanLocalLibraryHandler> logger)
         {
             _libraryRepository = libraryRepository;
             _configElementRepository = configElementRepository;
             _movieFolderScanner = movieFolderScanner;
             _televisionFolderScanner = televisionFolderScanner;
+            _musicVideoFolderScanner = musicVideoFolderScanner;
             _entityLocker = entityLocker;
+            _mediator = mediator;
             _logger = logger;
         }
 
@@ -58,32 +66,62 @@ namespace ErsatzTV.Application.MediaSources.Commands
         {
             (LocalLibrary localLibrary, string ffprobePath, bool forceScan) = parameters;
 
-            var lastScan = new DateTimeOffset(localLibrary.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
-            if (forceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
+            var sw = new Stopwatch();
+            sw.Start();
+
+            for (var i = 0; i < localLibrary.Paths.Count; i++)
             {
-                foreach (LibraryPath libraryPath in localLibrary.Paths)
+                LibraryPath libraryPath = localLibrary.Paths[i];
+
+                decimal progressMin = (decimal) i / localLibrary.Paths.Count;
+                decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;
+
+                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+                if (forceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
                 {
                     switch (localLibrary.MediaKind)
                     {
                         case LibraryMediaKind.Movies:
-                            await _movieFolderScanner.ScanFolder(libraryPath, ffprobePath);
+                            await _movieFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                lastScan,
+                                progressMin,
+                                progressMax);
                             break;
                         case LibraryMediaKind.Shows:
-                            await _televisionFolderScanner.ScanFolder(libraryPath, ffprobePath);
+                            await _televisionFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                lastScan,
+                                progressMin,
+                                progressMax);
+                            break;
+                        case LibraryMediaKind.MusicVideos:
+                            await _musicVideoFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                lastScan,
+                                progressMin,
+                                progressMax);
                             break;
                     }
+
+                    libraryPath.LastScan = DateTime.UtcNow;
+                    await _libraryRepository.UpdateLastScan(libraryPath);
                 }
 
-                localLibrary.LastScan = DateTime.UtcNow;
-                await _libraryRepository.UpdateLastScan(localLibrary);
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of library {Name}",
-                    localLibrary.Name);
+                await _mediator.Publish(new LibraryScanProgress(libraryPath.LibraryId, progressMax));
             }
 
+            sw.Stop();
+            _logger.LogDebug(
+                "Scan of library {Name} completed in {Duration}",
+                localLibrary.Name,
+                TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds));
+
+            await _mediator.Publish(new LibraryScanProgress(localLibrary.Id, 0));
+
             _entityLocker.UnlockLibrary(localLibrary.Id);
             return Unit.Default;
         }

ErsatzTV.Application/Movies/Mapper.cs

@@ -13,8 +13,15 @@ namespace ErsatzTV.Application.Movies
                 metadata.Title,
                 metadata.Year?.ToString(),
                 metadata.Plot,
-                Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
-                    .Match(a => a.Path, string.Empty));
+                Artwork(metadata, ArtworkKind.Poster),
+                Artwork(metadata, ArtworkKind.FanArt),
+                metadata.Genres.Map(g => g.Name).ToList(),
+                metadata.Tags.Map(t => t.Name).ToList(),
+                metadata.Studios.Map(s => s.Name).ToList());
         }
+
+        private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>
+            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+                .Match(a => a.Path, string.Empty);
     }
 }

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -1,4 +1,14 @@
-namespace ErsatzTV.Application.Movies
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.Movies
 {
-    public record MovieViewModel(string Title, string Year, string Plot, string Poster);
+    public record MovieViewModel(
+        string Title,
+        string Year,
+        string Plot,
+        string Poster,
+        string FanArt,
+        List<string> Genres,
+        List<string> Tags,
+        List<string> Studios);
 }

ErsatzTV.Application/Playouts/Mapper.cs

@@ -24,15 +24,25 @@ namespace ErsatzTV.Application.Playouts
         private static PlayoutProgramScheduleViewModel Project(ProgramSchedule programSchedule) =>
             new(programSchedule.Id, programSchedule.Name);
 
-        private static string GetDisplayTitle(MediaItem mediaItem) =>
-            mediaItem switch
+        private static string GetDisplayTitle(MediaItem mediaItem)
+        {
+            switch (mediaItem)
             {
-                Episode e => e.EpisodeMetadata.HeadOrNone()
-                    .Map(em => $"{em.Title} - s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00}")
-                    .IfNone("[unknown episode]"),
-                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]"),
-                _ => string.Empty
-            };
+                case Episode e:
+                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                    return e.EpisodeMetadata.HeadOrNone()
+                        .Map(em => $"{showTitle}s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00} - {em.Title}")
+                        .IfNone("[unknown episode]");
+                case Movie m:
+                    return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
+                case MusicVideo mv:
+                    return mv.MusicVideoMetadata.HeadOrNone().Map(mvm => $"{mvm.Artist} - {mvm.Title}")
+                        .IfNone("[unknown music video]");
+                default:
+                    return string.Empty;
+            }
+        }
 
         private static string GetDisplayDuration(MediaItem mediaItem)
         {
@@ -40,6 +50,7 @@ namespace ErsatzTV.Application.Playouts
             {
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
             };
 

ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs

@@ -1,4 +1,4 @@
 namespace ErsatzTV.Application.Playouts
 {
-    public record PlayoutChannelViewModel(int Id, int Number, string Name);
+    public record PlayoutChannelViewModel(int Id, string Number, string Name);
 }

ErsatzTV.Application/Plex/Commands/SignOutOfPlex.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Plex.Commands
+{
+    public record SignOutOfPlex : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Plex;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Plex.Commands
+{
+    public class SignOutOfPlexHandler : MediatR.IRequestHandler<SignOutOfPlex, Either<BaseError, Unit>>
+    {
+        private readonly IEntityLocker _entityLocker;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IPlexSecretStore _plexSecretStore;
+        private readonly ISearchIndex _searchIndex;
+
+        public SignOutOfPlexHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IPlexSecretStore plexSecretStore,
+            IEntityLocker entityLocker,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _plexSecretStore = plexSecretStore;
+            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(SignOutOfPlex request, CancellationToken cancellationToken)
+        {
+            List<int> ids = await _mediaSourceRepository.DeleteAllPlex();
+            await _searchIndex.RemoveItems(ids);
+            await _plexSecretStore.DeleteAll();
+            _entityLocker.UnlockPlex();
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraries.cs

@@ -3,5 +3,6 @@ using LanguageExt;
 
 namespace ErsatzTV.Application.Plex.Commands
 {
-    public record SynchronizePlexLibraries(int PlexMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>;
+    public record SynchronizePlexLibraries(int PlexMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+        IPlexBackgroundServiceRequest;
 }

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibrariesHandler.cs

@@ -78,10 +78,10 @@ namespace ErsatzTV.Application.Plex.Commands
                     var existing = connectionParameters.PlexMediaSource.Libraries.OfType<PlexLibrary>().ToList();
                     var toAdd = libraries.Filter(library => existing.All(l => l.Key != library.Key)).ToList();
                     var toRemove = existing.Filter(library => libraries.All(l => l.Key != library.Key)).ToList();
-                    connectionParameters.PlexMediaSource.Libraries.AddRange(toAdd);
-                    toRemove.ForEach(c => connectionParameters.PlexMediaSource.Libraries.Remove(c));
-
-                    return _mediaSourceRepository.Update(connectionParameters.PlexMediaSource);
+                    return _mediaSourceRepository.UpdateLibraries(
+                        connectionParameters.PlexMediaSource.Id,
+                        toAdd,
+                        toRemove);
                 },
                 error =>
                 {

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryById.cs

@@ -4,7 +4,7 @@ using MediatR;
 
 namespace ErsatzTV.Application.Plex.Commands
 {
-    public interface ISynchronizePlexLibraryById : IRequest<Either<BaseError, string>>, IBackgroundServiceRequest
+    public interface ISynchronizePlexLibraryById : IRequest<Either<BaseError, string>>, IPlexBackgroundServiceRequest
     {
         int PlexLibraryId { get; }
         bool ForceScan { get; }

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs

@@ -20,21 +20,27 @@ namespace ErsatzTV.Application.Plex.Commands
             IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>
     {
         private readonly IEntityLocker _entityLocker;
+        private readonly ILibraryRepository _libraryRepository;
         private readonly ILogger<SynchronizePlexLibraryByIdHandler> _logger;
         private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlexMovieLibraryScanner _plexMovieLibraryScanner;
         private readonly IPlexSecretStore _plexSecretStore;
+        private readonly IPlexTelevisionLibraryScanner _plexTelevisionLibraryScanner;
 
         public SynchronizePlexLibraryByIdHandler(
             IMediaSourceRepository mediaSourceRepository,
             IPlexSecretStore plexSecretStore,
             IPlexMovieLibraryScanner plexMovieLibraryScanner,
+            IPlexTelevisionLibraryScanner plexTelevisionLibraryScanner,
+            ILibraryRepository libraryRepository,
             IEntityLocker entityLocker,
             ILogger<SynchronizePlexLibraryByIdHandler> logger)
         {
             _mediaSourceRepository = mediaSourceRepository;
             _plexSecretStore = plexSecretStore;
             _plexMovieLibraryScanner = plexMovieLibraryScanner;
+            _plexTelevisionLibraryScanner = plexTelevisionLibraryScanner;
+            _libraryRepository = libraryRepository;
             _entityLocker = entityLocker;
             _logger = logger;
         }
@@ -67,13 +73,15 @@ namespace ErsatzTV.Application.Plex.Commands
                             parameters.Library);
                         break;
                     case LibraryMediaKind.Shows:
-                        // TODO: plex tv scanner
-                        // await _televisionFolderScanner.ScanFolder(parameters.LocalMediaSource, parameters.FFprobePath);
+                        await _plexTelevisionLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection,
+                            parameters.ConnectionParameters.PlexServerAuthToken,
+                            parameters.Library);
                         break;
                 }
 
                 parameters.Library.LastScan = DateTime.UtcNow;
-                await _mediaSourceRepository.Update(parameters.Library);
+                await _libraryRepository.UpdateLastScan(parameters.Library);
             }
             else
             {

ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs

@@ -1,9 +1,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Channels;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
@@ -15,15 +17,21 @@ namespace ErsatzTV.Application.Plex.Commands
         SynchronizePlexMediaSourcesHandler : IRequestHandler<SynchronizePlexMediaSources,
             Either<BaseError, List<PlexMediaSource>>>
     {
+        private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
+        private readonly IEntityLocker _entityLocker;
         private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlexTvApiClient _plexTvApiClient;
 
         public SynchronizePlexMediaSourcesHandler(
             IMediaSourceRepository mediaSourceRepository,
-            IPlexTvApiClient plexTvApiClient)
+            IPlexTvApiClient plexTvApiClient,
+            ChannelWriter<IPlexBackgroundServiceRequest> channel,
+            IEntityLocker entityLocker)
         {
             _mediaSourceRepository = mediaSourceRepository;
             _plexTvApiClient = plexTvApiClient;
+            _channel = channel;
+            _entityLocker = entityLocker;
         }
 
         public Task<Either<BaseError, List<PlexMediaSource>>> Handle(
@@ -39,46 +47,42 @@ namespace ErsatzTV.Application.Plex.Commands
                 await SynchronizeServer(allExisting, server);
             }
 
+            foreach (PlexMediaSource mediaSource in await _mediaSourceRepository.GetAllPlex())
+            {
+                await _channel.WriteAsync(new SynchronizePlexLibraries(mediaSource.Id));
+            }
+
+            _entityLocker.UnlockPlex();
+
             return allExisting;
         }
 
-        private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+        private Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
         {
             Option<PlexMediaSource> maybeExisting =
                 allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
-            await maybeExisting.Match(
+            return maybeExisting.Match(
                 existing =>
                 {
+                    existing.Platform = server.Platform;
+                    existing.PlatformVersion = server.PlatformVersion;
                     existing.ProductVersion = server.ProductVersion;
                     existing.ServerName = server.ServerName;
-                    MergeConnections(existing.Connections, server.Connections);
-                    if (existing.Connections.Any() && existing.Connections.All(c => !c.IsActive))
-                    {
-                        existing.Connections.Head().IsActive = true;
-                    }
-
-                    return _mediaSourceRepository.Update(existing);
+                    var toAdd = server.Connections
+                        .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                    var toRemove = existing.Connections
+                        .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                    return _mediaSourceRepository.Update(existing, toAdd, toRemove);
                 },
                 async () =>
                 {
-                    await _mediaSourceRepository.Add(server);
                     if (server.Connections.Any())
                     {
                         server.Connections.Head().IsActive = true;
                     }
 
-                    await _mediaSourceRepository.Update(server);
+                    await _mediaSourceRepository.Add(server);
                 });
         }
-
-        private void MergeConnections(
-            List<PlexConnection> existing,
-            List<PlexConnection> incoming)
-        {
-            var toAdd = incoming.Filter(connection => existing.All(c => c.Uri != connection.Uri)).ToList();
-            var toRemove = existing.Filter(connection => incoming.All(c => c.Uri != connection.Uri)).ToList();
-            existing.AddRange(toAdd);
-            toRemove.ForEach(c => existing.Remove(c));
-        }
     }
 }

ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferencesHandler.cs

@@ -4,6 +4,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using LanguageExt;
 
 namespace ErsatzTV.Application.Plex.Commands
@@ -13,16 +14,23 @@ namespace ErsatzTV.Application.Plex.Commands
             Either<BaseError, Unit>>
     {
         private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
 
-        public UpdatePlexLibraryPreferencesHandler(IMediaSourceRepository mediaSourceRepository) =>
+        public UpdatePlexLibraryPreferencesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ISearchIndex searchIndex)
+        {
             _mediaSourceRepository = mediaSourceRepository;
+            _searchIndex = searchIndex;
+        }
 
         public async Task<Either<BaseError, Unit>> Handle(
             UpdatePlexLibraryPreferences request,
             CancellationToken cancellationToken)
         {
             var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
-            await _mediaSourceRepository.DisablePlexLibrarySync(toDisable);
+            List<int> ids = await _mediaSourceRepository.DisablePlexLibrarySync(toDisable);
+            await _searchIndex.RemoveItems(ids);
 
             IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
             await _mediaSourceRepository.EnablePlexLibrarySync(toEnable);

ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacementsHandler.cs

@@ -6,7 +6,6 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Plex.Commands
 {
@@ -35,20 +34,7 @@ namespace ErsatzTV.Application.Plex.Commands
             var toRemove = plexMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
             var toUpdate = incoming.Except(toAdd).ToList();
 
-            plexMediaSource.PathReplacements.AddRange(toAdd);
-            toRemove.ForEach(pr => plexMediaSource.PathReplacements.Remove(pr));
-            foreach (PlexPathReplacement pathReplacement in toUpdate)
-            {
-                Optional(plexMediaSource.PathReplacements.SingleOrDefault(pr => pr.Id == pathReplacement.Id))
-                    .IfSome(
-                        pr =>
-                        {
-                            pr.PlexPath = pathReplacement.PlexPath;
-                            pr.LocalPath = pathReplacement.LocalPath;
-                        });
-            }
-
-            return _mediaSourceRepository.Update(plexMediaSource).ToUnit();
+            return _mediaSourceRepository.UpdatePathReplacements(plexMediaSource.Id, toAdd, toUpdate, toRemove);
         }
 
         private static PlexPathReplacement Project(PlexPathReplacementItem vm) =>

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -16,5 +16,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MediaItemId,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+        bool? OfflineTail,
+        string CustomTitle) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
 }

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs

@@ -1,4 +1,6 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -6,6 +8,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.ProgramSchedules.Commands
 {
@@ -22,22 +25,33 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             CreateProgramSchedule request,
             CancellationToken cancellationToken) =>
             Validate(request)
-                .Map(PersistProgramSchedule)
-                .ToEitherAsync();
+                .MapT(PersistProgramSchedule)
+                .Bind(v => v.ToEitherAsync());
 
         private Task<ProgramScheduleViewModel> PersistProgramSchedule(ProgramSchedule c) =>
             _programScheduleRepository.Add(c).Map(ProjectToViewModel);
 
-        private Validation<BaseError, ProgramSchedule> Validate(CreateProgramSchedule request) =>
+        private Task<Validation<BaseError, ProgramSchedule>> Validate(CreateProgramSchedule request) =>
             ValidateName(request)
-                .Map(
+                .MapT(
                     name => new ProgramSchedule
                     {
                         Name = name, MediaCollectionPlaybackOrder = request.MediaCollectionPlaybackOrder
                     });
 
-        private Validation<BaseError, string> ValidateName(CreateProgramSchedule createProgramSchedule) =>
-            createProgramSchedule.NotEmpty(c => c.Name)
+        private async Task<Validation<BaseError, string>> ValidateName(CreateProgramSchedule createProgramSchedule)
+        {
+            List<string> allNames = await _programScheduleRepository.GetAll()
+                .Map(list => list.Map(c => c.Name).ToList());
+
+            Validation<BaseError, string> result1 = createProgramSchedule.NotEmpty(c => c.Name)
                 .Bind(_ => createProgramSchedule.NotLongerThan(50)(c => c.Name));
+
+            var result2 = Optional(createProgramSchedule.Name)
+                .Filter(name => !allNames.Contains(name))
+                .ToValidation<BaseError>("Schedule name must be unique");
+
+            return (result1, result2).Apply((_, _) => createProgramSchedule.Name);
+        }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -13,5 +13,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MultipleCount { get; }
         TimeSpan? PlayoutDuration { get; }
         bool? OfflineTail { get; }
+        string CustomTitle { get; }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -100,7 +100,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
-                    MediaItemId = item.MediaItemId
+                    MediaItemId = item.MediaItemId,
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.One => new ProgramScheduleItemOne
                 {
@@ -109,7 +110,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
-                    MediaItemId = item.MediaItemId
+                    MediaItemId = item.MediaItemId,
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.Multiple => new ProgramScheduleItemMultiple
                 {
@@ -119,7 +121,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MediaItemId = item.MediaItemId,
-                    Count = item.MultipleCount.GetValueOrDefault()
+                    Count = item.MultipleCount.GetValueOrDefault(),
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.Duration => new ProgramScheduleItemDuration
                 {
@@ -130,7 +133,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     CollectionId = item.CollectionId,
                     MediaItemId = item.MediaItemId,
                     PlayoutDuration = item.PlayoutDuration.GetValueOrDefault(),
-                    OfflineTail = item.OfflineTail.GetValueOrDefault()
+                    OfflineTail = item.OfflineTail.GetValueOrDefault(),
+                    CustomTitle = item.CustomTitle
                 },
                 _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
             };

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -17,7 +17,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MediaItemId,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail) : IProgramScheduleItemRequest;
+        bool? OfflineTail,
+        string CustomTitle) : IProgramScheduleItemRequest;
 
     public record ReplaceProgramScheduleItems
         (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -28,7 +28,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             _ => null
                         },
                         duration.PlayoutDuration,
-                        duration.OfflineTail),
+                        duration.OfflineTail,
+                        duration.CustomTitle),
                 ProgramScheduleItemFlood flood =>
                     new ProgramScheduleItemFloodViewModel(
                         flood.Id,
@@ -44,7 +45,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
-                        }),
+                        },
+                        flood.CustomTitle),
                 ProgramScheduleItemMultiple multiple =>
                     new ProgramScheduleItemMultipleViewModel(
                         multiple.Id,
@@ -61,7 +63,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
                         },
-                        multiple.Count),
+                        multiple.Count,
+                        multiple.CustomTitle),
                 ProgramScheduleItemOne one =>
                     new ProgramScheduleItemOneViewModel(
                         one.Id,
@@ -77,7 +80,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
-                        }),
+                        },
+                        one.CustomTitle),
                 _ => throw new NotSupportedException(
                     $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
             };

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -16,7 +16,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             MediaCollectionViewModel collection,
             NamedMediaItemViewModel mediaItem,
             TimeSpan playoutDuration,
-            bool offlineTail) : base(
+            bool offlineTail,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -24,7 +25,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Duration,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
             PlayoutDuration = playoutDuration;
             OfflineTail = offlineTail;

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -14,7 +14,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
-            NamedMediaItemViewModel mediaItem) : base(
+            NamedMediaItemViewModel mediaItem,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -22,7 +23,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Flood,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -15,7 +15,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
             NamedMediaItemViewModel mediaItem,
-            int count) : base(
+            int count,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -23,7 +24,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Multiple,
             collectionType,
             collection,
-            mediaItem) =>
+            mediaItem,
+            customTitle) =>
             Count = count;
 
         public int Count { get; }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -14,7 +14,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
-            NamedMediaItemViewModel mediaItem) : base(
+            NamedMediaItemViewModel mediaItem,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -22,7 +23,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.One,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -13,7 +13,8 @@ namespace ErsatzTV.Application.ProgramSchedules
         PlayoutMode PlayoutMode,
         ProgramScheduleItemCollectionType CollectionType,
         MediaCollectionViewModel Collection,
-        NamedMediaItemViewModel MediaItem)
+        NamedMediaItemViewModel MediaItem,
+        string CustomTitle)
     {
         public string Name => CollectionType switch
         {

ErsatzTV.Application/Search/Commands/RebuildSearchIndex.cs

@@ -0,0 +1,6 @@
+using LanguageExt;
+
+namespace ErsatzTV.Application.Search.Commands
+{
+    public record RebuildSearchIndex : MediatR.IRequest<Unit>, IBackgroundServiceRequest;
+}

ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Application.Search.Commands
+{
+    public class RebuildSearchIndexHandler : MediatR.IRequestHandler<RebuildSearchIndex, Unit>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly ILogger<RebuildSearchIndexHandler> _logger;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ISearchRepository _searchRepository;
+
+        public RebuildSearchIndexHandler(
+            ISearchIndex searchIndex,
+            ISearchRepository searchRepository,
+            IConfigElementRepository configElementRepository,
+            ILogger<RebuildSearchIndexHandler> logger)
+        {
+            _searchIndex = searchIndex;
+            _logger = logger;
+            _searchRepository = searchRepository;
+            _configElementRepository = configElementRepository;
+        }
+
+        public async Task<Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
+        {
+            bool indexFolderExists = Directory.Exists(FileSystemLayout.SearchIndexFolder);
+
+            if (!indexFolderExists ||
+                await _configElementRepository.GetValue<int>(ConfigElementKey.SearchIndexVersion) <
+                _searchIndex.Version)
+            {
+                _logger.LogDebug("Migrating search index to version {Version}", _searchIndex.Version);
+
+                List<int> itemIds = await _searchRepository.GetItemIdsToIndex();
+                await _searchIndex.Rebuild(itemIds);
+
+                Option<ConfigElement> maybeVersion =
+                    await _configElementRepository.Get(ConfigElementKey.SearchIndexVersion);
+                await maybeVersion.Match(
+                    version =>
+                    {
+                        version.Value = _searchIndex.Version.ToString();
+                        return _configElementRepository.Update(version);
+                    },
+                    () =>
+                    {
+                        var configElement = new ConfigElement
+                        {
+                            Key = ConfigElementKey.SearchIndexVersion.Key,
+                            Value = _searchIndex.Version.ToString()
+                        };
+                        return _configElementRepository.Add(configElement);
+                    });
+
+                _logger.LogDebug("Done migrating search index");
+            }
+            else
+            {
+                _logger.LogDebug("Search index is already version {Version}", _searchIndex.Version);
+            }
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndex.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Search;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndex(string Query) : IRequest<SearchResult>;
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexHandler.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class QuerySearchIndexHandler : IRequestHandler<QuerySearchIndex, SearchResult>
+    {
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+
+        public Task<SearchResult> Handle(QuerySearchIndex request, CancellationToken cancellationToken) =>
+            _searchIndex.Search(request.Query, 0, 100);
+    }
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexMovies.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMovies, MovieCardResultsViewModel>
+    {
+        private readonly IMovieRepository _movieRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexMoviesHandler(ISearchIndex searchIndex, IMovieRepository movieRepository)
+        {
+            _searchIndex = searchIndex;
+            _movieRepository = movieRepository;
+        }
+
+        public async Task<MovieCardResultsViewModel> Handle(
+            QuerySearchIndexMovies request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<MovieCardViewModel> items = await _movieRepository
+                .GetMoviesForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new MovieCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexShows.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexShowsHandler : IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
+    {
+        private readonly ISearchIndex _searchIndex;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public QuerySearchIndexShowsHandler(ISearchIndex searchIndex, ITelevisionRepository televisionRepository)
+        {
+            _searchIndex = searchIndex;
+            _televisionRepository = televisionRepository;
+        }
+
+        public async Task<TelevisionShowCardResultsViewModel> Handle(
+            QuerySearchIndexShows request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<TelevisionShowCardViewModel> items = await _televisionRepository
+                .GetShowsForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new TelevisionShowCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}

ErsatzTV.Application/Search/SearchResultViewModel.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.Search
+{
+    public class SearchResultViewModel<T>
+    {
+        public int TotalCount { get; set; }
+        public List<T> Items { get; set; }
+    }
+}

ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs

@@ -5,5 +5,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.Streaming.Queries
 {
-    public record FFmpegProcessRequest(int ChannelNumber) : IRequest<Either<BaseError, Process>>;
+    public record FFmpegProcessRequest(string ChannelNumber) : IRequest<Either<BaseError, Process>>;
 }

ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumber.cs

@@ -6,5 +6,5 @@ using MediatR;
 namespace ErsatzTV.Application.Streaming.Queries
 {
     public record GetConcatPlaylistByChannelNumber
-        (string Scheme, string Host, int ChannelNumber) : IRequest<Either<BaseError, ConcatPlaylist>>;
+        (string Scheme, string Host, string ChannelNumber) : IRequest<Either<BaseError, ConcatPlaylist>>;
 }

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs

@@ -2,7 +2,7 @@
 {
     public record GetConcatProcessByChannelNumber : FFmpegProcessRequest
     {
-        public GetConcatProcessByChannelNumber(string scheme, string host, int channelNumber) : base(channelNumber)
+        public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(channelNumber)
         {
             Scheme = scheme;
             Host = host;

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -5,30 +5,38 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Streaming.Queries
 {
     public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
     {
+        private readonly IConfigElementRepository _configElementRepository;
         private readonly FFmpegProcessService _ffmpegProcessService;
 
         public GetConcatProcessByChannelNumberHandler(
             IChannelRepository channelRepository,
             IConfigElementRepository configElementRepository,
             FFmpegProcessService ffmpegProcessService)
-            : base(channelRepository, configElementRepository) =>
+            : base(channelRepository, configElementRepository)
+        {
+            _configElementRepository = configElementRepository;
             _ffmpegProcessService = ffmpegProcessService;
+        }
 
-        protected override Task<Either<BaseError, Process>> GetProcess(
+        protected override async Task<Either<BaseError, Process>> GetProcess(
             GetConcatProcessByChannelNumber request,
             Channel channel,
-            string ffmpegPath) =>
-            Right<BaseError, Process>(
-                _ffmpegProcessService.ConcatChannel(
-                    ffmpegPath,
-                    channel,
-                    request.Scheme,
-                    request.Host)).AsTask();
+            string ffmpegPath)
+        {
+            bool saveReports = await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                .Map(result => result.IfNone(false));
+
+            return _ffmpegProcessService.ConcatChannel(
+                ffmpegPath,
+                saveReports,
+                channel,
+                request.Scheme,
+                request.Host);
+        }
     }
 }

ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumber.cs

@@ -5,5 +5,5 @@ using MediatR;
 namespace ErsatzTV.Application.Streaming.Queries
 {
     public record GetHlsPlaylistByChannelNumber
-        (string Scheme, string Host, int ChannelNumber) : IRequest<Either<BaseError, string>>;
+        (string Scheme, string Host, string ChannelNumber) : IRequest<Either<BaseError, string>>;
 }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs

@@ -2,7 +2,7 @@
 {
     public record GetPlayoutItemProcessByChannelNumber : FFmpegProcessRequest
     {
-        public GetPlayoutItemProcessByChannelNumber(int channelNumber) : base(channelNumber)
+        public GetPlayoutItemProcessByChannelNumber(string channelNumber) : base(channelNumber)
         {
         }
     }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -1,15 +1,14 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.IO;
-using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using Microsoft.Extensions.Logging;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Streaming.Queries
@@ -17,24 +16,26 @@ namespace ErsatzTV.Application.Streaming.Queries
     public class
         GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<GetPlayoutItemProcessByChannelNumber>
     {
+        private readonly IConfigElementRepository _configElementRepository;
         private readonly FFmpegProcessService _ffmpegProcessService;
-        private readonly ILogger<GetPlayoutItemProcessByChannelNumberHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ILocalFileSystem _localFileSystem;
         private readonly IPlayoutRepository _playoutRepository;
+        private readonly IPlexPathReplacementService _plexPathReplacementService;
 
         public GetPlayoutItemProcessByChannelNumberHandler(
             IChannelRepository channelRepository,
             IConfigElementRepository configElementRepository,
             IPlayoutRepository playoutRepository,
-            IMediaSourceRepository mediaSourceRepository,
             FFmpegProcessService ffmpegProcessService,
-            ILogger<GetPlayoutItemProcessByChannelNumberHandler> logger)
+            ILocalFileSystem localFileSystem,
+            IPlexPathReplacementService plexPathReplacementService)
             : base(channelRepository, configElementRepository)
         {
+            _configElementRepository = configElementRepository;
             _playoutRepository = playoutRepository;
-            _mediaSourceRepository = mediaSourceRepository;
             _ffmpegProcessService = ffmpegProcessService;
-            _logger = logger;
+            _localFileSystem = localFileSystem;
+            _plexPathReplacementService = plexPathReplacementService;
         }
 
         protected override async Task<Either<BaseError, Process>> GetProcess(
@@ -43,66 +44,134 @@ namespace ErsatzTV.Application.Streaming.Queries
             string ffmpegPath)
         {
             DateTimeOffset now = DateTimeOffset.Now;
-            Option<PlayoutItem> maybePlayoutItem = await _playoutRepository.GetPlayoutItem(channel.Id, now);
-            return await maybePlayoutItem.Match<Task<Either<BaseError, Process>>>(
-                async playoutItem =>
+            Either<BaseError, PlayoutItemWithPath> maybePlayoutItem = await _playoutRepository
+                .GetPlayoutItem(channel.Id, now)
+                .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
+                .BindT(ValidatePlayoutItemPath);
+
+            return await maybePlayoutItem.Match(
+                async playoutItemWithPath =>
                 {
-                    MediaVersion version = playoutItem.MediaItem switch
+                    MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem switch
                     {
                         Movie m => m.MediaVersions.Head(),
                         Episode e => e.MediaVersions.Head(),
-                        _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
+                        MusicVideo mv => mv.MediaVersions.Head(),
+                        _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                     };
 
-                    MediaFile file = version.MediaFiles.Head();
-                    string path = file.Path;
-                    if (playoutItem.MediaItem is PlexMovie plexMovie)
-                    {
-                        path = await GetReplacementPlexPath(plexMovie.LibraryPathId, path);
-                    }
+                    bool saveReports = await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                        .Map(result => result.IfNone(false));
 
-                    return _ffmpegProcessService.ForPlayoutItem(
-                        ffmpegPath,
-                        channel,
-                        version,
-                        path,
-                        playoutItem.StartOffset,
-                        now);
+                    return Right<BaseError, Process>(
+                        await _ffmpegProcessService.ForPlayoutItem(
+                            ffmpegPath,
+                            saveReports,
+                            channel,
+                            version,
+                            playoutItemWithPath.Path,
+                            playoutItemWithPath.PlayoutItem.StartOffset,
+                            now));
                 },
-                () =>
+                async error =>
                 {
-                    if (channel.FFmpegProfile.Transcode)
+                    var offlineTranscodeMessage =
+                        $"offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";
+
+                    Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
+                        .Filter(transcode => transcode)
+                        .Match(
+                            _ => _playoutRepository.GetNextItemStart(channel.Id, now)
+                                .MapT(nextStart => nextStart - now),
+                            () => Option<TimeSpan>.None.AsTask());
+
+                    switch (error)
                     {
-                        return Right<BaseError, Process>(_ffmpegProcessService.ForOfflineImage(ffmpegPath, channel))
-                            .AsTask();
+                        case UnableToLocatePlayoutItem:
+                            if (channel.FFmpegProfile.Transcode)
+                            {
+                                return _ffmpegProcessService.ForError(
+                                    ffmpegPath,
+                                    channel,
+                                    maybeDuration,
+                                    "Channel is Offline");
+                            }
+                            else
+                            {
+                                var message =
+                                    $"Unable to locate playout item for channel {channel.Number}; {offlineTranscodeMessage}";
+
+                                return BaseError.New(message);
+                            }
+                        case PlayoutItemDoesNotExistOnDisk:
+                            if (channel.FFmpegProfile.Transcode)
+                            {
+                                return _ffmpegProcessService.ForError(ffmpegPath, channel, maybeDuration, error.Value);
+                            }
+                            else
+                            {
+                                var message =
+                                    $"Playout item does not exist on disk for channel {channel.Number}; {offlineTranscodeMessage}";
+
+                                return BaseError.New(message);
+                            }
+                        default:
+                            if (channel.FFmpegProfile.Transcode)
+                            {
+                                return _ffmpegProcessService.ForError(
+                                    ffmpegPath,
+                                    channel,
+                                    maybeDuration,
+                                    "Channel is Offline");
+                            }
+                            else
+                            {
+                                var message =
+                                    $"Unexpected error locating playout item for channel {channel.Number}; {offlineTranscodeMessage}";
+
+                                return BaseError.New(message);
+                            }
                     }
-
-                    var message =
-                        $"Unable to locate playout item for channel {channel.Number}; offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";
-
-                    return Left<BaseError, Process>(BaseError.New(message)).AsTask();
                 });
         }
 
-        private async Task<string> GetReplacementPlexPath(int libraryPathId, string path)
+        private async Task<Either<BaseError, PlayoutItemWithPath>> ValidatePlayoutItemPath(PlayoutItem playoutItem)
         {
-            List<PlexPathReplacement> replacements =
-                await _mediaSourceRepository.GetPlexPathReplacementsByLibraryId(libraryPathId);
-            // TODO: this might barf mixing platforms (i.e. plex on linux, etv on windows)
-            Option<PlexPathReplacement> maybeReplacement = replacements
-                .SingleOrDefault(r => path.StartsWith(r.PlexPath + Path.DirectorySeparatorChar));
-            return maybeReplacement.Match(
-                replacement =>
-                {
-                    string finalPath = path.Replace(replacement.PlexPath, replacement.LocalPath);
-                    _logger.LogInformation(
-                        "Replacing plex path {PlexPath} with {LocalPath} resulting in {FinalPath}",
-                        replacement.PlexPath,
-                        replacement.LocalPath,
-                        finalPath);
-                    return finalPath;
-                },
-                () => path);
+            string path = await GetPlayoutItemPath(playoutItem);
+
+            // TODO: this won't work with url streaming from plex
+            if (_localFileSystem.FileExists(path))
+            {
+                return new PlayoutItemWithPath(playoutItem, path);
+            }
+
+            return new PlayoutItemDoesNotExistOnDisk(path);
         }
+
+        private async Task<string> GetPlayoutItemPath(PlayoutItem playoutItem)
+        {
+            MediaVersion version = playoutItem.MediaItem switch
+            {
+                Movie m => m.MediaVersions.Head(),
+                Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
+                _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
+            };
+
+            MediaFile file = version.MediaFiles.Head();
+            string path = file.Path;
+            return playoutItem.MediaItem switch
+            {
+                PlexMovie plexMovie => await _plexPathReplacementService.GetReplacementPlexPath(
+                    plexMovie.LibraryPathId,
+                    path),
+                PlexEpisode plexEpisode => await _plexPathReplacementService.GetReplacementPlexPath(
+                    plexEpisode.LibraryPathId,
+                    path),
+                _ => path
+            };
+        }
+
+        private record PlayoutItemWithPath(PlayoutItem PlayoutItem, string Path);
     }
 }