optimize local library scanning (#112)

* add explicit warning for zero/invalid duration media items

* set dateadded on plex media versions

* add media stream table

* save local media streams to db

* save plex media streams to db

* add preferred language settings (no validation)

* use preferred language if possible

* code cleanup

* proper language code validation

* force scan of all libraries to pull in media streams

.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,19 +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-new
-      - # Temporary fix
-        # https://github.com/docker/build-push-action/issues/252
-        # https://github.com/moby/buildkit/issues/1896
-        name: Move cache
-        run: |
-          rm -rf /tmp/.buildx-cache
-          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
 
       - 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
@@ -100,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
@@ -114,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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -8,5 +8,6 @@ namespace ErsatzTV.Application.Channels
         string Name,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -11,5 +11,6 @@ namespace ErsatzTV.Application.Channels.Commands
         string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,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
 {
@@ -36,9 +39,10 @@ namespace ErsatzTV.Application.Channels.Commands
             _channelRepository.Add(c).Map(ProjectToViewModel);
 
         private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
-            (ValidateName(request), await 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))
@@ -59,7 +63,8 @@ namespace ErsatzTV.Application.Channels.Commands
                         Number = number,
                         FFmpegProfileId = ffmpegProfileId,
                         StreamingMode = request.StreamingMode,
-                        Artwork = artwork
+                        Artwork = artwork,
+                        PreferredLanguageCode = preferredLanguageCode
                     };
                 });
 
@@ -67,6 +72,14 @@ namespace ErsatzTV.Application.Channels.Commands
             createChannel.NotEmpty(c => c.Name)
                 .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
+        private Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
+            Optional(createChannel.PreferredLanguageCode)
+                .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);

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -12,5 +12,6 @@ namespace ErsatzTV.Application.Channels.Commands
         string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -32,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))
             {
@@ -65,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)
@@ -92,5 +95,12 @@ namespace ErsatzTV.Application.Channels.Commands
 
             return BaseError.New("Channel number must be unique");
         }
+
+        private Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+            Optional(updateChannel.PreferredLanguageCode)
+                .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/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -70,12 +71,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
 
         private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
         {
-            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(
+            await _configElementRepository.Get(ConfigElementKey.FFmpegPath).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.FFmpegPath;
@@ -88,7 +84,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
-            ffprobePath.Match(
+            await _configElementRepository.Get(ConfigElementKey.FFprobePath).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.FFprobePath;
@@ -101,7 +97,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
-            defaultFFmpegProfileId.Match(
+            await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.DefaultFFmpegProfileId.ToString();
@@ -117,6 +113,44 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
+            await _configElementRepository.Get(ConfigElementKey.FFmpegSaveReports).Match(
+                ce =>
+                {
+                    ce.Value = request.Settings.SaveReports.ToString();
+                    _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement
+                    {
+                        Key = ConfigElementKey.FFmpegSaveReports.Key,
+                        Value = request.Settings.SaveReports.ToString()
+                    };
+                    _configElementRepository.Add(ce);
+                });
+
+            if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
+            {
+                Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
+            }
+
+            await _configElementRepository.Get(ConfigElementKey.FFmpegPreferredLanguageCode).Match(
+                ce =>
+                {
+                    ce.Value = request.Settings.PreferredLanguageCode;
+                    _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement
+                    {
+                        Key = ConfigElementKey.FFmpegPreferredLanguageCode.Key,
+                        Value = request.Settings.PreferredLanguageCode
+                    };
+                    _configElementRepository.Add(ce);
+                });
+
+
             return Unit.Default;
         }
     }

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/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)
+                DefaultFFmpegProfileId = defaultFFmpegProfileId.IfNone(0),
+                SaveReports = saveReports.IfNone(false),
+                PreferredLanguageCode = preferredLanguageCode.IfNone("eng")
             };
         }
     }

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/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/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,43 +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) =>
-            request.Query.Split(":").Head() switch
-            {
-                "genre" => GenreSearch(request.Query.Replace("genre:", string.Empty)),
-                "tag" => TagSearch(request.Query.Replace("tag:", string.Empty)),
-                _ => TitleSearch(request.Query)
-            };
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> TitleSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByTitle(query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> GenreSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByGenre(query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> TagSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByTag(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/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/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;
@@ -61,21 +62,30 @@ namespace ErsatzTV.Application.MediaSources.Commands
             var lastScan = new DateTimeOffset(localLibrary.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
             if (forceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
             {
+                var sw = new Stopwatch();
+                sw.Start();
+
                 foreach (LibraryPath libraryPath in localLibrary.Paths)
                 {
                     switch (localLibrary.MediaKind)
                     {
                         case LibraryMediaKind.Movies:
-                            await _movieFolderScanner.ScanFolder(libraryPath, ffprobePath);
+                            await _movieFolderScanner.ScanFolder(libraryPath, ffprobePath, lastScan);
                             break;
                         case LibraryMediaKind.Shows:
-                            await _televisionFolderScanner.ScanFolder(libraryPath, ffprobePath);
+                            await _televisionFolderScanner.ScanFolder(libraryPath, ffprobePath, lastScan);
                             break;
                     }
                 }
 
                 localLibrary.LastScan = DateTime.UtcNow;
                 await _libraryRepository.UpdateLastScan(localLibrary);
+
+                sw.Stop();
+                _logger.LogDebug(
+                    "Scan of library {Name} completed in {Duration}",
+                    localLibrary.Name,
+                    TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds));
             }
             else
             {

ErsatzTV.Application/Movies/Mapper.cs

@@ -16,7 +16,8 @@ namespace ErsatzTV.Application.Movies
                 Artwork(metadata, ArtworkKind.Poster),
                 Artwork(metadata, ArtworkKind.FanArt),
                 metadata.Genres.Map(g => g.Name).ToList(),
-                metadata.Tags.Map(t => t.Name).ToList());
+                metadata.Tags.Map(t => t.Name).ToList(),
+                metadata.Studios.Map(s => s.Name).ToList());
         }
 
         private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -9,5 +9,6 @@ namespace ErsatzTV.Application.Movies
         string Poster,
         string FanArt,
         List<string> Genres,
-        List<string> Tags);
+        List<string> Tags,
+        List<string> Studios);
 }

ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs

@@ -1,9 +1,11 @@
-using System.Threading;
+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
@@ -13,20 +15,24 @@ namespace ErsatzTV.Application.Plex.Commands
         private readonly IEntityLocker _entityLocker;
         private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlexSecretStore _plexSecretStore;
+        private readonly ISearchIndex _searchIndex;
 
         public SignOutOfPlexHandler(
             IMediaSourceRepository mediaSourceRepository,
             IPlexSecretStore plexSecretStore,
-            IEntityLocker entityLocker)
+            IEntityLocker entityLocker,
+            ISearchIndex searchIndex)
         {
             _mediaSourceRepository = mediaSourceRepository;
             _plexSecretStore = plexSecretStore;
             _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
         }
 
         public async Task<Either<BaseError, Unit>> Handle(SignOutOfPlex request, CancellationToken cancellationToken)
         {
-            await _mediaSourceRepository.DeleteAllPlex();
+            List<int> ids = await _mediaSourceRepository.DeleteAllPlex();
+            await _searchIndex.RemoveItems(ids);
             await _plexSecretStore.DeleteAll();
             _entityLocker.UnlockPlex();
 

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/SynchronizePlexMediaSourcesHandler.cs

@@ -64,25 +64,24 @@ namespace ErsatzTV.Application.Plex.Commands
             await 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);
                 });
         }
 

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/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/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/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -1,17 +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
@@ -19,27 +16,26 @@ namespace ErsatzTV.Application.Streaming.Queries
     public class
         GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<GetPlayoutItemProcessByChannelNumber>
     {
+        private readonly IConfigElementRepository _configElementRepository;
         private readonly FFmpegProcessService _ffmpegProcessService;
         private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILogger<GetPlayoutItemProcessByChannelNumberHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlayoutRepository _playoutRepository;
+        private readonly IPlexPathReplacementService _plexPathReplacementService;
 
         public GetPlayoutItemProcessByChannelNumberHandler(
             IChannelRepository channelRepository,
             IConfigElementRepository configElementRepository,
             IPlayoutRepository playoutRepository,
-            IMediaSourceRepository mediaSourceRepository,
             FFmpegProcessService ffmpegProcessService,
             ILocalFileSystem localFileSystem,
-            ILogger<GetPlayoutItemProcessByChannelNumberHandler> logger)
+            IPlexPathReplacementService plexPathReplacementService)
             : base(channelRepository, configElementRepository)
         {
+            _configElementRepository = configElementRepository;
             _playoutRepository = playoutRepository;
-            _mediaSourceRepository = mediaSourceRepository;
             _ffmpegProcessService = ffmpegProcessService;
             _localFileSystem = localFileSystem;
-            _logger = logger;
+            _plexPathReplacementService = plexPathReplacementService;
         }
 
         protected override async Task<Either<BaseError, Process>> GetProcess(
@@ -54,7 +50,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                 .BindT(ValidatePlayoutItemPath);
 
             return await maybePlayoutItem.Match(
-                playoutItemWithPath =>
+                async playoutItemWithPath =>
                 {
                     MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem switch
                     {
@@ -63,14 +59,18 @@ namespace ErsatzTV.Application.Streaming.Queries
                         _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                     };
 
+                    bool saveReports = await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                        .Map(result => result.IfNone(false));
+
                     return Right<BaseError, Process>(
-                        _ffmpegProcessService.ForPlayoutItem(
+                        await _ffmpegProcessService.ForPlayoutItem(
                             ffmpegPath,
+                            saveReports,
                             channel,
                             version,
                             playoutItemWithPath.Path,
                             playoutItemWithPath.PlayoutItem.StartOffset,
-                            now)).AsTask();
+                            now));
                 },
                 async error =>
                 {
@@ -160,33 +160,16 @@ namespace ErsatzTV.Application.Streaming.Queries
             string path = file.Path;
             return playoutItem.MediaItem switch
             {
-                PlexMovie plexMovie => await GetReplacementPlexPath(plexMovie.LibraryPathId, path),
-                PlexEpisode plexEpisode => await GetReplacementPlexPath(plexEpisode.LibraryPathId, path),
+                PlexMovie plexMovie => await _plexPathReplacementService.GetReplacementPlexPath(
+                    plexMovie.LibraryPathId,
+                    path),
+                PlexEpisode plexEpisode => await _plexPathReplacementService.GetReplacementPlexPath(
+                    plexEpisode.LibraryPathId,
+                    path),
                 _ => path
             };
         }
 
-        private async Task<string> GetReplacementPlexPath(int libraryPathId, string path)
-        {
-            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);
-        }
-
         private record PlayoutItemWithPath(PlayoutItem PlayoutItem, string Path);
     }
 }

ErsatzTV.Application/Television/Mapper.cs

@@ -16,7 +16,9 @@ namespace ErsatzTV.Application.Television
                 show.ShowMetadata.HeadOrNone().Map(GetPoster).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(GetFanArt).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Genres.Map(g => g.Name).ToList()).IfNone(new List<string>()),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()));
+                show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()),
+                show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList())
+                    .IfNone(new List<string>()));
 
         internal static TelevisionSeasonViewModel ProjectToViewModel(Season season) =>
             new(

ErsatzTV.Application/Television/TelevisionShowViewModel.cs

@@ -10,5 +10,6 @@ namespace ErsatzTV.Application.Television
         string Poster,
         string FanArt,
         List<string> Genres,
-        List<string> Tags);
+        List<string> Tags,
+        List<string> Studios);
 }

ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj

@@ -17,7 +17,7 @@
       <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
       <PackageReference Include="RestSharp" Version="106.11.7" />
       <PackageReference Include="Serilog" Version="2.10.0" />
-      <PackageReference Include="Serilog.Extensions.Hosting" Version="3.1.0" />
+      <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
       <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
     </ItemGroup>

ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj

@@ -8,13 +8,13 @@
       <PackageReference Include="FluentAssertions" Version="5.10.3" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-      <PackageReference Include="Moq" Version="4.16.0" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+      <PackageReference Include="Moq" Version="4.16.1" />
       <PackageReference Include="NUnit" Version="3.13.1" />
       <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
-      <PackageReference Include="Serilog.Sinks.Debug" Version="1.0.1" />
+      <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs

@@ -18,7 +18,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var builder = new FFmpegComplexFilterBuilder();
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsNone.Should().BeTrue();
             }
@@ -30,15 +30,15 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithAlignedAudio(duration);
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
-                        filter.ComplexFilter.Should().Be($"[0:a]apad=whole_dur={duration.TotalMilliseconds}ms[a]");
+                        filter.ComplexFilter.Should().Be($"[0:1]apad=whole_dur={duration.TotalMilliseconds}ms[a]");
                         filter.AudioLabel.Should().Be("[a]");
-                        filter.VideoLabel.Should().Be("0:v");
+                        filter.VideoLabel.Should().Be("0:0");
                     });
             }
 
@@ -50,36 +50,36 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     .WithAlignedAudio(duration)
                     .WithDeinterlace(true);
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
                         filter.ComplexFilter.Should().Be(
-                            $"[0:a]apad=whole_dur={duration.TotalMilliseconds}ms[a];[0:v]yadif=1[v]");
+                            $"[0:1]apad=whole_dur={duration.TotalMilliseconds}ms[a];[0:0]yadif=1[v]");
                         filter.AudioLabel.Should().Be("[a]");
                         filter.VideoLabel.Should().Be("[v]");
                     });
             }
 
             [Test]
-            [TestCase(true, false, false, "[0:v]yadif=1[v]", "[v]")]
-            [TestCase(true, true, false, "[0:v]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
-            [TestCase(true, false, true, "[0:v]yadif=1,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
+            [TestCase(true, false, false, "[0:0]yadif=1[v]", "[v]")]
+            [TestCase(true, true, false, "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
+            [TestCase(true, false, true, "[0:0]yadif=1,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:v]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
+                "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
                 "[v]")]
-            [TestCase(false, true, false, "[0:v]scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
-            [TestCase(false, false, true, "[0:v]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
+            [TestCase(false, true, false, "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
+            [TestCase(false, false, true, "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:v]scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
+                "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
                 "[v]")]
             public void Should_Return_Software_Video_Filter(
                 bool deinterlace,
@@ -101,55 +101,55 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
                         filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:a");
+                        filter.AudioLabel.Should().Be("0:1");
                         filter.VideoLabel.Should().Be(expectedVideoLabel);
                     });
             }
 
             [Test]
-            [TestCase(true, false, false, "[0:v]deinterlace_qsv[v]", "[v]")]
+            [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
             [TestCase(
                 true,
                 true,
                 false,
-                "[0:v]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:v]deinterlace_qsv,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:v]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:v]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:v]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:v]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             public void Should_Return_QSV_Video_Filter(
                 bool deinterlace,
@@ -172,74 +172,74 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
                         filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:a");
+                        filter.AudioLabel.Should().Be("0:1");
                         filter.VideoLabel.Should().Be(expectedVideoLabel);
                     });
             }
 
             [Test]
             // TODO: get yadif_cuda working in docker
-            // [TestCase(true, false, false, "[0:v]yadif_cuda[v]", "[v]")]
+            // [TestCase(true, false, false, "[0:V]yadif_cuda[v]", "[v]")]
             // [TestCase(
             //     true,
             //     true,
             //     false,
-            //     "[0:v]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,hwupload[v]",
+            //     "[0:V]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,hwupload[v]",
             //     "[v]")]
             // [TestCase(
             //     true,
             //     false,
             //     true,
-            //     "[0:v]yadif_cuda,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            //     "[0:V]yadif_cuda,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
             //     "[v]")]
             // [TestCase(
             //     true,
             //     true,
             //     true,
-            //     "[0:v]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            //     "[0:V]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
             //     "[v]")]
             [TestCase(
                 true,
                 true,
                 false,
-                "[0:v]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:v]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:v]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:v]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:v]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:v]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_NVENC_Video_Filter(
                 bool deinterlace,
@@ -262,104 +262,104 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
                         filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:a");
+                        filter.AudioLabel.Should().Be("0:1");
                         filter.VideoLabel.Should().Be(expectedVideoLabel);
                     });
             }
 
             [Test]
-            [TestCase("h264", true, false, false, "[0:v]deinterlace_vaapi[v]", "[v]")]
+            [TestCase("h264", true, false, false, "[0:0]deinterlace_vaapi[v]", "[v]")]
             [TestCase(
                 "h264",
                 true,
                 true,
                 false,
-                "[0:v]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 false,
                 true,
-                "[0:v]deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 true,
                 true,
-                "[0:v]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 false,
-                "[0:v]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 false,
                 true,
-                "[0:v]hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 true,
-                "[0:v]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
-            [TestCase("mpeg4", true, false, false, "[0:v]hwupload,deinterlace_vaapi[v]", "[v]")]
+            [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 true,
                 false,
-                "[0:v]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 false,
                 true,
-                "[0:v]hwupload,deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 true,
                 true,
-                "[0:v]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 false,
                 true,
                 false,
-                "[0:v]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 false,
                 false,
                 true,
-                "[0:v]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 false,
                 true,
                 true,
-                "[0:v]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_VAAPI_Video_Filter(
                 string codec,
@@ -384,14 +384,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build();
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
                         filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:a");
+                        filter.AudioLabel.Should().Be("0:1");
                         filter.VideoLabel.Should().Be(expectedVideoLabel);
                     });
             }

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsServiceTests.cs

@@ -25,6 +25,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -40,6 +42,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -55,6 +59,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -72,6 +78,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -89,6 +97,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -104,6 +114,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -121,6 +133,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     now,
                     now.AddMinutes(5));
 
@@ -139,6 +153,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     now,
                     now.AddMinutes(5));
 
@@ -155,6 +171,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -177,6 +195,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -199,6 +219,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -221,6 +243,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -244,6 +268,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -267,6 +293,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -290,6 +318,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -315,6 +345,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -337,12 +369,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "mpeg2video" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -365,12 +399,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "mpeg2video" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -392,12 +428,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "libx264" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "libx264" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -420,12 +458,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "mpeg2video" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -452,6 +492,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -473,12 +515,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "mpeg2video" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -505,6 +549,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -527,12 +573,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 // not anamorphic
                 var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1", VideoCodec = "mpeg2video" };
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -550,12 +598,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioCodec = "aac"
                 };
 
-                var version = new MediaVersion { AudioCodec = "aac" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "aac" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -571,12 +621,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioCodec = "aac"
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -592,12 +644,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioCodec = "aac"
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -613,12 +667,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioCodec = "aac"
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.HttpLiveStreaming,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -634,12 +690,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioBitrate = 2424
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -655,12 +713,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioBufferSize = 2424
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -678,12 +738,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioChannels = 6
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -701,12 +763,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioSampleRate = 48
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -723,12 +787,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioChannels = 6
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -745,12 +811,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     AudioSampleRate = 48
                 };
 
-                var version = new MediaVersion { AudioCodec = "ac3" };
+                var version = new MediaVersion();
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
@@ -775,6 +843,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode.TransportStream,
                     ffmpegProfile,
                     new MediaVersion(),
+                    new MediaStream(),
+                    new MediaStream(),
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -36,6 +36,8 @@ namespace ErsatzTV.Core.Tests.Fakes
             _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
         }
 
+        public Unit EnsureFolderExists(string folder) => Unit.Default;
+
         public DateTime GetLastWriteTime(string path) =>
             Optional(_files.SingleOrDefault(f => f.Path == path))
                 .Map(f => f.LastWriteTime)

ErsatzTV.Core.Tests/Fakes/FakeMovieWithPath.cs

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

ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 
 namespace ErsatzTV.Core.Tests.Fakes
@@ -11,12 +12,6 @@ namespace ErsatzTV.Core.Tests.Fakes
     {
         public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
 
-        public Task<bool> Update(Show show) => throw new NotSupportedException();
-
-        public Task<bool> Update(Season season) => throw new NotSupportedException();
-
-        public Task<bool> Update(Episode episode) => throw new NotSupportedException();
-
         public Task<List<Show>> GetAllShows() => throw new NotSupportedException();
 
         public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();
@@ -26,6 +21,8 @@ namespace ErsatzTV.Core.Tests.Fakes
         public Task<List<ShowMetadata>> GetPagedShows(int pageNumber, int pageSize) =>
             throw new NotSupportedException();
 
+        public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
+
         public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();
 
         public Task<List<Season>> GetAllSeasons() => throw new NotSupportedException();
@@ -49,7 +46,7 @@ namespace ErsatzTV.Core.Tests.Fakes
         public Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata) =>
             throw new NotSupportedException();
 
-        public Task<Either<BaseError, Show>>
+        public Task<Either<BaseError, MediaItemScanResult<Show>>>
             AddShow(int libraryPathId, string showFolder, ShowMetadata metadata) =>
             throw new NotSupportedException();
 
@@ -65,9 +62,11 @@ namespace ErsatzTV.Core.Tests.Fakes
 
         public Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath) => throw new NotSupportedException();
 
-        public Task<Unit> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();
+        public Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();
 
-        public Task<Either<BaseError, PlexShow>> GetOrAddPlexShow(PlexLibrary library, PlexShow item) =>
+        public Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
+            PlexLibrary library,
+            PlexShow item) =>
             throw new NotSupportedException();
 
         public Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item) =>
@@ -76,9 +75,12 @@ namespace ErsatzTV.Core.Tests.Fakes
         public Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item) =>
             throw new NotSupportedException();
 
-        public Task<Unit> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
+        public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
+        public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();
 
-        public Task<Unit> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
+        public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
+
+        public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
             throw new NotSupportedException();
 
         public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
@@ -86,5 +88,13 @@ namespace ErsatzTV.Core.Tests.Fakes
 
         public Task<Unit> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys) =>
             throw new NotSupportedException();
+
+        public Task<Unit> SetEpisodeNumber(Episode episode, int episodeNumber) => throw new NotSupportedException();
+
+        public Task<bool> Update(Show show) => throw new NotSupportedException();
+
+        public Task<bool> Update(Season season) => throw new NotSupportedException();
+
+        public Task<bool> Update(Episode episode) => throw new NotSupportedException();
     }
 }

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -9,6 +9,7 @@ using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
 using ErsatzTV.Core.Tests.Fakes;
 using FluentAssertions;
@@ -44,20 +45,24 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository = new Mock<IMovieRepository>();
                 _movieRepository.Setup(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()))
                     .Returns(
-                        (LibraryPath _, string path) => Right<BaseError, Movie>(new FakeMovieWithPath(path)).AsTask());
+                        (LibraryPath _, string path) =>
+                            Right<BaseError, MediaItemScanResult<Movie>>(new FakeMovieWithPath(path)).AsTask());
                 _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
                     .Returns(new List<string>().AsEnumerable().AsTask());
 
                 _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
                 _localMetadataProvider = new Mock<ILocalMetadataProvider>();
 
+                _localStatisticsProvider.Setup(x => x.RefreshStatistics(It.IsAny<string>(), It.IsAny<MediaItem>()))
+                    .Returns<string, MediaItem>((_, _) => Right<BaseError, bool>(true).AsTask());
+
                 // fallback metadata adds metadata to a movie, so we need to replicate that here
                 _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<MediaItem>()))
                     .Returns(
                         (MediaItem mediaItem) =>
                         {
                             ((Movie) mediaItem).MovieMetadata = new List<MovieMetadata> { new() };
-                            return Unit.Default.AsTask();
+                            return Task.FromResult(true);
                         });
 
                 _imageCache = new Mock<IImageCache>();
@@ -76,7 +81,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Path = BadFakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsLeft.Should().BeTrue();
                 result.IfLeft(error => error.Should().BeOfType<MediaSourceInaccessible>());
@@ -96,7 +104,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -104,11 +115,14 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
             }
 
@@ -129,7 +143,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -137,11 +154,15 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshSidecarMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath), metadataPath),
+                    x => x.RefreshSidecarMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
+                        metadataPath),
                     Times.Once);
             }
 
@@ -162,7 +183,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -170,11 +194,15 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshSidecarMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath), metadataPath),
+                    x => x.RefreshSidecarMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
+                        metadataPath),
                     Times.Once);
             }
 
@@ -199,7 +227,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -207,11 +238,61 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                    Times.Once);
+
+                _imageCache.Verify(
+                    x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
+                    Times.Once);
+            }
+
+            [Test]
+            public async Task NewMovie_Statistics_And_FallbackMetadata_And_FolderPoster(
+                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+                string videoExtension,
+                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
+                string imageExtension)
+            {
+                string moviePath = Path.Combine(
+                    FakeRoot,
+                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+                string posterPath = Path.Combine(
+                    Path.GetDirectoryName(moviePath) ?? string.Empty,
+                    $"folder.{imageExtension}");
+
+                MovieFolderScanner service = GetService(
+                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                    new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
+                );
+                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
+
+                result.IsRight.Should().BeTrue();
+
+                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+                _localStatisticsProvider.Verify(
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                    Times.Once);
+
+                _localMetadataProvider.Verify(
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _imageCache.Verify(
@@ -240,7 +321,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -248,11 +332,14 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _imageCache.Verify(
@@ -280,7 +367,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -288,11 +378,14 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
             }
 
@@ -316,7 +409,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -324,11 +420,14 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
             }
 
@@ -346,7 +445,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -354,11 +456,14 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
 
                 _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(FFprobePath, It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
 
                 _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(It.Is<FakeMovieWithPath>(i => i.Path == moviePath)),
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                     Times.Once);
             }
 
@@ -378,7 +483,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -402,7 +510,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 );
                 var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
 
-                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+                Either<BaseError, Unit> result = await service.ScanFolder(
+                    libraryPath,
+                    FFprobePath,
+                    DateTimeOffset.MinValue);
 
                 result.IsRight.Should().BeTrue();
 
@@ -417,7 +528,9 @@ namespace ErsatzTV.Core.Tests.Metadata
                     _movieRepository.Object,
                     _localStatisticsProvider.Object,
                     _localMetadataProvider.Object,
+                    new Mock<IMetadataRepository>().Object,
                     _imageCache.Object,
+                    new Mock<ISearchIndex>().Object,
                     new Mock<ILogger<MovieFolderScanner>>().Object
                 );
         }

ErsatzTV.Core.Tests/Plex/PlexPathReplacementServiceTests.cs

@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
+using ErsatzTV.Core.Plex;
+using FluentAssertions;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Plex
+{
+    [TestFixture]
+    public class PlexPathReplacementServiceTests
+    {
+        [Test]
+        public async Task PlexWindows_To_EtvWindows()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task PlexWindows_To_EtvLinux()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task PlexWindows_To_EtvLinux_UncPath()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task PlexWindows_To_EtvLinux_UncPathWithTrailingSlash()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                    LocalPath = @"/mnt/something else/Some Shared Folder/",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task PlexLinux_To_EtvWindows()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task PlexLinux_To_EtvLinux()
+        {
+            var replacements = new List<PlexPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    PlexPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new PlexPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementPlexPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+    }
+}

ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs

@@ -15,6 +15,54 @@ namespace ErsatzTV.Core.Tests.Scheduling
         // this seed will produce (shuffle) 1-10 in order
         private const int MagicSeed = 670596;
 
+        [Test]
+        public void Episodes_Should_Not_Duplicate_When_Reshuffling()
+        {
+            List<MediaItem> contents = Episodes(10);
+
+            // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
+            var state = new CollectionEnumeratorState { Seed = 8 };
+
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+
+            var list = new List<int>();
+            for (var i = 1; i <= 1000; i++)
+            {
+                shuffledContent.Current.IsSome.Should().BeTrue();
+                shuffledContent.Current.Do(x => list.Add(x.Id));
+                shuffledContent.MoveNext();
+            }
+
+            for (var i = 0; i < list.Count - 1; i++)
+            {
+                if (list[i] == list[i + 1])
+                {
+                    Assert.Fail("List contains duplicate items");
+                }
+            }
+        }
+
+        [Test]
+        [Timeout(2000)]
+        public void Duplicate_Check_Should_Ignore_Single_Item()
+        {
+            List<MediaItem> contents = Episodes(1);
+
+            var state = new CollectionEnumeratorState();
+
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+
+            var list = new List<int>();
+            for (var i = 1; i <= 10; i++)
+            {
+                shuffledContent.Current.IsSome.Should().BeTrue();
+                shuffledContent.Current.Do(x => list.Add(x.Id));
+                shuffledContent.MoveNext();
+            }
+
+            list.Should().Equal(1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+        }
+
         [Test]
         public void Episodes_Should_Shuffle()
         {

ErsatzTV.Core/Domain/Channel.cs

@@ -16,8 +16,7 @@ namespace ErsatzTV.Core.Domain
         public FFmpegProfile FFmpegProfile { get; set; }
         public StreamingMode StreamingMode { get; set; }
         public List<Playout> Playouts { get; set; }
-
         public List<Artwork> Artwork { get; set; }
-        // public SourceMode Mode { get; set; }
+        public string PreferredLanguageCode { get; set; }
     }
 }

ErsatzTV.Core/Domain/ConfigElementKey.cs

@@ -10,5 +10,8 @@
         public static ConfigElementKey FFprobePath => new("ffmpeg.ffprobe_path");
         public static ConfigElementKey FFmpegDefaultProfileId => new("ffmpeg.default_profile_id");
         public static ConfigElementKey FFmpegDefaultResolutionId => new("ffmpeg.default_resolution_id");
+        public static ConfigElementKey FFmpegSaveReports => new("ffmpeg.save_reports");
+        public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
+        public static ConfigElementKey SearchIndexVersion => new("search_index.version");
     }
 }

ErsatzTV.Core/Domain/MediaItem/MediaStream.cs

@@ -0,0 +1,18 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class MediaStream
+    {
+        public int Id { get; set; }
+        public int Index { get; set; }
+        public string Codec { get; set; }
+        public string Profile { get; set; }
+        public MediaStreamKind MediaStreamKind { get; set; }
+        public string Language { get; set; }
+        public int Channels { get; set; }
+        public string Title { get; set; }
+        public bool Default { get; set; }
+        public bool Forced { get; set; }
+        public int MediaVersionId { get; set; }
+        public MediaVersion MediaVersion { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/MediaStreamKind.cs

@@ -0,0 +1,9 @@
+namespace ErsatzTV.Core.Domain
+{
+    public enum MediaStreamKind
+    {
+        Video = 1,
+        Audio = 2,
+        Subtitle = 3
+    }
+}

ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs

@@ -8,15 +8,21 @@ namespace ErsatzTV.Core.Domain
     {
         public int Id { get; set; }
         public string Name { get; set; }
-
         public List<MediaFile> MediaFiles { get; set; }
-
+        public List<MediaStream> Streams { get; set; }
         public TimeSpan Duration { get; set; }
         public string SampleAspectRatio { get; set; }
         public string DisplayAspectRatio { get; set; }
+
+        [Obsolete("Use MediaSource instead")]
         public string VideoCodec { get; set; }
+
+        [Obsolete("Use MediaSource instead")]
         public string VideoProfile { get; set; }
+
+        [Obsolete("Use MediaSource instead")]
         public string AudioCodec { get; set; }
+
         public VideoScanKind VideoScanKind { get; set; }
         public DateTime DateAdded { get; set; }
         public DateTime DateUpdated { get; set; }

ErsatzTV.Core/Domain/MediaSource/PlexMediaSource.cs

@@ -6,6 +6,8 @@ namespace ErsatzTV.Core.Domain
     {
         public string ServerName { get; set; }
         public string ProductVersion { get; set; }
+        public string Platform { get; set; }
+        public string PlatformVersion { get; set; }
         public string ClientIdentifier { get; set; }
 
         // public bool IsOwned { get; set; }

ErsatzTV.Core/Domain/Metadata/Metadata.cs

@@ -17,5 +17,6 @@ namespace ErsatzTV.Core.Domain
         public List<Artwork> Artwork { get; set; }
         public List<Genre> Genres { get; set; }
         public List<Tag> Tags { get; set; }
+        public List<Studio> Studios { get; set; }
     }
 }

ErsatzTV.Core/Domain/Metadata/Studio.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class Studio
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+    }
+}

ErsatzTV.Core/Domain/SourceMode.cs

@@ -1,9 +0,0 @@
-namespace ErsatzTV.Core.Domain
-{
-    public enum SourceMode
-    {
-        Transcode,
-        DirectPlay,
-        DirectPaths
-    }
-}

ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs

@@ -4,7 +4,7 @@
     {
         public override string ToString() =>
             $@"ffconcat version 1.0
-file {Scheme}://{Host}/ffmpeg/stream/{ChannelNumber}
-file {Scheme}://{Host}/ffmpeg/stream/{ChannelNumber}";
+file http://localhost:8409/ffmpeg/stream/{ChannelNumber}
+file http://localhost:8409/ffmpeg/stream/{ChannelNumber}";
     }
 }

ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs

@@ -54,12 +54,12 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public Option<FFmpegComplexFilter> Build()
+        public Option<FFmpegComplexFilter> Build(int videoStreamIndex, int audioStreamIndex)
         {
             var complexFilter = new StringBuilder();
 
-            var videoLabel = "0:v";
-            var audioLabel = "0:a";
+            var videoLabel = $"0:{videoStreamIndex}";
+            var audioLabel = $"0:{audioStreamIndex}";
 
             HardwareAccelerationKind acceleration = _hardwareAccelerationKind.IfNone(HardwareAccelerationKind.None);
             bool isHardwareDecode = acceleration switch

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs

@@ -45,6 +45,8 @@ namespace ErsatzTV.Core.FFmpeg
             StreamingMode streamingMode,
             FFmpegProfile ffmpegProfile,
             MediaVersion version,
+            MediaStream videoStream,
+            MediaStream audioStream,
             DateTimeOffset start,
             DateTimeOffset now)
         {
@@ -85,7 +87,7 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
-                        NeedToNormalizeVideoCodec(ffmpegProfile, version))
+                        NeedToNormalizeVideoCodec(ffmpegProfile, videoStream))
                     {
                         result.VideoCodec = ffmpegProfile.VideoCodec;
                         result.VideoBitrate = ffmpegProfile.VideoBitrate;
@@ -96,7 +98,7 @@ namespace ErsatzTV.Core.FFmpeg
                         result.VideoCodec = "copy";
                     }
 
-                    if (NeedToNormalizeAudioCodec(ffmpegProfile, version))
+                    if (NeedToNormalizeAudioCodec(ffmpegProfile, audioStream))
                     {
                         result.AudioCodec = ffmpegProfile.AudioCodec;
                         result.AudioBitrate = ffmpegProfile.AudioBitrate;
@@ -104,7 +106,11 @@ namespace ErsatzTV.Core.FFmpeg
 
                         if (ffmpegProfile.NormalizeAudio)
                         {
-                            result.AudioChannels = ffmpegProfile.AudioChannels;
+                            if (audioStream.Channels != ffmpegProfile.AudioChannels)
+                            {
+                                result.AudioChannels = ffmpegProfile.AudioChannels;
+                            }
+
                             result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
                             result.AudioDuration = version.Duration;
                         }
@@ -152,11 +158,11 @@ namespace ErsatzTV.Core.FFmpeg
         private static bool IsOddSize(MediaVersion version) =>
             version.Height % 2 == 1 || version.Width % 2 == 1;
 
-        private static bool NeedToNormalizeVideoCodec(FFmpegProfile ffmpegProfile, MediaVersion version) =>
-            ffmpegProfile.NormalizeVideoCodec && ffmpegProfile.VideoCodec != version.VideoCodec;
+        private static bool NeedToNormalizeVideoCodec(FFmpegProfile ffmpegProfile, MediaStream videoStream) =>
+            ffmpegProfile.NormalizeVideoCodec && ffmpegProfile.VideoCodec != videoStream.Codec;
 
-        private static bool NeedToNormalizeAudioCodec(FFmpegProfile ffmpegProfile, MediaVersion version) =>
-            ffmpegProfile.NormalizeAudioCodec && ffmpegProfile.AudioCodec != version.AudioCodec;
+        private static bool NeedToNormalizeAudioCodec(FFmpegProfile ffmpegProfile, MediaStream audioStream) =>
+            ffmpegProfile.NormalizeAudioCodec && ffmpegProfile.AudioCodec != audioStream.Codec;
 
         private static IDisplaySize CalculateScaledSize(FFmpegProfile ffmpegProfile, MediaVersion version)
         {

ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs

@@ -21,6 +21,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -39,9 +40,14 @@ namespace ErsatzTV.Core.FFmpeg
 
         private readonly List<string> _arguments = new();
         private readonly string _ffmpegPath;
+        private readonly bool _saveReports;
         private FFmpegComplexFilterBuilder _complexFilterBuilder = new();
 
-        public FFmpegProcessBuilder(string ffmpegPath) => _ffmpegPath = ffmpegPath;
+        public FFmpegProcessBuilder(string ffmpegPath, bool saveReports)
+        {
+            _ffmpegPath = ffmpegPath;
+            _saveReports = saveReports;
+        }
 
         public FFmpegProcessBuilder WithThreads(int threads)
         {
@@ -323,12 +329,12 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegProcessBuilder WithFilterComplex()
+        public FFmpegProcessBuilder WithFilterComplex(int videoStreamIndex, int audioStreamIndex)
         {
-            var videoLabel = "0:v";
-            var audioLabel = "0:a";
+            var videoLabel = $"0:v:{videoStreamIndex}";
+            var audioLabel = $"0:a:{audioStreamIndex}";
 
-            Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build();
+            Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(videoStreamIndex, audioStreamIndex);
             maybeFilter.IfSome(
                 filter =>
                 {
@@ -365,6 +371,12 @@ namespace ErsatzTV.Core.FFmpeg
                 StandardOutputEncoding = Encoding.UTF8
             };
 
+            if (_saveReports)
+            {
+                string fileName = Path.Combine(FileSystemLayout.FFmpegReportsFolder, "%p-%t.log");
+                startInfo.EnvironmentVariables.Add("FFREPORT", $"file={fileName}:level=32");
+            }
+
             foreach (string argument in _arguments)
             {
                 startInfo.ArgumentList.Add(argument);

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using LanguageExt;
@@ -8,34 +9,46 @@ namespace ErsatzTV.Core.FFmpeg
 {
     public class FFmpegProcessService
     {
+        private readonly IFFmpegStreamSelector _ffmpegStreamSelector;
         private readonly FFmpegPlaybackSettingsCalculator _playbackSettingsCalculator;
 
-        public FFmpegProcessService(FFmpegPlaybackSettingsCalculator ffmpegPlaybackSettingsService) =>
+        public FFmpegProcessService(
+            FFmpegPlaybackSettingsCalculator ffmpegPlaybackSettingsService,
+            IFFmpegStreamSelector ffmpegStreamSelector)
+        {
             _playbackSettingsCalculator = ffmpegPlaybackSettingsService;
+            _ffmpegStreamSelector = ffmpegStreamSelector;
+        }
 
-        public Process ForPlayoutItem(
+        public async Task<Process> ForPlayoutItem(
             string ffmpegPath,
+            bool saveReports,
             Channel channel,
             MediaVersion version,
             string path,
             DateTimeOffset start,
             DateTimeOffset now)
         {
+            MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, version);
+            MediaStream audioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, version);
+
             FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.CalculateSettings(
                 channel.StreamingMode,
                 channel.FFmpegProfile,
                 version,
+                videoStream,
+                audioStream,
                 start,
                 now);
 
-            FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath)
+            FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, saveReports)
                 .WithThreads(playbackSettings.ThreadCount)
                 .WithHardwareAcceleration(playbackSettings.HardwareAcceleration)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
                 .WithSeek(playbackSettings.StreamSeek)
-                .WithInputCodec(path, playbackSettings.HardwareAcceleration, version.VideoCodec);
+                .WithInputCodec(path, playbackSettings.HardwareAcceleration, videoStream.Codec);
 
             playbackSettings.ScaledSize.Match(
                 scaledSize =>
@@ -50,7 +63,8 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     builder = builder
-                        .WithAlignedAudio(playbackSettings.AudioDuration).WithFilterComplex();
+                        .WithAlignedAudio(playbackSettings.AudioDuration)
+                        .WithFilterComplex(videoStream.Index, audioStream.Index);
                 },
                 () =>
                 {
@@ -60,19 +74,19 @@ namespace ErsatzTV.Core.FFmpeg
                             .WithDeinterlace(playbackSettings.Deinterlace)
                             .WithBlackBars(channel.FFmpegProfile.Resolution)
                             .WithAlignedAudio(playbackSettings.AudioDuration)
-                            .WithFilterComplex();
+                            .WithFilterComplex(videoStream.Index, audioStream.Index);
                     }
                     else if (playbackSettings.Deinterlace)
                     {
                         builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
                             .WithAlignedAudio(playbackSettings.AudioDuration)
-                            .WithFilterComplex();
+                            .WithFilterComplex(videoStream.Index, audioStream.Index);
                     }
                     else
                     {
                         builder = builder
                             .WithAlignedAudio(playbackSettings.AudioDuration)
-                            .WithFilterComplex();
+                            .WithFilterComplex(videoStream.Index, audioStream.Index);
                     }
                 });
 
@@ -91,7 +105,7 @@ namespace ErsatzTV.Core.FFmpeg
 
             IDisplaySize desiredResolution = channel.FFmpegProfile.Resolution;
 
-            FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath)
+            FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false)
                 .WithThreads(1)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
@@ -114,13 +128,13 @@ namespace ErsatzTV.Core.FFmpeg
         {
             FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
 
-            return new FFmpegProcessBuilder(ffmpegPath)
+            return new FFmpegProcessBuilder(ffmpegPath, false)
                 .WithThreads(1)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
                 .WithInfiniteLoop()
-                .WithConcat($"{scheme}://{host}/ffmpeg/concat/{channel.Number}")
+                .WithConcat($"http://localhost:8409/ffmpeg/concat/{channel.Number}")
                 .WithMetadata(channel)
                 .WithFormat("mpegts")
                 .WithPipe()

ErsatzTV.Core/FFmpeg/FFmpegStreamSelector.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Core.FFmpeg
+{
+    public class FFmpegStreamSelector : IFFmpegStreamSelector
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly ILogger<FFmpegStreamSelector> _logger;
+
+        public FFmpegStreamSelector(
+            ILogger<FFmpegStreamSelector> logger,
+            IConfigElementRepository configElementRepository)
+        {
+            _logger = logger;
+            _configElementRepository = configElementRepository;
+        }
+
+        public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
+            version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+
+        public async Task<MediaStream> SelectAudioStream(Channel channel, MediaVersion version)
+        {
+            var audioStreams = version.Streams.Filter(s => s.MediaStreamKind == MediaStreamKind.Audio).ToList();
+
+            string language = (channel.PreferredLanguageCode ?? string.Empty).ToLowerInvariant();
+            if (string.IsNullOrWhiteSpace(language))
+            {
+                _logger.LogDebug("Channel {Number} has no preferred language code", channel.Number);
+                Option<string> maybeDefaultLanguage = await _configElementRepository.GetValue<string>(
+                    ConfigElementKey.FFmpegPreferredLanguageCode);
+                maybeDefaultLanguage.Match(
+                    lang => language = lang.ToLowerInvariant(),
+                    () =>
+                    {
+                        _logger.LogDebug("FFmpeg has no preferred language code; falling back to {Code}", "eng");
+                        language = "eng";
+                    });
+            }
+
+            var correctLanguage = audioStreams.Filter(
+                s => string.Equals(
+                    s.Language,
+                    language,
+                    StringComparison.InvariantCultureIgnoreCase)).ToList();
+            if (correctLanguage.Any())
+            {
+                _logger.LogDebug(
+                    "Found {Count} audio streams with preferred language code {Code}; selecting stream with most channels",
+                    correctLanguage.Count,
+                    language);
+
+                return correctLanguage.OrderByDescending(s => s.Channels).Head();
+            }
+
+            _logger.LogDebug(
+                "Unable to find audio stream with preferred language code {Code}; selecting stream with most channels",
+                language);
+
+            return audioStreams.OrderByDescending(s => s.Channels).Head();
+        }
+    }
+}

ErsatzTV.Core/FileSystemLayout.cs

@@ -19,6 +19,9 @@ namespace ErsatzTV.Core
 
         public static readonly string PlexSecretsPath = Path.Combine(AppDataFolder, "plex-secrets.json");
 
+        public static readonly string FFmpegReportsFolder = Path.Combine(AppDataFolder, "ffmpeg-reports");
+        public static readonly string SearchIndexFolder = Path.Combine(AppDataFolder, "search-index");
+
         public static readonly string ArtworkCacheFolder = Path.Combine(AppDataFolder, "cache", "artwork");
 
         public static readonly string PosterCacheFolder = Path.Combine(ArtworkCacheFolder, "posters");

ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegStreamSelector.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Interfaces.FFmpeg
+{
+    public interface IFFmpegStreamSelector
+    {
+        Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version);
+        Task<MediaStream> SelectAudioStream(Channel channel, MediaVersion version);
+    }
+}

ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs

@@ -8,6 +8,7 @@ namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ILocalFileSystem
     {
+        Unit EnsureFolderExists(string folder);
         DateTime GetLastWriteTime(string path);
         bool IsLibraryPathAccessible(LibraryPath libraryPath);
         IEnumerable<string> ListSubdirectories(string folder);

ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs

@@ -1,15 +1,14 @@
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ILocalMetadataProvider
     {
         Task<ShowMetadata> GetMetadataForShow(string showFolder);
-        Task<Unit> RefreshSidecarMetadata(MediaItem mediaItem, string path);
-        Task<Unit> RefreshSidecarMetadata(Show televisionShow, string showFolder);
-        Task<Unit> RefreshFallbackMetadata(MediaItem mediaItem);
-        Task<Unit> RefreshFallbackMetadata(Show televisionShow, string showFolder);
+        Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path);
+        Task<bool> RefreshSidecarMetadata(Show televisionShow, string showFolder);
+        Task<bool> RefreshFallbackMetadata(MediaItem mediaItem);
+        Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs

@@ -6,6 +6,6 @@ namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ILocalStatisticsProvider
     {
-        Task<Either<BaseError, Unit>> RefreshStatistics(string ffprobePath, MediaItem mediaItem);
+        Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/IMovieFolderScanner.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 
@@ -6,6 +7,6 @@ namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface IMovieFolderScanner
     {
-        Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath);
+        Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath, DateTimeOffset lastScan);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ITelevisionFolderScanner.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 
@@ -6,6 +7,6 @@ namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ITelevisionFolderScanner
     {
-        Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath);
+        Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath, DateTimeOffset lastScan);
     }
 }

ErsatzTV.Core/Interfaces/Plex/IPlexPathReplacementService.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace ErsatzTV.Core.Interfaces.Plex
+{
+    public interface IPlexPathReplacementService
+    {
+        Task<string> GetReplacementPlexPath(int libraryPathId, string path);
+    }
+}

ErsatzTV.Core/Interfaces/Repositories/ILibraryRepository.cs

@@ -15,6 +15,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<List<LibraryPath>> GetLocalPaths(int libraryId);
         Task<Option<LibraryPath>> GetPath(int libraryPathId);
         Task<int> CountMediaItemsByPath(int libraryPathId);
+        Task<List<int>> GetMediaIdsByLocalPath(int libraryPathId);
         Task DeleteLocalPath(int libraryPathId);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMediaItemRepository.cs

@@ -9,7 +9,6 @@ namespace ErsatzTV.Core.Interfaces.Repositories
     {
         Task<Option<MediaItem>> Get(int id);
         Task<List<MediaItem>> GetAll();
-        Task<List<MediaItem>> Search(string searchString);
         Task<bool> Update(MediaItem mediaItem);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs

@@ -20,11 +20,23 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<List<PlexPathReplacement>> GetPlexPathReplacementsByLibraryId(int plexLibraryPathId);
         Task<int> CountMediaItems(int id);
         Task Update(LocalMediaSource localMediaSource);
-        Task Update(PlexMediaSource plexMediaSource);
+        Task Update(PlexMediaSource plexMediaSource, List<PlexConnection> toAdd, List<PlexConnection> toDelete);
+
+        Task<Unit> UpdateLibraries(
+            int plexMediaSourceId,
+            List<PlexLibrary> toAdd,
+            List<PlexLibrary> toDelete);
+
+        Task<Unit> UpdatePathReplacements(
+            int plexMediaSourceId,
+            List<PlexPathReplacement> toAdd,
+            List<PlexPathReplacement> toUpdate,
+            List<PlexPathReplacement> toDelete);
+
         Task Update(PlexLibrary plexMediaSourceLibrary);
         Task Delete(int mediaSourceId);
-        Task<Unit> DeleteAllPlex();
-        Task DisablePlexLibrarySync(List<int> libraryIds);
+        Task<List<int>> DeleteAllPlex();
+        Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds);
         Task EnablePlexLibrarySync(IEnumerable<int> libraryIds);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 
@@ -6,10 +7,18 @@ namespace ErsatzTV.Core.Interfaces.Repositories
 {
     public interface IMetadataRepository
     {
-        Task<Unit> RemoveGenre(Genre genre);
-        Task<Unit> UpdateStatistics(MediaVersion mediaVersion);
+        Task<bool> RemoveGenre(Genre genre);
+        Task<bool> RemoveTag(Tag tag);
+        Task<bool> RemoveStudio(Studio studio);
+        Task<bool> Update(Domain.Metadata metadata);
+        Task<bool> Add(Domain.Metadata metadata);
+        Task<bool> UpdateLocalStatistics(int mediaVersionId, MediaVersion incoming, bool updateVersion = true);
+        Task<bool> UpdatePlexStatistics(int mediaVersionId, MediaVersion incoming);
         Task<Unit> UpdateArtworkPath(Artwork artwork);
         Task<Unit> AddArtwork(Domain.Metadata metadata, Artwork artwork);
         Task<Unit> RemoveArtwork(Domain.Metadata metadata, ArtworkKind artworkKind);
+        Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated);
+        Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated);
+        Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Repositories
@@ -9,14 +10,17 @@ namespace ErsatzTV.Core.Interfaces.Repositories
     {
         Task<bool> AllMoviesExist(List<int> movieIds);
         Task<Option<Movie>> GetMovie(int movieId);
-        Task<Either<BaseError, Movie>> GetOrAdd(LibraryPath libraryPath, string path);
-        Task<Either<BaseError, PlexMovie>> GetOrAdd(PlexLibrary library, PlexMovie item);
-        Task<bool> Update(Movie movie);
+        Task<Either<BaseError, MediaItemScanResult<Movie>>> GetOrAdd(LibraryPath libraryPath, string path);
+        Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> GetOrAdd(PlexLibrary library, PlexMovie item);
         Task<int> GetMovieCount();
         Task<List<MovieMetadata>> GetPagedMovies(int pageNumber, int pageSize);
+        Task<List<MovieMetadata>> GetMoviesForCards(List<int> ids);
         Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath);
-        Task<Unit> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<Unit> AddGenre(MovieMetadata metadata, Genre genre);
-        Task<Unit> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys);
+        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+        Task<bool> AddGenre(MovieMetadata metadata, Genre genre);
+        Task<bool> AddTag(MovieMetadata metadata, Tag tag);
+        Task<bool> AddStudio(MovieMetadata metadata, Studio studio);
+        Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys);
+        Task<bool> UpdateSortTitle(MovieMetadata movieMetadata);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs

@@ -1,11 +1,14 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Repositories
 {
     public interface ISearchRepository
     {
+        public Task<List<int>> GetItemIdsToIndex();
+        public Task<Option<MediaItem>> GetItemToIndex(int id);
         public Task<List<MediaItem>> SearchMediaItemsByTitle(string query);
         public Task<List<MediaItem>> SearchMediaItemsByGenre(string genre);
         public Task<List<MediaItem>> SearchMediaItemsByTag(string tag);

ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Repositories
@@ -8,13 +9,11 @@ namespace ErsatzTV.Core.Interfaces.Repositories
     public interface ITelevisionRepository
     {
         Task<bool> AllShowsExist(List<int> showIds);
-        Task<bool> Update(Show show);
-        Task<bool> Update(Season season);
-        Task<bool> Update(Episode episode);
         Task<List<Show>> GetAllShows();
         Task<Option<Show>> GetShow(int showId);
         Task<int> GetShowCount();
         Task<List<ShowMetadata>> GetPagedShows(int pageNumber, int pageSize);
+        Task<List<ShowMetadata>> GetShowsForCards(List<int> ids);
         Task<List<Episode>> GetShowItems(int showId);
         Task<List<Season>> GetAllSeasons();
         Task<Option<Season>> GetSeason(int seasonId);
@@ -25,19 +24,27 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<int> GetEpisodeCount(int seasonId);
         Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize);
         Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata);
-        Task<Either<BaseError, Show>> AddShow(int libraryPathId, string showFolder, ShowMetadata metadata);
+
+        Task<Either<BaseError, MediaItemScanResult<Show>>> AddShow(
+            int libraryPathId,
+            string showFolder,
+            ShowMetadata metadata);
+
         Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber);
         Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path);
         Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath);
         Task<Unit> DeleteByPath(LibraryPath libraryPath, string path);
         Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath);
-        Task<Unit> DeleteEmptyShows(LibraryPath libraryPath);
-        Task<Either<BaseError, PlexShow>> GetOrAddPlexShow(PlexLibrary library, PlexShow item);
+        Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath);
+        Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(PlexLibrary library, PlexShow item);
         Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item);
         Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item);
-        Task<Unit> AddGenre(ShowMetadata metadata, Genre genre);
-        Task<Unit> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys);
+        Task<bool> AddGenre(ShowMetadata metadata, Genre genre);
+        Task<bool> AddTag(ShowMetadata metadata, Tag tag);
+        Task<bool> AddStudio(ShowMetadata metadata, Studio studio);
+        Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys);
         Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys);
         Task<Unit> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys);
+        Task<Unit> SetEpisodeNumber(Episode episode, int episodeNumber);
     }
 }

ErsatzTV.Core/Interfaces/Runtime/IRuntimeInfo.cs

@@ -0,0 +1,11 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace ErsatzTV.Core.Interfaces.Runtime
+{
+    public interface IRuntimeInfo
+    {
+        [SuppressMessage("ReSharper", "InconsistentNaming")]
+        bool IsOSPlatform(OSPlatform osPlatform);
+    }
+}

ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Search
+{
+    public interface ISearchIndex
+    {
+        public int Version { get; }
+        Task<bool> Initialize();
+        Task<Unit> Rebuild(List<int> itemIds);
+        Task<Unit> AddItems(List<MediaItem> items);
+        Task<Unit> UpdateItems(List<MediaItem> items);
+        Task<Unit> RemoveItems(List<int> ids);
+        Task<SearchResult> Search(string query, int skip, int limit, string searchField = "");
+    }
+}

ErsatzTV.Core/Iptv/ChannelGuide.cs

@@ -32,7 +32,7 @@ namespace ErsatzTV.Core.Iptv
             xml.WriteStartElement("tv");
             xml.WriteAttributeString("generator-info-name", "ersatztv");
 
-            foreach (Channel channel in _channels.OrderBy(c => c.Number))
+            foreach (Channel channel in _channels.OrderBy(c => decimal.Parse(c.Number)))
             {
                 xml.WriteStartElement("channel");
                 xml.WriteAttributeString("id", channel.Number);
@@ -48,7 +48,7 @@ namespace ErsatzTV.Core.Iptv
                     .HeadOrNone()
                     .Match(
                         artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}",
-                        () => $"{_scheme}://{_host}/images/ersatztv-500.png");
+                        () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
                 xml.WriteAttributeString("src", logo);
                 xml.WriteEndElement(); // icon
 
@@ -122,7 +122,7 @@ namespace ErsatzTV.Core.Iptv
                                 .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
                                 .HeadOrNone()
                                 .Match(
-                                    artwork => $"{_scheme}://{_host}/artwork/posters/{artwork.Path}",
+                                    artwork => $"{_scheme}://{_host}/iptv/artwork/posters/{artwork.Path}",
                                     () => string.Empty);
 
                             if (!string.IsNullOrWhiteSpace(poster))
@@ -152,6 +152,26 @@ namespace ErsatzTV.Core.Iptv
 
                     if (playoutItem.MediaItem is Episode episode)
                     {
+                        Option<ShowMetadata> maybeMetadata =
+                            Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();
+                        if (maybeMetadata.IsSome)
+                        {
+                            ShowMetadata metadata = maybeMetadata.ValueUnsafe();
+                            string poster = Optional(metadata.Artwork).Flatten()
+                                .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+                                .HeadOrNone()
+                                .Match(
+                                    artwork => $"{_scheme}://{_host}/iptv/artwork/posters/{artwork.Path}",
+                                    () => string.Empty);
+
+                            if (!string.IsNullOrWhiteSpace(poster))
+                            {
+                                xml.WriteStartElement("icon");
+                                xml.WriteAttributeString("src", poster);
+                                xml.WriteEndElement(); // icon
+                            }
+                        }
+
                         int s = Optional(episode.Season?.SeasonNumber).IfNone(0);
                         int e = episode.EpisodeNumber;
                         if (s > 0 && e > 0)

ErsatzTV.Core/Iptv/ChannelPlaylist.cs

@@ -33,7 +33,7 @@ namespace ErsatzTV.Core.Iptv
                     .HeadOrNone()
                     .Match(
                         artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}",
-                        () => $"{_scheme}://{_host}/images/ersatztv-500.png");
+                        () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
 
                 string shortUniqueId = Convert.ToBase64String(channel.UniqueId.ToByteArray())
                     .TrimEnd('=')

ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
 using ErsatzTV.Core.Domain;
@@ -22,7 +23,7 @@ namespace ErsatzTV.Core.Metadata
             string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
             string fileName = Path.GetFileName(path);
             var metadata = new EpisodeMetadata
-                { MetadataKind = MetadataKind.Fallback, Title = fileName ?? path };
+                { MetadataKind = MetadataKind.Fallback, Title = fileName ?? path, DateAdded = DateTime.UtcNow };
             return fileName != null ? GetEpisodeMetadata(fileName, metadata) : Tuple(metadata, 0);
         }
 
@@ -47,6 +48,16 @@ namespace ErsatzTV.Core.Metadata
                 return title.Substring(4);
             }
 
+            if (title.StartsWith("a ", StringComparison.OrdinalIgnoreCase))
+            {
+                return title.Substring(2);
+            }
+
+            if (title.StartsWith("an ", StringComparison.OrdinalIgnoreCase))
+            {
+                return title.Substring(3);
+            }
+
             if (title.StartsWith("Æ"))
             {
                 return title.Replace("Æ", "E");
@@ -64,6 +75,7 @@ namespace ErsatzTV.Core.Metadata
                 if (match.Success)
                 {
                     metadata.Title = match.Groups[1].Value;
+                    metadata.DateUpdated = DateTime.UtcNow;
                     return Tuple(metadata, int.Parse(match.Groups[3].Value));
                 }
             }
@@ -86,6 +98,10 @@ namespace ErsatzTV.Core.Metadata
                     metadata.Title = match.Groups[1].Value;
                     metadata.Year = int.Parse(match.Groups[2].Value);
                     metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
+                    metadata.Genres = new List<Genre>();
+                    metadata.Tags = new List<Tag>();
+                    metadata.Studios = new List<Studio>();
+                    metadata.DateUpdated = DateTime.UtcNow;
                 }
             }
             catch (Exception)
@@ -107,6 +123,7 @@ namespace ErsatzTV.Core.Metadata
                     metadata.Title = match.Groups[1].Value;
                     metadata.Year = int.Parse(match.Groups[2].Value);
                     metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
+                    metadata.DateUpdated = DateTime.UtcNow;
                 }
             }
             catch (Exception)

ErsatzTV.Core/Metadata/LocalFileSystem.cs

@@ -11,6 +11,16 @@ namespace ErsatzTV.Core.Metadata
 {
     public class LocalFileSystem : ILocalFileSystem
     {
+        public Unit EnsureFolderExists(string folder)
+        {
+            if (!Directory.Exists(folder))
+            {
+                Directory.CreateDirectory(folder);
+            }
+
+            return Unit.Default;
+        }
+
         public DateTime GetLastWriteTime(string path) =>
             Try(File.GetLastWriteTimeUtc(path)).IfFail(() => DateTime.MinValue);
 

ErsatzTV.Core/Metadata/LocalFolderScanner.cs

@@ -2,21 +2,18 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Metadata
 {
     public abstract class LocalFolderScanner
     {
-        private static readonly SHA1CryptoServiceProvider Crypto;
-
         public static readonly List<string> VideoFileExtensions = new()
         {
             ".mpg", ".mp2", ".mpeg", ".mpe", ".mpv", ".ogg", ".mp4",
@@ -48,27 +45,30 @@ namespace ErsatzTV.Core.Metadata
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILocalStatisticsProvider _localStatisticsProvider;
         private readonly ILogger _logger;
-
-        static LocalFolderScanner() => Crypto = new SHA1CryptoServiceProvider();
+        private readonly IMetadataRepository _metadataRepository;
 
         protected LocalFolderScanner(
             ILocalFileSystem localFileSystem,
             ILocalStatisticsProvider localStatisticsProvider,
+            IMetadataRepository metadataRepository,
             IImageCache imageCache,
             ILogger logger)
         {
             _localFileSystem = localFileSystem;
             _localStatisticsProvider = localStatisticsProvider;
+            _metadataRepository = metadataRepository;
             _imageCache = imageCache;
             _logger = logger;
         }
 
-        protected async Task<Either<BaseError, T>> UpdateStatistics<T>(T mediaItem, string ffprobePath)
+        protected async Task<Either<BaseError, MediaItemScanResult<T>>> UpdateStatistics<T>(
+            MediaItemScanResult<T> mediaItem,
+            string ffprobePath)
             where T : MediaItem
         {
             try
             {
-                MediaVersion version = mediaItem switch
+                MediaVersion version = mediaItem.Item switch
                 {
                     Movie m => m.MediaVersions.Head(),
                     Episode e => e.MediaVersions.Head(),
@@ -77,12 +77,19 @@ namespace ErsatzTV.Core.Metadata
 
                 string path = version.MediaFiles.Head().Path;
 
-                if (version.DateUpdated < _localFileSystem.GetLastWriteTime(path))
+                if (version.DateUpdated < _localFileSystem.GetLastWriteTime(path) || !version.Streams.Any())
                 {
                     _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", path);
-                    Either<BaseError, Unit> refreshResult =
-                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, mediaItem);
-                    refreshResult.IfLeft(
+                    Either<BaseError, bool> refreshResult =
+                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, mediaItem.Item);
+                    refreshResult.Match(
+                        result =>
+                        {
+                            if (result)
+                            {
+                                mediaItem.IsUpdated = true;
+                            }
+                        },
                         error =>
                             _logger.LogWarning(
                                 "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
@@ -99,17 +106,16 @@ namespace ErsatzTV.Core.Metadata
             }
         }
 
-        protected bool RefreshArtwork(string artworkFile, Domain.Metadata metadata, ArtworkKind artworkKind)
+        protected async Task<bool> RefreshArtwork(string artworkFile, Domain.Metadata metadata, ArtworkKind artworkKind)
         {
             DateTime lastWriteTime = _localFileSystem.GetLastWriteTime(artworkFile);
 
             metadata.Artwork ??= new List<Artwork>();
 
-            Option<Artwork> maybeArtwork =
-                Optional(metadata.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == artworkKind);
+            Option<Artwork> maybeArtwork = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind);
 
             bool shouldRefresh = maybeArtwork.Match(
-                artwork => artwork.DateUpdated < lastWriteTime,
+                artwork => lastWriteTime.Subtract(artwork.DateUpdated) > TimeSpan.FromSeconds(1),
                 true);
 
             if (shouldRefresh)
@@ -117,13 +123,14 @@ namespace ErsatzTV.Core.Metadata
                 _logger.LogDebug("Refreshing {Attribute} from {Path}", artworkKind, artworkFile);
                 string cacheName = _imageCache.CopyArtworkToCache(artworkFile, artworkKind);
 
-                maybeArtwork.Match(
-                    artwork =>
+                await maybeArtwork.Match(
+                    async artwork =>
                     {
                         artwork.Path = cacheName;
                         artwork.DateUpdated = lastWriteTime;
+                        await _metadataRepository.UpdateArtworkPath(artwork);
                     },
-                    () =>
+                    async () =>
                     {
                         var artwork = new Artwork
                         {
@@ -132,8 +139,8 @@ namespace ErsatzTV.Core.Metadata
                             DateUpdated = lastWriteTime,
                             ArtworkKind = artworkKind
                         };
-
                         metadata.Artwork.Add(artwork);
+                        await _metadataRepository.AddArtwork(metadata, artwork);
                     });
 
                 return true;

ErsatzTV.Core/Metadata/LocalMetadataProvider.cs

@@ -22,17 +22,20 @@ namespace ErsatzTV.Core.Metadata
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILogger<LocalMetadataProvider> _logger;
 
-        private readonly IMediaItemRepository _mediaItemRepository;
+        private readonly IMetadataRepository _metadataRepository;
+        private readonly IMovieRepository _movieRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
         public LocalMetadataProvider(
-            IMediaItemRepository mediaItemRepository,
+            IMetadataRepository metadataRepository,
+            IMovieRepository movieRepository,
             ITelevisionRepository televisionRepository,
             IFallbackMetadataProvider fallbackMetadataProvider,
             ILocalFileSystem localFileSystem,
             ILogger<LocalMetadataProvider> logger)
         {
-            _mediaItemRepository = mediaItemRepository;
+            _metadataRepository = metadataRepository;
+            _movieRepository = movieRepository;
             _televisionRepository = televisionRepository;
             _fallbackMetadataProvider = fallbackMetadataProvider;
             _localFileSystem = localFileSystem;
@@ -62,45 +65,60 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
-        public Task<Unit> RefreshSidecarMetadata(MediaItem mediaItem, string path) =>
+        public Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path) =>
             mediaItem switch
             {
                 Episode e => LoadMetadata(e, path)
-                    .Bind(maybeMetadata => maybeMetadata.IfSomeAsync(metadata => ApplyMetadataUpdate(e, metadata))),
+                    .Bind(
+                        maybeMetadata => maybeMetadata.Match(
+                            metadata => ApplyMetadataUpdate(e, metadata),
+                            () => Task.FromResult(false))),
                 Movie m => LoadMetadata(m, path)
-                    .Bind(maybeMetadata => maybeMetadata.IfSomeAsync(metadata => ApplyMetadataUpdate(m, metadata))),
-                _ => Task.FromResult(Unit.Default)
+                    .Bind(
+                        maybeMetadata => maybeMetadata.Match(
+                            metadata => ApplyMetadataUpdate(m, metadata),
+                            () => Task.FromResult(false))),
+                _ => Task.FromResult(false)
             };
 
-        public Task<Unit> RefreshSidecarMetadata(Show televisionShow, string showFolder) =>
+        public Task<bool> RefreshSidecarMetadata(Show televisionShow, string showFolder) =>
             LoadMetadata(televisionShow, showFolder).Bind(
-                maybeMetadata => maybeMetadata.IfSomeAsync(metadata => ApplyMetadataUpdate(televisionShow, metadata)));
+                maybeMetadata => maybeMetadata.Match(
+                    metadata => ApplyMetadataUpdate(televisionShow, metadata),
+                    () => Task.FromResult(false)));
 
-        public Task<Unit> RefreshFallbackMetadata(MediaItem mediaItem) =>
+        public Task<bool> RefreshFallbackMetadata(MediaItem mediaItem) =>
             mediaItem switch
             {
-                Episode e => ApplyMetadataUpdate(e, _fallbackMetadataProvider.GetFallbackMetadata(e))
-                    .ToUnit(),
-                Movie m => ApplyMetadataUpdate(m, _fallbackMetadataProvider.GetFallbackMetadata(m)).ToUnit(),
-                _ => Task.FromResult(Unit.Default)
+                Episode e => ApplyMetadataUpdate(e, _fallbackMetadataProvider.GetFallbackMetadata(e)),
+                Movie m => ApplyMetadataUpdate(m, _fallbackMetadataProvider.GetFallbackMetadata(m)),
+                _ => Task.FromResult(false)
             };
 
-        public Task<Unit> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
-            ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder))
-                .ToUnit();
+        public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
+            ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
 
-        private async Task ApplyMetadataUpdate(Episode episode, Tuple<EpisodeMetadata, int> metadataEpisodeNumber)
+        private async Task<bool> ApplyMetadataUpdate(Episode episode, Tuple<EpisodeMetadata, int> metadataEpisodeNumber)
         {
             (EpisodeMetadata metadata, int episodeNumber) = metadataEpisodeNumber;
-            episode.EpisodeNumber = episodeNumber;
-            Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
+            if (episode.EpisodeNumber != episodeNumber)
+            {
+                await _televisionRepository.SetEpisodeNumber(episode, episodeNumber);
+            }
+
+            await Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
                 existing =>
                 {
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    existing.DateAdded = metadata.DateAdded;
+                    
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+
                     existing.DateUpdated = metadata.DateUpdated;
                     existing.MetadataKind = metadata.MetadataKind;
                     existing.OriginalTitle = metadata.OriginalTitle;
@@ -109,28 +127,39 @@ namespace ErsatzTV.Core.Metadata
                     existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
+
+                    return _metadataRepository.Update(existing);
                 },
                 () =>
                 {
                     metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
+                    metadata.EpisodeId = episode.Id;
                     episode.EpisodeMetadata = new List<EpisodeMetadata> { metadata };
+
+                    return _metadataRepository.Add(metadata);
                 });
 
-            await _televisionRepository.Update(episode);
+            return true;
         }
 
-        private async Task ApplyMetadataUpdate(Movie movie, MovieMetadata metadata)
-        {
+        private Task<bool> ApplyMetadataUpdate(Movie movie, MovieMetadata metadata) =>
             Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
-                existing =>
+                async existing =>
                 {
+                    var updated = false;
+                    
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    existing.DateAdded = metadata.DateAdded;
+                    
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+                    
                     existing.DateUpdated = metadata.DateUpdated;
                     existing.MetadataKind = metadata.MetadataKind;
                     existing.OriginalTitle = metadata.OriginalTitle;
@@ -144,47 +173,93 @@ namespace ErsatzTV.Core.Metadata
                         .ToList())
                     {
                         existing.Genres.Remove(genre);
+                        if (await _metadataRepository.RemoveGenre(genre))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
                         .ToList())
                     {
                         existing.Genres.Add(genre);
+                        if (await _movieRepository.AddGenre(existing, genre))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Tag tag in existing.Tags.Filter(t => metadata.Tags.All(t2 => t2.Name != t.Name))
                         .ToList())
                     {
                         existing.Tags.Remove(tag);
+                        if (await _metadataRepository.RemoveTag(tag))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Tag tag in metadata.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
                         .ToList())
                     {
                         existing.Tags.Add(tag);
+                        if (await _movieRepository.AddTag(existing, tag))
+                        {
+                            updated = true;
+                        }
                     }
+
+                    foreach (Studio studio in existing.Studios
+                        .Filter(s => metadata.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Remove(studio);
+                        if (await _metadataRepository.RemoveStudio(studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in metadata.Studios
+                        .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Add(studio);
+                        if (await _movieRepository.AddStudio(existing, studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    return await _metadataRepository.Update(existing) || updated;
                 },
-                () =>
+                async () =>
                 {
                     metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
+                    metadata.MovieId = movie.Id;
                     movie.MovieMetadata = new List<MovieMetadata> { metadata };
+
+                    return await _metadataRepository.Add(metadata);
                 });
 
-            await _mediaItemRepository.Update(movie);
-        }
-
-        private async Task ApplyMetadataUpdate(Show show, ShowMetadata metadata)
-        {
+        private Task<bool> ApplyMetadataUpdate(Show show, ShowMetadata metadata) =>
             Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
-                existing =>
+                async existing =>
                 {
+                    var updated = false;
+
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    existing.DateAdded = metadata.DateAdded;
+                    
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+
                     existing.DateUpdated = metadata.DateUpdated;
                     existing.MetadataKind = metadata.MetadataKind;
                     existing.OriginalTitle = metadata.OriginalTitle;
@@ -198,36 +273,76 @@ namespace ErsatzTV.Core.Metadata
                         .ToList())
                     {
                         existing.Genres.Remove(genre);
+                        if (await _metadataRepository.RemoveGenre(genre))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
                         .ToList())
                     {
                         existing.Genres.Add(genre);
+                        if (await _televisionRepository.AddGenre(existing, genre))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Tag tag in existing.Tags.Filter(t => metadata.Tags.All(t2 => t2.Name != t.Name))
                         .ToList())
                     {
                         existing.Tags.Remove(tag);
+                        if (await _metadataRepository.RemoveTag(tag))
+                        {
+                            updated = true;
+                        }
                     }
 
                     foreach (Tag tag in metadata.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
                         .ToList())
                     {
                         existing.Tags.Add(tag);
+                        if (await _televisionRepository.AddTag(existing, tag))
+                        {
+                            updated = true;
+                        }
                     }
+
+                    foreach (Studio studio in existing.Studios
+                        .Filter(s => metadata.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Remove(studio);
+                        if (await _metadataRepository.RemoveStudio(studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in metadata.Studios
+                        .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Add(studio);
+                        if (await _televisionRepository.AddStudio(existing, studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    return await _metadataRepository.Update(existing) || updated;
                 },
-                () =>
+                async () =>
                 {
                     metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
+                    metadata.ShowId = show.Id;
                     show.ShowMetadata = new List<ShowMetadata> { metadata };
-                });
 
-            await _televisionRepository.Update(show);
-        }
+                    return await _metadataRepository.Add(metadata);
+                });
 
         private async Task<Option<MovieMetadata>> LoadMetadata(Movie mediaItem, string nfoFileName)
         {
@@ -272,15 +387,17 @@ namespace ErsatzTV.Core.Metadata
                     nfo => new ShowMetadata
                     {
                         MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = DateTime.UtcNow,
                         DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
                         Title = nfo.Title,
                         Plot = nfo.Plot,
                         Outline = nfo.Outline,
                         Tagline = nfo.Tagline,
-                        Year = nfo.Year,
-                        ReleaseDate = GetAired(nfo.Premiered) ?? new DateTime(nfo.Year, 1, 1),
+                        Year = GetYear(nfo.Year, nfo.Premiered),
+                        ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
                         Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList()
+                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
                     },
                     None);
             }
@@ -303,9 +420,10 @@ namespace ErsatzTV.Core.Metadata
                         var metadata = new EpisodeMetadata
                         {
                             MetadataKind = MetadataKind.Sidecar,
+                            DateAdded = DateTime.UtcNow,
                             DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
                             Title = nfo.Title,
-                            ReleaseDate = GetAired(nfo.Aired),
+                            ReleaseDate = GetAired(0, nfo.Aired),
                             Plot = nfo.Plot
                         };
                         return Tuple(metadata, nfo.Episode);
@@ -329,6 +447,7 @@ namespace ErsatzTV.Core.Metadata
                     nfo => new MovieMetadata
                     {
                         MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = DateTime.UtcNow,
                         DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
                         Title = nfo.Title,
                         Year = nfo.Year,
@@ -337,7 +456,8 @@ namespace ErsatzTV.Core.Metadata
                         Outline = nfo.Outline,
                         Tagline = nfo.Tagline,
                         Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList()
+                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
                     },
                     None);
             }
@@ -348,21 +468,38 @@ namespace ErsatzTV.Core.Metadata
             }
         }
 
-        private static DateTime? GetAired(string aired)
+        private static int? GetYear(int year, string premiered)
         {
-            if (string.IsNullOrWhiteSpace(aired))
+            if (year > 1000)
+            {
+                return year;
+            }
+
+            if (string.IsNullOrWhiteSpace(premiered))
             {
                 return null;
             }
 
-            if (DateTime.TryParse(aired, out DateTime parsed))
+            if (DateTime.TryParse(premiered, out DateTime parsed))
             {
-                return parsed;
+                return parsed.Year;
             }
 
             return null;
         }
 
+        private static DateTime? GetAired(int year, string aired)
+        {
+            DateTime? fallback = year > 1000 ? new DateTime(year, 1, 1) : null;
+
+            if (string.IsNullOrWhiteSpace(aired))
+            {
+                return fallback;
+            }
+
+            return DateTime.TryParse(aired, out DateTime parsed) ? parsed : fallback;
+        }
+
         [XmlRoot("movie")]
         public class MovieNfo
         {
@@ -392,6 +529,9 @@ namespace ErsatzTV.Core.Metadata
 
             [XmlElement("tag")]
             public List<string> Tags { get; set; }
+
+            [XmlElement("studio")]
+            public List<string> Studios { get; set; }
         }
 
         [XmlRoot("tvshow")]
@@ -420,6 +560,9 @@ namespace ErsatzTV.Core.Metadata
 
             [XmlElement("tag")]
             public List<string> Tags { get; set; }
+
+            [XmlElement("studio")]
+            public List<string> Studios { get; set; }
         }
 
         [XmlRoot("episodedetails")]

ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs

@@ -17,19 +17,19 @@ namespace ErsatzTV.Core.Metadata
     {
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILogger<LocalStatisticsProvider> _logger;
-        private readonly IMediaItemRepository _mediaItemRepository;
+        private readonly IMetadataRepository _metadataRepository;
 
         public LocalStatisticsProvider(
-            IMediaItemRepository mediaItemRepository,
+            IMetadataRepository metadataRepository,
             ILocalFileSystem localFileSystem,
             ILogger<LocalStatisticsProvider> logger)
         {
-            _mediaItemRepository = mediaItemRepository;
+            _metadataRepository = metadataRepository;
             _localFileSystem = localFileSystem;
             _logger = logger;
         }
 
-        public async Task<Either<BaseError, Unit>> RefreshStatistics(string ffprobePath, MediaItem mediaItem)
+        public async Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem)
         {
             try
             {
@@ -44,11 +44,11 @@ namespace ErsatzTV.Core.Metadata
                 return await maybeProbe.Match(
                     async ffprobe =>
                     {
-                        MediaVersion version = ProjectToMediaVersion(ffprobe);
-                        await ApplyVersionUpdate(mediaItem, version, filePath);
-                        return Right<BaseError, Unit>(Unit.Default);
+                        MediaVersion version = ProjectToMediaVersion(filePath, ffprobe);
+                        bool result = await ApplyVersionUpdate(mediaItem, version, filePath);
+                        return Right<BaseError, bool>(result);
                     },
-                    error => Task.FromResult(Left<BaseError, Unit>(error)));
+                    error => Task.FromResult(Left<BaseError, bool>(error)));
             }
             catch (Exception ex)
             {
@@ -68,18 +68,9 @@ namespace ErsatzTV.Core.Metadata
 
             bool durationChange = mediaItemVersion.Duration != version.Duration;
 
-            mediaItemVersion.DateUpdated = _localFileSystem.GetLastWriteTime(filePath);
-            mediaItemVersion.Duration = version.Duration;
-            mediaItemVersion.AudioCodec = version.AudioCodec;
-            mediaItemVersion.SampleAspectRatio = version.SampleAspectRatio;
-            mediaItemVersion.DisplayAspectRatio = version.DisplayAspectRatio;
-            mediaItemVersion.Width = version.Width;
-            mediaItemVersion.Height = version.Height;
-            mediaItemVersion.VideoCodec = version.VideoCodec;
-            mediaItemVersion.VideoProfile = version.VideoProfile;
-            mediaItemVersion.VideoScanKind = version.VideoScanKind;
+            version.DateUpdated = _localFileSystem.GetLastWriteTime(filePath);
 
-            return await _mediaItemRepository.Update(mediaItem) && durationChange;
+            return await _metadataRepository.UpdateLocalStatistics(mediaItemVersion.Id, version) && durationChange;
         }
 
         private Task<Either<BaseError, FFprobe>> GetProbeOutput(string ffprobePath, string filePath)
@@ -117,7 +108,7 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
-        private MediaVersion ProjectToMediaVersion(FFprobe probeOutput) =>
+        private MediaVersion ProjectToMediaVersion(string path, FFprobe probeOutput) =>
             Optional(probeOutput)
                 .Filter(json => json?.format != null && json.streams != null)
                 .ToValidation<BaseError>("Unable to parse ffprobe output")
@@ -125,14 +116,47 @@ namespace ErsatzTV.Core.Metadata
                 .Match(
                     json =>
                     {
-                        var duration = TimeSpan.FromSeconds(double.Parse(json.format.duration));
+                        var version = new MediaVersion
+                            { Name = "Main", DateAdded = DateTime.UtcNow, Streams = new List<MediaStream>() };
 
-                        var version = new MediaVersion { Name = "Main", Duration = duration };
-
-                        FFprobeStream audioStream = json.streams.FirstOrDefault(s => s.codec_type == "audio");
-                        if (audioStream != null)
+                        if (double.TryParse(json.format.duration, out double duration))
                         {
-                            version.AudioCodec = audioStream.codec_name;
+                            var seconds = TimeSpan.FromSeconds(duration);
+                            version.Duration = seconds;
+                        }
+                        else
+                        {
+                            _logger.LogWarning(
+                                "Media item at {Path} has a missing or invalid duration {Duration} and will cause scheduling issues",
+                                path,
+                                json.format.duration);
+                        }
+
+                        foreach (FFprobeStream audioStream in json.streams.Filter(s => s.codec_type == "audio"))
+                        {
+                            var stream = new MediaStream
+                            {
+                                MediaVersionId = version.Id,
+                                MediaStreamKind = MediaStreamKind.Audio,
+                                Index = audioStream.index,
+                                Codec = audioStream.codec_name,
+                                Profile = (audioStream.profile ?? string.Empty).ToLowerInvariant(),
+                                Channels = audioStream.channels
+                            };
+
+                            if (audioStream.disposition is not null)
+                            {
+                                stream.Default = audioStream.disposition.@default == 1;
+                                stream.Forced = audioStream.disposition.forced == 1;
+                            }
+
+                            if (audioStream.tags is not null)
+                            {
+                                stream.Language = audioStream.tags.language;
+                                stream.Title = audioStream.tags.title;
+                            }
+
+                            version.Streams.Add(stream);
                         }
 
                         FFprobeStream videoStream = json.streams.FirstOrDefault(s => s.codec_type == "video");
@@ -142,14 +166,54 @@ namespace ErsatzTV.Core.Metadata
                             version.DisplayAspectRatio = videoStream.display_aspect_ratio;
                             version.Width = videoStream.width;
                             version.Height = videoStream.height;
-                            version.VideoCodec = videoStream.codec_name;
-                            version.VideoProfile = (videoStream.profile ?? string.Empty).ToLowerInvariant();
                             version.VideoScanKind = ScanKindFromFieldOrder(videoStream.field_order);
+
+                            var stream = new MediaStream
+                            {
+                                MediaVersionId = version.Id,
+                                MediaStreamKind = MediaStreamKind.Video,
+                                Index = videoStream.index,
+                                Codec = videoStream.codec_name,
+                                Profile = (videoStream.profile ?? string.Empty).ToLowerInvariant()
+                            };
+
+                            if (videoStream.disposition is not null)
+                            {
+                                stream.Default = videoStream.disposition.@default == 1;
+                                stream.Forced = videoStream.disposition.forced == 1;
+                            }
+
+                            version.Streams.Add(stream);
+                        }
+
+                        foreach (FFprobeStream subtitleStream in json.streams.Filter(s => s.codec_type == "subtitle"))
+                        {
+                            var stream = new MediaStream
+                            {
+                                MediaVersionId = version.Id,
+                                MediaStreamKind = MediaStreamKind.Subtitle,
+                                Index = subtitleStream.index,
+                                Codec = subtitleStream.codec_name
+                            };
+
+                            if (subtitleStream.disposition is not null)
+                            {
+                                stream.Default = subtitleStream.disposition.@default == 1;
+                                stream.Forced = subtitleStream.disposition.forced == 1;
+                            }
+
+                            if (subtitleStream.tags is not null)
+                            {
+                                stream.Language = subtitleStream.tags.language;
+                            }
+
+                            version.Streams.Add(stream);
                         }
 
                         return version;
                     },
-                    _ => new MediaVersion { Name = "Main" });
+                    _ => new MediaVersion
+                        { Name = "Main", DateAdded = DateTime.UtcNow, Streams = new List<MediaStream>() });
 
         private VideoScanKind ScanKindFromFieldOrder(string fieldOrder) =>
             fieldOrder?.ToLowerInvariant() switch
@@ -164,17 +228,24 @@ namespace ErsatzTV.Core.Metadata
 
         public record FFprobeFormat(string duration);
 
+        public record FFprobeDisposition(int @default, int forced);
+
+        public record FFProbeTags(string language, string title);
+
         public record FFprobeStream(
             int index,
             string codec_name,
             string profile,
             string codec_type,
+            int channels,
             int width,
             int height,
             string sample_aspect_ratio,
             string display_aspect_ratio,
             string field_order,
-            string r_frame_rate);
+            string r_frame_rate,
+            FFprobeDisposition disposition,
+            FFProbeTags tags);
         // ReSharper restore InconsistentNaming
     }
 }

ErsatzTV.Core/Metadata/MediaItemScanResult.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Metadata
+{
+    public class MediaItemScanResult<T> where T : MediaItem
+    {
+        public MediaItemScanResult(T item) => Item = item;
+
+        public T Item { get; }
+
+        public bool IsAdded { get; set; }
+        public bool IsUpdated { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/MovieFolderScanner.cs

@@ -8,6 +8,7 @@ using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 using static LanguageExt.Prelude;
@@ -21,23 +22,30 @@ namespace ErsatzTV.Core.Metadata
         private readonly ILocalMetadataProvider _localMetadataProvider;
         private readonly ILogger<MovieFolderScanner> _logger;
         private readonly IMovieRepository _movieRepository;
+        private readonly ISearchIndex _searchIndex;
 
         public MovieFolderScanner(
             ILocalFileSystem localFileSystem,
             IMovieRepository movieRepository,
             ILocalStatisticsProvider localStatisticsProvider,
             ILocalMetadataProvider localMetadataProvider,
+            IMetadataRepository metadataRepository,
             IImageCache imageCache,
+            ISearchIndex searchIndex,
             ILogger<MovieFolderScanner> logger)
-            : base(localFileSystem, localStatisticsProvider, imageCache, logger)
+            : base(localFileSystem, localStatisticsProvider, metadataRepository, imageCache, logger)
         {
             _localFileSystem = localFileSystem;
             _movieRepository = movieRepository;
             _localMetadataProvider = localMetadataProvider;
+            _searchIndex = searchIndex;
             _logger = logger;
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath)
+        public async Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            DateTimeOffset lastScan)
         {
             if (!_localFileSystem.IsLibraryPathAccessible(libraryPath))
             {
@@ -71,20 +79,38 @@ namespace ErsatzTV.Core.Metadata
                     continue;
                 }
 
+                if (_localFileSystem.GetLastWriteTime(movieFolder) < lastScan)
+                {
+                    continue;
+                }
 
                 foreach (string file in allFiles.OrderBy(identity))
                 {
-                    // TODO: optimize dbcontext use here, do we need tracking? can we make partial updates with dapper?
                     // TODO: figure out how to rebuild playlists
-                    Either<BaseError, Movie> maybeMovie = await _movieRepository
+                    Either<BaseError, MediaItemScanResult<Movie>> maybeMovie = await _movieRepository
                         .GetOrAdd(libraryPath, file)
-                        .BindT(movie => UpdateStatistics(movie, ffprobePath).MapT(_ => movie))
+                        .BindT(movie => UpdateStatistics(movie, ffprobePath))
                         .BindT(UpdateMetadata)
                         .BindT(movie => UpdateArtwork(movie, ArtworkKind.Poster))
                         .BindT(movie => UpdateArtwork(movie, ArtworkKind.FanArt));
 
-                    maybeMovie.IfLeft(
-                        error => _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value));
+                    await maybeMovie.Match(
+                        async result =>
+                        {
+                            if (result.IsAdded)
+                            {
+                                await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
+                            {
+                                await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                            }
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value);
+                            return Task.CompletedTask;
+                        });
                 }
             }
 
@@ -93,17 +119,20 @@ namespace ErsatzTV.Core.Metadata
                 if (!_localFileSystem.FileExists(path))
                 {
                     _logger.LogInformation("Removing missing movie at {Path}", path);
-                    await _movieRepository.DeleteByPath(libraryPath, path);
+                    List<int> ids = await _movieRepository.DeleteByPath(libraryPath, path);
+                    await _searchIndex.RemoveItems(ids);
                 }
             }
 
             return Unit.Default;
         }
 
-        private async Task<Either<BaseError, Movie>> UpdateMetadata(Movie movie)
+        private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateMetadata(
+            MediaItemScanResult<Movie> result)
         {
             try
             {
+                Movie movie = result.Item;
                 await LocateNfoFile(movie).Match(
                     async nfoFile =>
                     {
@@ -115,7 +144,10 @@ namespace ErsatzTV.Core.Metadata
                         if (shouldUpdate)
                         {
                             _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            await _localMetadataProvider.RefreshSidecarMetadata(movie, nfoFile);
+                            if (await _localMetadataProvider.RefreshSidecarMetadata(movie, nfoFile))
+                            {
+                                result.IsUpdated = true;
+                            }
                         }
                     },
                     async () =>
@@ -124,37 +156,40 @@ namespace ErsatzTV.Core.Metadata
                         {
                             string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
                             _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                            await _localMetadataProvider.RefreshFallbackMetadata(movie);
+                            if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
+                            {
+                                result.IsUpdated = true;
+                            }
                         }
                     });
 
-                return movie;
+                return result;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
-        private async Task<Either<BaseError, Movie>> UpdateArtwork(Movie movie, ArtworkKind artworkKind)
+        private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateArtwork(
+            MediaItemScanResult<Movie> result,
+            ArtworkKind artworkKind)
         {
             try
             {
+                Movie movie = result.Item;
                 await LocateArtwork(movie, artworkKind).IfSomeAsync(
                     async posterFile =>
                     {
                         MovieMetadata metadata = movie.MovieMetadata.Head();
-                        if (RefreshArtwork(posterFile, metadata, artworkKind))
-                        {
-                            await _movieRepository.Update(movie);
-                        }
+                        await RefreshArtwork(posterFile, metadata, artworkKind);
                     });
 
-                return movie;
+                return result;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
@@ -183,6 +218,14 @@ namespace ErsatzTV.Core.Metadata
                     ext => new[] { $"{segment}.{ext}", Path.GetFileNameWithoutExtension(path) + $"-{segment}.{ext}" })
                 .Map(f => Path.Combine(folder, f));
             Option<string> result = possibleMoviePosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+            if (result.IsNone && artworkKind == ArtworkKind.Poster)
+            {
+                IEnumerable<string> possibleFolderPosters = ImageFileExtensions.Collect(
+                        ext => new[] { $"folder.{ext}" })
+                    .Map(f => Path.Combine(folder, f));
+                result = possibleFolderPosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+            }
+
             return result;
         }
     }

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -8,6 +8,7 @@ using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 using static LanguageExt.Prelude;
@@ -19,6 +20,7 @@ namespace ErsatzTV.Core.Metadata
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILocalMetadataProvider _localMetadataProvider;
         private readonly ILogger<TelevisionFolderScanner> _logger;
+        private readonly ISearchIndex _searchIndex;
         private readonly ITelevisionRepository _televisionRepository;
 
         public TelevisionFolderScanner(
@@ -26,20 +28,27 @@ namespace ErsatzTV.Core.Metadata
             ITelevisionRepository televisionRepository,
             ILocalStatisticsProvider localStatisticsProvider,
             ILocalMetadataProvider localMetadataProvider,
+            IMetadataRepository metadataRepository,
             IImageCache imageCache,
+            ISearchIndex searchIndex,
             ILogger<TelevisionFolderScanner> logger) : base(
             localFileSystem,
             localStatisticsProvider,
+            metadataRepository,
             imageCache,
             logger)
         {
             _localFileSystem = localFileSystem;
             _televisionRepository = televisionRepository;
             _localMetadataProvider = localMetadataProvider;
+            _searchIndex = searchIndex;
             _logger = logger;
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath)
+        public async Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            DateTimeOffset lastScan)
         {
             if (!_localFileSystem.IsLibraryPathAccessible(libraryPath))
             {
@@ -53,14 +62,26 @@ namespace ErsatzTV.Core.Metadata
 
             foreach (string showFolder in allShowFolders)
             {
-                Either<BaseError, Show> maybeShow =
+                Either<BaseError, MediaItemScanResult<Show>> maybeShow =
                     await FindOrCreateShow(libraryPath.Id, showFolder)
                         .BindT(show => UpdateMetadataForShow(show, showFolder))
                         .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Poster))
                         .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.FanArt));
 
                 await maybeShow.Match(
-                    show => ScanSeasons(libraryPath, ffprobePath, show, showFolder),
+                    async result =>
+                    {
+                        if (result.IsAdded)
+                        {
+                            await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                        }
+                        else if (result.IsUpdated)
+                        {
+                            await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                        }
+
+                        await ScanSeasons(libraryPath, ffprobePath, result.Item, showFolder, lastScan);
+                    },
                     _ => Task.FromResult(Unit.Default));
             }
 
@@ -74,19 +95,20 @@ namespace ErsatzTV.Core.Metadata
             }
 
             await _televisionRepository.DeleteEmptySeasons(libraryPath);
-            await _televisionRepository.DeleteEmptyShows(libraryPath);
+            List<int> ids = await _televisionRepository.DeleteEmptyShows(libraryPath);
+            await _searchIndex.RemoveItems(ids);
 
             return Unit.Default;
         }
 
-        private async Task<Either<BaseError, Show>> FindOrCreateShow(
+        private async Task<Either<BaseError, MediaItemScanResult<Show>>> FindOrCreateShow(
             int libraryPathId,
             string showFolder)
         {
             ShowMetadata metadata = await _localMetadataProvider.GetMetadataForShow(showFolder);
             Option<Show> maybeShow = await _televisionRepository.GetShowByMetadata(libraryPathId, metadata);
             return await maybeShow.Match(
-                show => Right<BaseError, Show>(show).AsTask(),
+                show => Right<BaseError, MediaItemScanResult<Show>>(new MediaItemScanResult<Show>(show)).AsTask(),
                 async () => await _televisionRepository.AddShow(libraryPathId, showFolder, metadata));
         }
 
@@ -94,7 +116,8 @@ namespace ErsatzTV.Core.Metadata
             LibraryPath libraryPath,
             string ffprobePath,
             Show show,
-            string showFolder)
+            string showFolder,
+            DateTimeOffset lastScan)
         {
             foreach (string seasonFolder in _localFileSystem.ListSubdirectories(showFolder).Filter(ShouldIncludeFolder)
                 .OrderBy(identity))
@@ -108,7 +131,7 @@ namespace ErsatzTV.Core.Metadata
                             .BindT(season => UpdatePoster(season, seasonFolder));
 
                         await maybeSeason.Match(
-                            season => ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder),
+                            season => ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder, lastScan),
                             _ => Task.FromResult(Unit.Default));
                     });
             }
@@ -120,15 +143,23 @@ namespace ErsatzTV.Core.Metadata
             LibraryPath libraryPath,
             string ffprobePath,
             Season season,
-            string seasonPath)
+            string seasonPath,
+            DateTimeOffset lastScan)
         {
+            if (_localFileSystem.GetLastWriteTime(seasonPath) < lastScan)
+            {
+                return Unit.Default;
+            }
+
             foreach (string file in _localFileSystem.ListFiles(seasonPath)
                 .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f))).OrderBy(identity))
             {
                 // TODO: figure out how to rebuild playlists
                 Either<BaseError, Episode> maybeEpisode = await _televisionRepository
                     .GetOrAddEpisode(season, libraryPath, file)
-                    .BindT(episode => UpdateStatistics(episode, ffprobePath).MapT(_ => episode))
+                    .BindT(
+                        episode => UpdateStatistics(new MediaItemScanResult<Episode>(episode), ffprobePath)
+                            .MapT(_ => episode))
                     .BindT(UpdateMetadata)
                     .BindT(UpdateThumbnail);
 
@@ -139,12 +170,13 @@ namespace ErsatzTV.Core.Metadata
             return Unit.Default;
         }
 
-        private async Task<Either<BaseError, Show>> UpdateMetadataForShow(
-            Show show,
+        private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateMetadataForShow(
+            MediaItemScanResult<Show> result,
             string showFolder)
         {
             try
             {
+                Show show = result.Item;
                 await LocateNfoFileForShow(showFolder).Match(
                     async nfoFile =>
                     {
@@ -156,7 +188,10 @@ namespace ErsatzTV.Core.Metadata
                         if (shouldUpdate)
                         {
                             _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            await _localMetadataProvider.RefreshSidecarMetadata(show, nfoFile);
+                            if (await _localMetadataProvider.RefreshSidecarMetadata(show, nfoFile))
+                            {
+                                result.IsUpdated = true;
+                            }
                         }
                     },
                     async () =>
@@ -164,15 +199,18 @@ namespace ErsatzTV.Core.Metadata
                         if (!Optional(show.ShowMetadata).Flatten().Any())
                         {
                             _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
-                            await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder);
+                            if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
+                            {
+                                result.IsUpdated = true;
+                            }
                         }
                     });
 
-                return show;
+                return result;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
@@ -197,7 +235,11 @@ namespace ErsatzTV.Core.Metadata
                     },
                     async () =>
                     {
-                        if (!Optional(episode.EpisodeMetadata).Flatten().Any())
+                        bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
+                            m => m.DateUpdated == DateTime.MinValue,
+                            true);
+
+                        if (shouldUpdate)
                         {
                             string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
                             _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
@@ -209,32 +251,30 @@ namespace ErsatzTV.Core.Metadata
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
-        private async Task<Either<BaseError, Show>> UpdateArtworkForShow(
-            Show show,
+        private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateArtworkForShow(
+            MediaItemScanResult<Show> result,
             string showFolder,
             ArtworkKind artworkKind)
         {
             try
             {
+                Show show = result.Item;
                 await LocateArtworkForShow(showFolder, artworkKind).IfSomeAsync(
                     async posterFile =>
                     {
                         ShowMetadata metadata = show.ShowMetadata.Head();
-                        if (RefreshArtwork(posterFile, metadata, artworkKind))
-                        {
-                            await _televisionRepository.Update(show);
-                        }
+                        await RefreshArtwork(posterFile, metadata, artworkKind);
                     });
 
-                return show;
+                return result;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
@@ -245,25 +285,15 @@ namespace ErsatzTV.Core.Metadata
                 await LocatePoster(season, seasonFolder).IfSomeAsync(
                     async posterFile =>
                     {
-                        season.SeasonMetadata ??= new List<SeasonMetadata>();
-                        if (!season.SeasonMetadata.Any())
-                        {
-                            season.SeasonMetadata.Add(new SeasonMetadata { SeasonId = season.Id });
-                        }
-
                         SeasonMetadata metadata = season.SeasonMetadata.Head();
-
-                        if (RefreshArtwork(posterFile, metadata, ArtworkKind.Poster))
-                        {
-                            await _televisionRepository.Update(season);
-                        }
+                        await RefreshArtwork(posterFile, metadata, ArtworkKind.Poster);
                     });
 
                 return season;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
@@ -275,17 +305,14 @@ namespace ErsatzTV.Core.Metadata
                     async posterFile =>
                     {
                         EpisodeMetadata metadata = episode.EpisodeMetadata.Head();
-                        if (RefreshArtwork(posterFile, metadata, ArtworkKind.Thumbnail))
-                        {
-                            await _televisionRepository.Update(episode);
-                        }
+                        await RefreshArtwork(posterFile, metadata, ArtworkKind.Thumbnail);
                     });
 
                 return episode;
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.Message);
+                return BaseError.New(ex.ToString());
             }
         }
 
@@ -302,15 +329,16 @@ namespace ErsatzTV.Core.Metadata
 
         private Option<string> LocateArtworkForShow(string showFolder, ArtworkKind artworkKind)
         {
-            string segment = artworkKind switch
+            string[] segments = artworkKind switch
             {
-                ArtworkKind.Poster => "poster",
-                ArtworkKind.FanArt => "fanart",
+                ArtworkKind.Poster => new[] { "poster", "folder" },
+                ArtworkKind.FanArt => new[] { "fanart" },
                 _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
             };
 
             return ImageFileExtensions
-                .Map(ext => $"{segment}.{ext}")
+                .Map(ext => segments.Map(segment => $"{segment}.{ext}"))
+                .Flatten()
                 .Map(f => Path.Combine(showFolder, f))
                 .Filter(s => _localFileSystem.FileExists(s))
                 .HeadOrNone();

ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs

@@ -4,9 +4,10 @@ using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Plex
 {
@@ -16,17 +17,20 @@ namespace ErsatzTV.Core.Plex
         private readonly IMetadataRepository _metadataRepository;
         private readonly IMovieRepository _movieRepository;
         private readonly IPlexServerApiClient _plexServerApiClient;
+        private readonly ISearchIndex _searchIndex;
 
         public PlexMovieLibraryScanner(
             IPlexServerApiClient plexServerApiClient,
             IMovieRepository movieRepository,
             IMetadataRepository metadataRepository,
+            ISearchIndex searchIndex,
             ILogger<PlexMovieLibraryScanner> logger)
             : base(metadataRepository)
         {
             _plexServerApiClient = plexServerApiClient;
             _movieRepository = movieRepository;
             _metadataRepository = metadataRepository;
+            _searchIndex = searchIndex;
             _logger = logger;
         }
 
@@ -46,21 +50,37 @@ namespace ErsatzTV.Core.Plex
                     foreach (PlexMovie incoming in movieEntries)
                     {
                         // TODO: figure out how to rebuild playlists
-                        Either<BaseError, PlexMovie> maybeMovie = await _movieRepository
+                        Either<BaseError, MediaItemScanResult<PlexMovie>> maybeMovie = await _movieRepository
                             .GetOrAdd(plexMediaSourceLibrary, incoming)
                             .BindT(existing => UpdateStatistics(existing, incoming, connection, token))
                             .BindT(existing => UpdateMetadata(existing, incoming))
                             .BindT(existing => UpdateArtwork(existing, incoming));
 
-                        maybeMovie.IfLeft(
-                            error => _logger.LogWarning(
-                                "Error processing plex movie at {Key}: {Error}",
-                                incoming.Key,
-                                error.Value));
+                        await maybeMovie.Match(
+                            async result =>
+                            {
+                                if (result.IsAdded)
+                                {
+                                    await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                                }
+                                else if (result.IsUpdated)
+                                {
+                                    await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                                }
+                            },
+                            error =>
+                            {
+                                _logger.LogWarning(
+                                    "Error processing plex movie at {Key}: {Error}",
+                                    incoming.Key,
+                                    error.Value);
+                                return Task.CompletedTask;
+                            });
                     }
 
                     var movieKeys = movieEntries.Map(s => s.Key).ToList();
-                    await _movieRepository.RemoveMissingPlexMovies(plexMediaSourceLibrary, movieKeys);
+                    List<int> ids = await _movieRepository.RemoveMissingPlexMovies(plexMediaSourceLibrary, movieKeys);
+                    await _searchIndex.RemoveItems(ids);
                 },
                 error =>
                 {
@@ -75,17 +95,17 @@ namespace ErsatzTV.Core.Plex
             return Unit.Default;
         }
 
-        private async Task<Either<BaseError, PlexMovie>> UpdateStatistics(
-            PlexMovie existing,
+        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateStatistics(
+            MediaItemScanResult<PlexMovie> result,
             PlexMovie incoming,
             PlexConnection connection,
             PlexServerAuthToken token)
         {
+            PlexMovie existing = result.Item;
             MediaVersion existingVersion = existing.MediaVersions.Head();
             MediaVersion incomingVersion = incoming.MediaVersions.Head();
 
-            if (incomingVersion.DateUpdated > existingVersion.DateUpdated ||
-                string.IsNullOrWhiteSpace(existingVersion.SampleAspectRatio))
+            if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
             {
                 Either<BaseError, MediaVersion> maybeStatistics =
                     await _plexServerApiClient.GetStatistics(incoming.Key.Split("/").Last(), connection, token);
@@ -93,20 +113,23 @@ namespace ErsatzTV.Core.Plex
                 await maybeStatistics.Match(
                     async mediaVersion =>
                     {
-                        existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio ?? "1:1";
+                        existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio;
                         existingVersion.VideoScanKind = mediaVersion.VideoScanKind;
-                        existingVersion.DateUpdated = incomingVersion.DateUpdated;
+                        existingVersion.DateUpdated = mediaVersion.DateUpdated;
 
-                        await _metadataRepository.UpdateStatistics(existingVersion);
+                        await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, mediaVersion);
                     },
                     _ => Task.CompletedTask);
             }
 
-            return Right<BaseError, PlexMovie>(existing);
+            return result;
         }
 
-        private async Task<Either<BaseError, PlexMovie>> UpdateMetadata(PlexMovie existing, PlexMovie incoming)
+        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateMetadata(
+            MediaItemScanResult<PlexMovie> result,
+            PlexMovie incoming)
         {
+            PlexMovie existing = result.Item;
             MovieMetadata existingMetadata = existing.MovieMetadata.Head();
             MovieMetadata incomingMetadata = incoming.MovieMetadata.Head();
 
@@ -117,7 +140,10 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Remove(genre);
-                    await _metadataRepository.RemoveGenre(genre);
+                    if (await _metadataRepository.RemoveGenre(genre))
+                    {
+                        result.IsUpdated = true;
+                    }
                 }
 
                 foreach (Genre genre in incomingMetadata.Genres
@@ -125,15 +151,56 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Add(genre);
-                    await _movieRepository.AddGenre(existingMetadata, genre);
+                    if (await _movieRepository.AddGenre(existingMetadata, genre))
+                    {
+                        result.IsUpdated = true;
+                    }
                 }
+
+                foreach (Studio studio in existingMetadata.Studios
+                    .Filter(s => incomingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existingMetadata.Studios.Remove(studio);
+                    if (await _metadataRepository.RemoveStudio(studio))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                foreach (Studio studio in incomingMetadata.Studios
+                    .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existingMetadata.Studios.Add(studio);
+                    if (await _movieRepository.AddStudio(existingMetadata, studio))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                if (incomingMetadata.SortTitle != existingMetadata.SortTitle)
+                {
+                    existingMetadata.SortTitle = incomingMetadata.SortTitle;
+                    if (await _movieRepository.UpdateSortTitle(existingMetadata))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+
+                // TODO: update other metadata?
             }
 
-            return existing;
+            return result;
         }
 
-        private async Task<Either<BaseError, PlexMovie>> UpdateArtwork(PlexMovie existing, PlexMovie incoming)
+        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateArtwork(
+            MediaItemScanResult<PlexMovie> result,
+            PlexMovie incoming)
         {
+            PlexMovie existing = result.Item;
             MovieMetadata existingMetadata = existing.MovieMetadata.Head();
             MovieMetadata incomingMetadata = incoming.MovieMetadata.Head();
 
@@ -141,9 +208,10 @@ namespace ErsatzTV.Core.Plex
             {
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
             }
 
-            return existing;
+            return result;
         }
     }
 }

ErsatzTV.Core/Plex/PlexPathReplacementService.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Plex;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Core.Plex
+{
+    public class PlexPathReplacementService : IPlexPathReplacementService
+    {
+        private readonly ILogger<PlexPathReplacementService> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IRuntimeInfo _runtimeInfo;
+
+        public PlexPathReplacementService(
+            IMediaSourceRepository mediaSourceRepository,
+            IRuntimeInfo runtimeInfo,
+            ILogger<PlexPathReplacementService> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _runtimeInfo = runtimeInfo;
+            _logger = logger;
+        }
+
+        public async Task<string> GetReplacementPlexPath(int libraryPathId, string path)
+        {
+            List<PlexPathReplacement> replacements =
+                await _mediaSourceRepository.GetPlexPathReplacementsByLibraryId(libraryPathId);
+            Option<PlexPathReplacement> maybeReplacement = replacements
+                .SingleOrDefault(
+                    r =>
+                    {
+                        string separatorChar = IsWindows(r.PlexMediaSource) ? @"\" : @"/";
+                        string prefix = r.PlexPath.EndsWith(separatorChar) ? r.PlexPath : r.PlexPath + separatorChar;
+                        return path.StartsWith(prefix);
+                    });
+            return maybeReplacement.Match(
+                replacement =>
+                {
+                    string finalPath = path.Replace(replacement.PlexPath, replacement.LocalPath);
+                    if (IsWindows(replacement.PlexMediaSource) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        finalPath = finalPath.Replace(@"\", @"/");
+                    }
+                    else if (!IsWindows(replacement.PlexMediaSource) && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        finalPath = finalPath.Replace(@"/", @"\");
+                    }
+
+                    _logger.LogInformation(
+                        "Replacing plex path {PlexPath} with {LocalPath} resulting in {FinalPath}",
+                        replacement.PlexPath,
+                        replacement.LocalPath,
+                        finalPath);
+                    return finalPath;
+                },
+                () => path);
+        }
+
+        private static bool IsWindows(PlexMediaSource plexMediaSource) =>
+            plexMediaSource.Platform.ToLowerInvariant() == "windows";
+    }
+}

ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs

@@ -4,6 +4,8 @@ using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Metadata;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 using static LanguageExt.Prelude;
@@ -15,18 +17,21 @@ namespace ErsatzTV.Core.Plex
         private readonly ILogger<PlexTelevisionLibraryScanner> _logger;
         private readonly IMetadataRepository _metadataRepository;
         private readonly IPlexServerApiClient _plexServerApiClient;
+        private readonly ISearchIndex _searchIndex;
         private readonly ITelevisionRepository _televisionRepository;
 
         public PlexTelevisionLibraryScanner(
             IPlexServerApiClient plexServerApiClient,
             ITelevisionRepository televisionRepository,
             IMetadataRepository metadataRepository,
+            ISearchIndex searchIndex,
             ILogger<PlexTelevisionLibraryScanner> logger)
             : base(metadataRepository)
         {
             _plexServerApiClient = plexServerApiClient;
             _televisionRepository = televisionRepository;
             _metadataRepository = metadataRepository;
+            _searchIndex = searchIndex;
             _logger = logger;
         }
 
@@ -46,13 +51,25 @@ namespace ErsatzTV.Core.Plex
                     foreach (PlexShow incoming in showEntries)
                     {
                         // TODO: figure out how to rebuild playlists
-                        Either<BaseError, PlexShow> maybeShow = await _televisionRepository
+                        Either<BaseError, MediaItemScanResult<PlexShow>> maybeShow = await _televisionRepository
                             .GetOrAddPlexShow(plexMediaSourceLibrary, incoming)
                             .BindT(existing => UpdateMetadata(existing, incoming))
                             .BindT(existing => UpdateArtwork(existing, incoming));
 
                         await maybeShow.Match(
-                            async show => await ScanSeasons(plexMediaSourceLibrary, show, connection, token),
+                            async result =>
+                            {
+                                if (result.IsAdded)
+                                {
+                                    await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                                }
+                                else if (result.IsUpdated)
+                                {
+                                    await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                                }
+
+                                await ScanSeasons(plexMediaSourceLibrary, result.Item, connection, token);
+                            },
                             error =>
                             {
                                 _logger.LogWarning(
@@ -64,7 +81,9 @@ namespace ErsatzTV.Core.Plex
                     }
 
                     var showKeys = showEntries.Map(s => s.Key).ToList();
-                    await _televisionRepository.RemoveMissingPlexShows(plexMediaSourceLibrary, showKeys);
+                    List<int> ids =
+                        await _televisionRepository.RemoveMissingPlexShows(plexMediaSourceLibrary, showKeys);
+                    await _searchIndex.RemoveItems(ids);
 
                     return Unit.Default;
                 },
@@ -79,8 +98,11 @@ namespace ErsatzTV.Core.Plex
                 });
         }
 
-        private Task<Either<BaseError, PlexShow>> UpdateMetadata(PlexShow existing, PlexShow incoming)
+        private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateMetadata(
+            MediaItemScanResult<PlexShow> result,
+            PlexShow incoming)
         {
+            PlexShow existing = result.Item;
             ShowMetadata existingMetadata = existing.ShowMetadata.Head();
             ShowMetadata incomingMetadata = incoming.ShowMetadata.Head();
 
@@ -93,7 +115,10 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Remove(genre);
-                    _metadataRepository.RemoveGenre(genre);
+                    if (await _metadataRepository.RemoveGenre(genre))
+                    {
+                        result.IsUpdated = true;
+                    }
                 }
 
                 foreach (Genre genre in incomingMetadata.Genres
@@ -101,15 +126,45 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Add(genre);
-                    _televisionRepository.AddGenre(existingMetadata, genre);
+                    if (await _televisionRepository.AddGenre(existingMetadata, genre))
+                    {
+                        result.IsUpdated = true;
+                    }
                 }
+
+                foreach (Studio studio in existingMetadata.Studios
+                    .Filter(s => incomingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existingMetadata.Studios.Remove(studio);
+                    if (await _metadataRepository.RemoveStudio(studio))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                foreach (Studio studio in incomingMetadata.Studios
+                    .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existingMetadata.Studios.Add(studio);
+                    if (await _televisionRepository.AddStudio(existingMetadata, studio))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
             }
 
-            return Right<BaseError, PlexShow>(existing).AsTask();
+            return result;
         }
 
-        private async Task<Either<BaseError, PlexShow>> UpdateArtwork(PlexShow existing, PlexShow incoming)
+        private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateArtwork(
+            MediaItemScanResult<PlexShow> result,
+            PlexShow incoming)
         {
+            PlexShow existing = result.Item;
             ShowMetadata existingMetadata = existing.ShowMetadata.Head();
             ShowMetadata incomingMetadata = incoming.ShowMetadata.Head();
 
@@ -117,9 +172,10 @@ namespace ErsatzTV.Core.Plex
             {
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
             }
 
-            return existing;
+            return result;
         }
 
         private async Task<Either<BaseError, Unit>> ScanSeasons(
@@ -182,6 +238,7 @@ namespace ErsatzTV.Core.Plex
             if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
             {
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
             }
 
             return existing;
@@ -244,8 +301,7 @@ namespace ErsatzTV.Core.Plex
             MediaVersion existingVersion = existing.MediaVersions.Head();
             MediaVersion incomingVersion = incoming.MediaVersions.Head();
 
-            if (incomingVersion.DateUpdated > existingVersion.DateUpdated ||
-                string.IsNullOrWhiteSpace(existingVersion.SampleAspectRatio))
+            if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
             {
                 Either<BaseError, MediaVersion> maybeStatistics =
                     await _plexServerApiClient.GetStatistics(incoming.Key.Split("/").Last(), connection, token);
@@ -253,11 +309,11 @@ namespace ErsatzTV.Core.Plex
                 await maybeStatistics.Match(
                     async mediaVersion =>
                     {
-                        existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio ?? "1:1";
+                        existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio;
                         existingVersion.VideoScanKind = mediaVersion.VideoScanKind;
-                        existingVersion.DateUpdated = incomingVersion.DateUpdated;
+                        existingVersion.DateUpdated = mediaVersion.DateUpdated;
 
-                        await _metadataRepository.UpdateStatistics(existingVersion);
+                        await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, mediaVersion);
                     },
                     _ => Task.CompletedTask);
             }

ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs

@@ -34,13 +34,21 @@ namespace ErsatzTV.Core.Scheduling
 
         public void MoveNext()
         {
-            State.Index++;
-            if (State.Index % _shuffled.Count == 0)
+            if ((State.Index + 1) % _shuffled.Count == 0)
             {
+                Option<MediaItem> tail = Current;
+
                 State.Index = 0;
-                State.Seed = _random.Next();
-                _random = new Random(State.Seed);
-                _shuffled = Shuffle(_mediaItems, _random);
+                do
+                {
+                    State.Seed = _random.Next();
+                    _random = new Random(State.Seed);
+                    _shuffled = Shuffle(_mediaItems, _random);
+                } while (_mediaItems.Count > 1 && Current == tail);
+            }
+            else
+            {
+                State.Index++;
             }
 
             State.Index %= _shuffled.Count;