fix updating music videos (#174)

* fix padding odd resolutions

* fix updating plex episode artwork only as needed

.github/workflows/ci.yml

@@ -1,5 +1,6 @@
 name: Build
 on:
+  workflow_dispatch:
   pull_request:
   push:
     branches:
@@ -35,7 +36,7 @@ jobs:
     name: Build & Publish to Docker Hub
     needs: build_and_test
     runs-on: ubuntu-latest
-    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no ci]')
+    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no docker]')
     steps:
       - name: Checkout
         uses: actions/checkout@v2

ErsatzTV.Application/Artists/ArtistViewModel.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace ErsatzTV.Application.Artists
+{
+    public record ArtistViewModel(
+        string Name,
+        string Disambiguation,
+        string Biography,
+        string Thumbnail,
+        string FanArt,
+        List<string> Genres,
+        List<string> Styles,
+        List<string> Moods,
+        List<CultureInfo> Languages);
+}

ErsatzTV.Application/Artists/Mapper.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Artists
+{
+    internal static class Mapper
+    {
+        internal static ArtistViewModel ProjectToViewModel(Artist artist, List<string> languages)
+        {
+            ArtistMetadata metadata = Optional(artist.ArtistMetadata).Flatten().Head();
+            return new ArtistViewModel(
+                metadata.Title,
+                metadata.Disambiguation,
+                metadata.Biography,
+                Artwork(metadata, ArtworkKind.Thumbnail),
+                Artwork(metadata, ArtworkKind.FanArt),
+                metadata.Genres.Map(g => g.Name).ToList(),
+                metadata.Styles.Map(s => s.Name).ToList(),
+                metadata.Moods.Map(m => m.Name).ToList(),
+                LanguagesForArtist(languages));
+        }
+
+        private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>
+            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+                .Match(a => a.Path, string.Empty);
+
+        private static List<CultureInfo> LanguagesForArtist(List<string> languages)
+        {
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+            return languages
+                .Distinct()
+                .Map(
+                    lang => allCultures.Filter(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+                .Sequence()
+                .Flatten()
+                .ToList();
+        }
+    }
+}

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public record GetArtistById(int ArtistId) : IRequest<Option<ArtistViewModel>>;
+}

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Artists.Mapper;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
+    {
+        private readonly IArtistRepository _artistRepository;
+        private readonly ISearchRepository _searchRepository;
+
+        public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
+        {
+            _artistRepository = artistRepository;
+            _searchRepository = searchRepository;
+        }
+
+        public async Task<Option<ArtistViewModel>> Handle(
+            GetArtistById request,
+            CancellationToken cancellationToken)
+        {
+            Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
+            return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
+                async artist =>
+                {
+                    List<string> languages = await _searchRepository.GetLanguagesForArtist(artist);
+                    return ProjectToViewModel(artist, languages);
+                },
+                () => Task.FromResult(Option<ArtistViewModel>.None));
+        }
+    }
+}

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : MediatR.IRequest<Unit>;
+}

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -0,0 +1,34 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public class SaveConfigElementByKeyHandler : MediatR.IRequestHandler<SaveConfigElementByKey, Unit>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
+        {
+            Option<ConfigElement> maybeElement = await _configElementRepository.Get(request.Key);
+            await maybeElement.Match(
+                ce =>
+                {
+                    ce.Value = request.Value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = request.Key.Key, Value = request.Value };
+                    return _configElementRepository.Add(ce);
+                });
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Configuration
+{
+    public record ConfigElementViewModel(string Key, string Value);
+}

ErsatzTV.Application/Configuration/Mapper.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Configuration
+{
+    internal static class Mapper
+    {
+        internal static ConfigElementViewModel ProjectToViewModel(ConfigElement element) =>
+            new(element.Key, element.Value);
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public record GetConfigElementByKey(ConfigElementKey Key) : IRequest<Option<ConfigElementViewModel>>;
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

@@ -0,0 +1,22 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Configuration.Mapper;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<Option<ConfigElementViewModel>> Handle(
+            GetConfigElementByKey request,
+            CancellationToken cancellationToken) =>
+            _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -86,8 +86,10 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             return Unit.Default;
         }
 
-        private Task Upsert(ConfigElementKey key, string value) =>
-            _configElementRepository.Get(key).Match(
+        private async Task Upsert(ConfigElementKey key, string value)
+        {
+            Option<ConfigElement> maybeElement = await _configElementRepository.Get(key);
+            await maybeElement.Match(
                 ce =>
                 {
                     ce.Value = value;
@@ -98,5 +100,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     var ce = new ConfigElement { Key = key.Key, Value = value };
                     return _configElementRepository.Add(ce);
                 });
+        }
     }
 }

ErsatzTV.Application/MediaCards/ActorCardViewModel.cs

@@ -0,0 +1,5 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb) :
+        MediaCardViewModel(Id, Name, Role, Name, Thumb);
+}

ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record ArtistCardViewModel
+        (int ArtistId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            ArtistId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster);
+}

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using ErsatzTV.Core.Domain;
 using static LanguageExt.Prelude;
@@ -55,11 +54,20 @@ namespace ErsatzTV.Application.MediaCards
         internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
             new(
                 musicVideoMetadata.MusicVideoId,
-                $"{musicVideoMetadata.Title} ({musicVideoMetadata.Artist})",
-                musicVideoMetadata.Year?.ToString(),
+                musicVideoMetadata.Title,
+                musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
                 musicVideoMetadata.SortTitle,
+                musicVideoMetadata.Plot,
                 GetThumbnail(musicVideoMetadata));
 
+        internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
+            new(
+                artistMetadata.ArtistId,
+                artistMetadata.Title,
+                artistMetadata.Disambiguation,
+                artistMetadata.SortTitle,
+                GetThumbnail(artistMetadata));
+
         internal static CollectionCardResultsViewModel
             ProjectToViewModel(Collection collection) =>
             new(
@@ -73,19 +81,18 @@ namespace ErsatzTV.Application.MediaCards
                 collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
                 collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
                     .ToList(),
+                collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
+        internal static ActorCardViewModel ProjectToViewModel(Actor actor) =>
+            new(actor.Id, actor.Name, actor.Role, actor.Artwork?.Path);
+
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>
             Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
                 .Map(ci => ci.CustomIndex ?? 0)
                 .IfNone(0);
 
-        internal static SearchCardResultsViewModel ProjectToSearchResults(List<MediaItem> items) =>
-            new(
-                items.OfType<Movie>().Map(m => ProjectToViewModel(m.MovieMetadata.Head())).ToList(),
-                items.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList());
-
         private static string GetSeasonName(int number) =>
             number == 0 ? "Specials" : $"Season {number}";
 

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

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

ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.cs

@@ -0,0 +1,33 @@
+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;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class GetMusicVideoCardsHandler : IRequestHandler<GetMusicVideoCards, MusicVideoCardResultsViewModel>
+    {
+        private readonly IMusicVideoRepository _musicVideoRepository;
+
+        public GetMusicVideoCardsHandler(IMusicVideoRepository musicVideoRepository) =>
+            _musicVideoRepository = musicVideoRepository;
+
+        public async Task<MusicVideoCardResultsViewModel> Handle(
+            GetMusicVideoCards request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _musicVideoRepository.GetMusicVideoCount(request.ArtistId);
+
+            List<MusicVideoCardViewModel> results = await _musicVideoRepository
+                .GetPagedMusicVideos(request.ArtistId, request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new MusicVideoCardResultsViewModel(count, results, None);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs

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

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -9,5 +9,6 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         int CollectionId,
         List<int> MovieIds,
         List<int> ShowIds,
+        List<int> ArtistIds,
         List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -39,9 +39,13 @@ namespace ErsatzTV.Application.MediaCollections.Commands
 
         private async Task<Unit> ApplyAddItemsRequest(AddItemsToCollection request)
         {
-            if (await _mediaCollectionRepository.AddMediaItems(
-                request.CollectionId,
-                request.MovieIds.Append(request.ShowIds).Append(request.MusicVideoIds).ToList()))
+            var allItems = request.MovieIds
+                .Append(request.ShowIds)
+                .Append(request.ArtistIds)
+                .Append(request.MusicVideoIds)
+                .ToList();
+
+            if (await _mediaCollectionRepository.AddMediaItems(request.CollectionId, allItems))
             {
                 // rebuild all playouts that use this collection
                 foreach (int playoutId in await _mediaCollectionRepository

ErsatzTV.Application/MediaCollections/PagedMediaCollectionsViewModel.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetPagedCollections.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs

@@ -0,0 +1,32 @@
+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.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetPagedCollectionsHandler : IRequestHandler<GetPagedCollections, PagedMediaCollectionsViewModel>
+    {
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public GetPagedCollectionsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+            _mediaCollectionRepository = mediaCollectionRepository;
+
+        public async Task<PagedMediaCollectionsViewModel> Handle(
+            GetPagedCollections request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _mediaCollectionRepository.CountAllCollections();
+
+            List<MediaCollectionViewModel> page = await _mediaCollectionRepository
+                .GetPagedCollections(request.PageNum, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedMediaCollectionsViewModel(count, page);
+        }
+    }
+}

ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs

@@ -20,7 +20,7 @@ namespace ErsatzTV.Application.MediaItems.Queries
         {
             var result = new List<CultureInfo>();
 
-            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
             List<string> allLanguageCodes = await _mediaItemRepository.GetAllLanguageCodes();
             foreach (string code in allLanguageCodes)
             {

ErsatzTV.Application/Movies/Mapper.cs

@@ -1,5 +1,9 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Movies
@@ -17,7 +21,26 @@ namespace ErsatzTV.Application.Movies
                 Artwork(metadata, ArtworkKind.FanArt),
                 metadata.Genres.Map(g => g.Name).ToList(),
                 metadata.Tags.Map(t => t.Name).ToList(),
-                metadata.Studios.Map(s => s.Name).ToList());
+                metadata.Studios.Map(s => s.Name).ToList(),
+                LanguagesForMovie(movie),
+                metadata.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id).Map(MediaCards.Mapper.ProjectToViewModel)
+                    .ToList());
+        }
+
+        private static List<CultureInfo> LanguagesForMovie(Movie movie)
+        {
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+            return movie.MediaVersions
+                .Map(mv => mv.Streams.Filter(s => s.MediaStreamKind == MediaStreamKind.Audio).Map(s => s.Language))
+                .Flatten()
+                .Distinct()
+                .Map(
+                    lang => allCultures.Filter(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+                .Sequence()
+                .Flatten()
+                .ToList();
         }
 
         private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Globalization;
+using ErsatzTV.Application.MediaCards;
 
 namespace ErsatzTV.Application.Movies
 {
@@ -10,5 +12,7 @@ namespace ErsatzTV.Application.Movies
         string FanArt,
         List<string> Genres,
         List<string> Tags,
-        List<string> Studios);
+        List<string> Studios,
+        List<CultureInfo> Languages,
+        List<ActorCardViewModel> Actors);
 }

ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs

@@ -48,7 +48,7 @@ namespace ErsatzTV.Application.Playouts.Commands
         }
 
         private async Task<Validation<BaseError, Playout>> Validate(CreatePlayout request) =>
-            (await ChannelMustExist(request), await ProgramScheduleMustExist(request), ValidatePlayoutType(request))
+            (await ValidateChannel(request), await ProgramScheduleMustExist(request), ValidatePlayoutType(request))
             .Apply(
                 (channel, programSchedule, playoutType) => new Playout
                 {
@@ -57,10 +57,19 @@ namespace ErsatzTV.Application.Playouts.Commands
                     ProgramSchedulePlayoutType = playoutType
                 });
 
+        private Task<Validation<BaseError, Channel>> ValidateChannel(CreatePlayout createPlayout) =>
+            ChannelMustExist(createPlayout).BindT(ChannelMustNotHavePlayouts);
+
         private async Task<Validation<BaseError, Channel>> ChannelMustExist(CreatePlayout createPlayout) =>
             (await _channelRepository.Get(createPlayout.ChannelId))
             .ToValidation<BaseError>("Channel does not exist.");
 
+        private async Task<Validation<BaseError, Channel>> ChannelMustNotHavePlayouts(Channel channel) =>
+            Optional(await _channelRepository.CountPlayouts(channel.Id))
+                .Filter(count => count == 0)
+                .Map(_ => channel)
+                .ToValidation<BaseError>("Channel already has one playout.");
+
         private async Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
             CreatePlayout createPlayout) =>
             (await _programScheduleRepository.GetWithPlayouts(createPlayout.ProgramScheduleId))

ErsatzTV.Application/Playouts/Mapper.cs

@@ -37,7 +37,10 @@ namespace ErsatzTV.Application.Playouts
                 case Movie m:
                     return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
                 case MusicVideo mv:
-                    return mv.MusicVideoMetadata.HeadOrNone().Map(mvm => $"{mvm.Artist} - {mvm.Title}")
+                    string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
+                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
+                    return mv.MusicVideoMetadata.HeadOrNone()
+                        .Map(mvm => $"{artistName}{mvm.Title}")
                         .IfNone("[unknown music video]");
                 default:
                     return string.Empty;

ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs

@@ -10,6 +10,7 @@ using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Plex.Commands
 {
@@ -19,6 +20,7 @@ namespace ErsatzTV.Application.Plex.Commands
     {
         private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
         private readonly IEntityLocker _entityLocker;
+        private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
         private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly IPlexTvApiClient _plexTvApiClient;
 
@@ -26,12 +28,14 @@ namespace ErsatzTV.Application.Plex.Commands
             IMediaSourceRepository mediaSourceRepository,
             IPlexTvApiClient plexTvApiClient,
             ChannelWriter<IPlexBackgroundServiceRequest> channel,
-            IEntityLocker entityLocker)
+            IEntityLocker entityLocker,
+            ILogger<SynchronizePlexMediaSourcesHandler> logger)
         {
             _mediaSourceRepository = mediaSourceRepository;
             _plexTvApiClient = plexTvApiClient;
             _channel = channel;
             _entityLocker = entityLocker;
+            _logger = logger;
         }
 
         public Task<Either<BaseError, List<PlexMediaSource>>> Handle(
@@ -47,6 +51,14 @@ namespace ErsatzTV.Application.Plex.Commands
                 await SynchronizeServer(allExisting, server);
             }
 
+            // delete removed servers
+            foreach (PlexMediaSource removed in allExisting.Filter(
+                s => servers.All(pms => pms.ClientIdentifier != s.ClientIdentifier)))
+            {
+                _logger.LogWarning("Deleting removed Plex server {ServerName}!", removed.Id.ToString());
+                await _mediaSourceRepository.DeletePlex(removed);
+            }
+
             foreach (PlexMediaSource mediaSource in await _mediaSourceRepository.GetAllPlex())
             {
                 await _channel.WriteAsync(new SynchronizePlexLibraries(mediaSource.Id));
@@ -72,7 +84,7 @@ namespace ErsatzTV.Application.Plex.Commands
                         .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);
+                    return _mediaSourceRepository.Update(existing, server.Connections, toAdd, toRemove);
                 },
                 async () =>
                 {

ErsatzTV.Application/Search/Queries/QuerySearchIndex.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItems.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexAllItems(string Query) : IRequest<SearchResultAllItemsViewModel>;
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
+    {
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+
+        public async Task<SearchResultAllItemsViewModel> Handle(
+            QuerySearchIndexAllItems request,
+            CancellationToken cancellationToken)
+        {
+            List<int> movieIds = await _searchIndex.Search($"type:movie AND ({request.Query})", 0, 0)
+                .Map(result => result.Items.Map(i => i.Id).ToList());
+            List<int> showIds = await _searchIndex.Search($"type:show AND ({request.Query})", 0, 0)
+                .Map(result => result.Items.Map(i => i.Id).ToList());
+            List<int> artistIds = await _searchIndex.Search($"type:artist AND ({request.Query})", 0, 0)
+                .Map(result => result.Items.Map(i => i.Id).ToList());
+            List<int> musicVideoIds = await _searchIndex.Search($"type:music_video AND ({request.Query})", 0, 0)
+                .Map(result => result.Items.Map(i => i.Id).ToList());
+
+            return new SearchResultAllItemsViewModel(movieIds, showIds, artistIds, musicVideoIds);
+        }
+    }
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexArtists.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs

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

ErsatzTV.Application/Search/Queries/QuerySearchIndexHandler.cs

@@ -1,18 +0,0 @@
-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/SearchResultAllItemsViewModel.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.Search
+{
+    public record SearchResultAllItemsViewModel(
+        List<int> MovieIds,
+        List<int> ShowIds,
+        List<int> ArtistIds,
+        List<int> MusicVideoIds);
+}

ErsatzTV.Application/Television/Mapper.cs

@@ -1,13 +1,17 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Television
 {
     internal static class Mapper
     {
-        internal static TelevisionShowViewModel ProjectToViewModel(Show show) =>
+        internal static TelevisionShowViewModel ProjectToViewModel(Show show, List<string> languages) =>
             new(
                 show.Id,
                 show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
@@ -18,7 +22,13 @@ namespace ErsatzTV.Application.Television
                 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.Studios.Map(s => s.Name).ToList())
-                    .IfNone(new List<string>()));
+                    .IfNone(new List<string>()),
+                LanguagesForShow(languages),
+                show.ShowMetadata.HeadOrNone()
+                    .Map(
+                        m => m.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id).Map(MediaCards.Mapper.ProjectToViewModel)
+                            .ToList())
+                    .IfNone(new List<ActorCardViewModel>()));
 
         internal static TelevisionSeasonViewModel ProjectToViewModel(Season season) =>
             new(
@@ -48,5 +58,19 @@ namespace ErsatzTV.Application.Television
         private static string GetArtwork(Metadata metadata, ArtworkKind artworkKind) =>
             Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
                 .Match(a => a.Path, string.Empty);
+
+        private static List<CultureInfo> LanguagesForShow(List<string> languages)
+        {
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+            return languages
+                .Distinct()
+                .Map(
+                    lang => allCultures.Filter(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+                .Sequence()
+                .Flatten()
+                .ToList();
+        }
     }
 }

ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs

@@ -1,5 +1,7 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
@@ -9,15 +11,29 @@ namespace ErsatzTV.Application.Television.Queries
 {
     public class GetTelevisionShowByIdHandler : IRequestHandler<GetTelevisionShowById, Option<TelevisionShowViewModel>>
     {
+        private readonly ISearchRepository _searchRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
-        public GetTelevisionShowByIdHandler(ITelevisionRepository televisionRepository) =>
+        public GetTelevisionShowByIdHandler(
+            ITelevisionRepository televisionRepository,
+            ISearchRepository searchRepository)
+        {
             _televisionRepository = televisionRepository;
+            _searchRepository = searchRepository;
+        }
 
-        public Task<Option<TelevisionShowViewModel>> Handle(
+        public async Task<Option<TelevisionShowViewModel>> Handle(
             GetTelevisionShowById request,
-            CancellationToken cancellationToken) =>
-            _televisionRepository.GetShow(request.Id)
-                .MapT(ProjectToViewModel);
+            CancellationToken cancellationToken)
+        {
+            Option<Show> maybeShow = await _televisionRepository.GetShow(request.Id);
+            return await maybeShow.Match<Task<Option<TelevisionShowViewModel>>>(
+                async show =>
+                {
+                    List<string> languages = await _searchRepository.GetLanguagesForShow(show);
+                    return ProjectToViewModel(show, languages);
+                },
+                () => Task.FromResult(Option<TelevisionShowViewModel>.None));
+        }
     }
 }

ErsatzTV.Application/Television/TelevisionShowViewModel.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Globalization;
+using ErsatzTV.Application.MediaCards;
 
 namespace ErsatzTV.Application.Television
 {
@@ -11,5 +13,7 @@ namespace ErsatzTV.Application.Television
         string FanArt,
         List<string> Genres,
         List<string> Tags,
-        List<string> Studios);
+        List<string> Studios,
+        List<CultureInfo> Languages,
+        List<ActorCardViewModel> Actors);
 }

ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs

@@ -26,6 +26,11 @@ namespace ErsatzTV.Core.Tests.Fakes
             throw new NotSupportedException();
 
         public Task<List<Collection>> GetAll() => throw new NotSupportedException();
+        public Task<int> CountAllCollections() => throw new NotSupportedException();
+
+        public Task<List<Collection>> GetPagedCollections(int pageNumber, int pageSize) =>
+            throw new NotSupportedException();
+
         public Task<Option<List<MediaItem>>> GetItems(int id) => Some(_data[id].ToList()).AsTask();
         Task<bool> IMediaCollectionRepository.Update(Collection collection) => throw new NotSupportedException();
         public Task Delete(int collectionId) => throw new NotSupportedException();

ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs

@@ -79,6 +79,9 @@ namespace ErsatzTV.Core.Tests.Fakes
         public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();
 
         public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
+        public Task<bool> AddActor(ShowMetadata metadata, Actor actor) => throw new NotSupportedException();
+
+        public Task<bool> AddActor(EpisodeMetadata metadata, Actor actor) => throw new NotSupportedException();
 
         public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
             throw new NotSupportedException();

ErsatzTV.Core/Domain/ConfigElementKey.cs

@@ -14,5 +14,6 @@
         public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
         public static ConfigElementKey SearchIndexVersion => new("search_index.version");
         public static ConfigElementKey HDHRTunerCount => new("hdhr.tuner_count");
+        public static ConfigElementKey CollectionsPageSize => new("pages.collections.page_size");
     }
 }

ErsatzTV.Core/Domain/MediaItem/Artist.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class Artist : MediaItem
+    {
+        public List<MusicVideo> MusicVideos { get; set; }
+        public List<ArtistMetadata> ArtistMetadata { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs

@@ -4,6 +4,8 @@ namespace ErsatzTV.Core.Domain
 {
     public class MusicVideo : MediaItem
     {
+        public int ArtistId { get; set; }
+        public Artist Artist { get; set; }
         public List<MusicVideoMetadata> MusicVideoMetadata { get; set; }
         public List<MediaVersion> MediaVersions { get; set; }
     }

ErsatzTV.Core/Domain/Metadata/Actor.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class Actor
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Role { get; set; }
+        public int? Order { get; set; }
+        public int? ArtworkId { get; set; }
+        public Artwork Artwork { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Metadata/ArtistMetadata.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class ArtistMetadata : Metadata
+    {
+        public string Disambiguation { get; set; }
+        public string Biography { get; set; }
+        public string Formed { get; set; }
+        public int ArtistId { get; set; }
+        public Artist Artist { get; set; }
+        public List<Style> Styles { get; set; }
+        public List<Mood> Moods { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Metadata/Metadata.cs

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

ErsatzTV.Core/Domain/Metadata/Mood.cs

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

ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs

@@ -4,7 +4,6 @@
     {
         public string Album { get; set; }
         public string Plot { get; set; }
-        public string Artist { get; set; }
         public int MusicVideoId { get; set; }
         public MusicVideo MusicVideo { get; set; }
     }

ErsatzTV.Core/Domain/Metadata/Style.cs

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

ErsatzTV.Core/FFmpeg/DisplaySizeExtensions.cs

@@ -4,9 +4,6 @@ namespace ErsatzTV.Core.FFmpeg
 {
     public static class DisplaySizeExtensions
     {
-        internal static IDisplaySize PadToEven(this IDisplaySize size) =>
-            new DisplaySize(size.Width + size.Width % 2, size.Height + size.Height % 2);
-
         internal static bool IsSameSizeAs(this IDisplaySize @this, IDisplaySize that) =>
             @this.Width == that.Width && @this.Height == that.Height;
     }

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -60,7 +60,6 @@ namespace ErsatzTV.Core.FFmpeg
                     builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
                         .WithScaling(scaledSize);
 
-                    scaledSize = scaledSize.PadToEven();
                     if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
                     {
                         builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);

ErsatzTV.Core/Interfaces/GitHub/IGitHubApiClient.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.GitHub
+{
+    public interface IGitHubApiClient
+    {
+        Task<Either<BaseError, string>> GetLatestReleaseNotes();
+        Task<Either<BaseError, string>> GetReleaseNotes(string tag);
+    }
+}

ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs

@@ -1,14 +1,16 @@
 using System;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface IFallbackMetadataProvider
     {
         ShowMetadata GetFallbackMetadataForShow(string showFolder);
+        ArtistMetadata GetFallbackMetadataForArtist(string artistFolder);
         Tuple<EpisodeMetadata, int> GetFallbackMetadata(Episode episode);
         MovieMetadata GetFallbackMetadata(Movie movie);
-        MusicVideoMetadata GetFallbackMetadata(MusicVideo musicVideo);
+        Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo);
         string GetSortTitle(string title);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs

@@ -6,12 +6,15 @@ namespace ErsatzTV.Core.Interfaces.Metadata
     public interface ILocalMetadataProvider
     {
         Task<ShowMetadata> GetMetadataForShow(string showFolder);
+        Task<ArtistMetadata> GetMetadataForArtist(string artistFolder);
         Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName);
         Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName);
         Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName);
+        Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName);
         Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName);
         Task<bool> RefreshFallbackMetadata(Movie movie);
         Task<bool> RefreshFallbackMetadata(Episode episode);
+        Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder);
         Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo);
         Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
     }

ErsatzTV.Core/Interfaces/Plex/IPlexMovieLibraryScanner.cs

@@ -10,6 +10,6 @@ namespace ErsatzTV.Core.Interfaces.Plex
         Task<Either<BaseError, Unit>> ScanLibrary(
             PlexConnection connection,
             PlexServerAuthToken token,
-            PlexLibrary plexMediaSourceLibrary);
+            PlexLibrary library);
     }
 }

ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs

@@ -34,6 +34,18 @@ namespace ErsatzTV.Core.Interfaces.Plex
             PlexConnection connection,
             PlexServerAuthToken token);
 
+        Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
+            PlexLibrary library,
+            string key,
+            PlexConnection connection,
+            PlexServerAuthToken token);
+
+        Task<Either<BaseError, ShowMetadata>> GetShowMetadata(
+            PlexLibrary library,
+            string key,
+            PlexConnection connection,
+            PlexServerAuthToken token);
+
         Task<Either<BaseError, MediaVersion>> GetStatistics(
             string key,
             PlexConnection connection,

ErsatzTV.Core/Interfaces/Plex/IPlexTelevisionLibraryScanner.cs

@@ -10,6 +10,6 @@ namespace ErsatzTV.Core.Interfaces.Plex
         Task<Either<BaseError, Unit>> ScanLibrary(
             PlexConnection connection,
             PlexServerAuthToken token,
-            PlexLibrary plexMediaSourceLibrary);
+            PlexLibrary library);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IArtistRepository.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Repositories
+{
+    public interface IArtistRepository
+    {
+        Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata);
+
+        Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
+            int libraryPathId,
+            string artistFolder,
+            ArtistMetadata metadata);
+
+        Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath);
+        Task<Option<Artist>> GetArtist(int artistId);
+        Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids);
+        Task<bool> AddGenre(ArtistMetadata metadata, Genre genre);
+        Task<bool> AddStyle(ArtistMetadata metadata, Style style);
+        Task<bool> AddMood(ArtistMetadata metadata, Mood mood);
+    }
+}

ErsatzTV.Core/Interfaces/Repositories/IChannelRepository.cs

@@ -14,5 +14,6 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<List<Channel>> GetAllForGuide();
         Task Update(Channel channel);
         Task Delete(int channelId);
+        Task<int> CountPlayouts(int channelId);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs

@@ -15,6 +15,8 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<Option<Collection>> GetCollectionWithItemsUntracked(int id);
         Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id);
         Task<List<Collection>> GetAll();
+        Task<int> CountAllCollections();
+        Task<List<Collection>> GetPagedCollections(int pageNumber, int pageSize);
         Task<Option<List<MediaItem>>> GetItems(int id);
         Task<bool> Update(Collection collection);
         Task Delete(int collectionId);

ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs

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

ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs

@@ -10,6 +10,9 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<bool> RemoveGenre(Genre genre);
         Task<bool> RemoveTag(Tag tag);
         Task<bool> RemoveStudio(Studio studio);
+        Task<bool> RemoveStyle(Style style);
+        Task<bool> RemoveMood(Mood mood);
+        Task<bool> RemoveActor(Actor actor);
         Task<bool> Update(Domain.Metadata metadata);
         Task<bool> Add(Domain.Metadata metadata);
         Task<bool> UpdateLocalStatistics(int mediaVersionId, MediaVersion incoming, bool updateVersion = true);
@@ -20,5 +23,6 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated);
         Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated);
         Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated);
+        Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs

@@ -20,6 +20,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<bool> AddGenre(MovieMetadata metadata, Genre genre);
         Task<bool> AddTag(MovieMetadata metadata, Tag tag);
         Task<bool> AddStudio(MovieMetadata metadata, Studio studio);
+        Task<bool> AddActor(MovieMetadata metadata, Actor actor);
         Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys);
         Task<bool> UpdateSortTitle(MovieMetadata movieMetadata);
     }

ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs

@@ -8,7 +8,11 @@ namespace ErsatzTV.Core.Interfaces.Repositories
 {
     public interface IMusicVideoRepository
     {
-        Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(LibraryPath libraryPath, string path);
+        Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
+            Artist artist,
+            LibraryPath libraryPath,
+            string path);
+
         Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath);
         Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
         Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre);
@@ -16,5 +20,8 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio);
         Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids);
         Task<Option<MusicVideo>> GetMusicVideo(int musicVideoId);
+        Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath);
+        Task<int> GetMusicVideoCount(int artistId);
+        Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs

@@ -9,9 +9,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories
     {
         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);
         public Task<List<string>> GetLanguagesForShow(Show show);
+        public Task<List<string>> GetLanguagesForArtist(Artist artist);
     }
 }

ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs

@@ -42,6 +42,8 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<bool> AddGenre(ShowMetadata metadata, Genre genre);
         Task<bool> AddTag(ShowMetadata metadata, Tag tag);
         Task<bool> AddStudio(ShowMetadata metadata, Studio studio);
+        Task<bool> AddActor(ShowMetadata metadata, Actor actor);
+        Task<bool> AddActor(EpisodeMetadata metadata, Actor actor);
         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);

ErsatzTV.Core/Iptv/ChannelGuide.cs

@@ -221,8 +221,8 @@ namespace ErsatzTV.Core.Iptv
                     .IfNone("[unknown movie]"),
                 Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
                     .IfNone("[unknown show]"),
-                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => $"{mvm.Artist} - {mvm.Title}")
-                    .IfNone("[unknown music video]"),
+                MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
+                    .IfNone("[unknown artist]"),
                 _ => "[unknown]"
             };
         }
@@ -239,6 +239,9 @@ namespace ErsatzTV.Core.Iptv
                 Episode e => e.EpisodeMetadata.HeadOrNone().Match(
                     em => em.Title ?? string.Empty,
                     () => string.Empty),
+                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                    mvm => mvm.Title ?? string.Empty,
+                    () => string.Empty),
                 _ => string.Empty
             };
         }

ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Text.RegularExpressions;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
+using LanguageExt;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Metadata
@@ -18,6 +19,13 @@ namespace ErsatzTV.Core.Metadata
             return GetTelevisionShowMetadata(fileName, metadata);
         }
 
+        public ArtistMetadata GetFallbackMetadataForArtist(string artistFolder)
+        {
+            string fileName = Path.GetFileName(artistFolder);
+            return new ArtistMetadata
+                { MetadataKind = MetadataKind.Fallback, Title = fileName ?? artistFolder };
+        }
+
         public Tuple<EpisodeMetadata, int> GetFallbackMetadata(Episode episode)
         {
             string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
@@ -36,7 +44,7 @@ namespace ErsatzTV.Core.Metadata
             return fileName != null ? GetMovieMetadata(fileName, metadata) : metadata;
         }
 
-        public MusicVideoMetadata GetFallbackMetadata(MusicVideo musicVideo)
+        public Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo)
         {
             string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
             string fileName = Path.GetFileName(path);
@@ -46,7 +54,7 @@ namespace ErsatzTV.Core.Metadata
                 Title = fileName ?? path
             };
 
-            return fileName != null ? GetMusicVideoMetadata(fileName, metadata) : metadata;
+            return GetMusicVideoMetadata(fileName, metadata);
         }
 
         public string GetSortTitle(string title)
@@ -89,6 +97,7 @@ namespace ErsatzTV.Core.Metadata
                 {
                     metadata.Title = match.Groups[1].Value;
                     metadata.DateUpdated = DateTime.UtcNow;
+                    metadata.Actors = new List<Actor>();
                     return Tuple(metadata, int.Parse(match.Groups[3].Value));
                 }
             }
@@ -114,6 +123,7 @@ namespace ErsatzTV.Core.Metadata
                     metadata.Genres = new List<Genre>();
                     metadata.Tags = new List<Tag>();
                     metadata.Studios = new List<Studio>();
+                    metadata.Actors = new List<Actor>();
                     metadata.DateUpdated = DateTime.UtcNow;
                 }
             }
@@ -125,28 +135,26 @@ namespace ErsatzTV.Core.Metadata
             return metadata;
         }
 
-        private MusicVideoMetadata GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
+        private Option<MusicVideoMetadata> GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
         {
             try
             {
                 const string PATTERN = @"^(.*?) - (.*?).\w+$";
                 Match match = Regex.Match(fileName, PATTERN);
-                if (match.Success)
-                {
-                    metadata.Artist = match.Groups[1].Value;
-                    metadata.Title = match.Groups[2].Value;
-                    metadata.Genres = new List<Genre>();
-                    metadata.Tags = new List<Tag>();
-                    metadata.Studios = new List<Studio>();
-                    metadata.DateUpdated = DateTime.UtcNow;
-                }
+                metadata.Title = match.Success
+                    ? match.Groups[2].Value.Trim()
+                    : Path.GetFileNameWithoutExtension(fileName);
+                metadata.Genres = new List<Genre>();
+                metadata.Tags = new List<Tag>();
+                metadata.Studios = new List<Studio>();
+                metadata.DateUpdated = DateTime.UtcNow;
+
+                return metadata;
             }
             catch (Exception)
             {
-                // ignored
+                return None;
             }
-
-            return metadata;
         }
 
         private ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
@@ -160,6 +168,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.Actors = new List<Actor>();
                     metadata.DateUpdated = DateTime.UtcNow;
                 }
             }

ErsatzTV.Core/Metadata/LocalFolderScanner.cs

@@ -166,5 +166,9 @@ namespace ErsatzTV.Core.Metadata
 
             return false;
         }
+
+        protected bool ShouldIncludeFolder(string folder) =>
+            !Path.GetFileName(folder).StartsWith('.') &&
+            !_localFileSystem.FileExists(Path.Combine(folder, ".etvignore"));
     }
 }

ErsatzTV.Core/Metadata/LocalMetadataProvider.cs

@@ -19,7 +19,9 @@ namespace ErsatzTV.Core.Metadata
         private static readonly XmlSerializer MovieSerializer = new(typeof(MovieNfo));
         private static readonly XmlSerializer EpisodeSerializer = new(typeof(TvShowEpisodeNfo));
         private static readonly XmlSerializer TvShowSerializer = new(typeof(TvShowNfo));
+        private static readonly XmlSerializer ArtistSerializer = new(typeof(ArtistNfo));
         private static readonly XmlSerializer MusicVideoSerializer = new(typeof(MusicVideoNfo));
+        private readonly IArtistRepository _artistRepository;
         private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILogger<LocalMetadataProvider> _logger;
@@ -33,6 +35,7 @@ namespace ErsatzTV.Core.Metadata
             IMetadataRepository metadataRepository,
             IMovieRepository movieRepository,
             ITelevisionRepository televisionRepository,
+            IArtistRepository artistRepository,
             IMusicVideoRepository musicVideoRepository,
             IFallbackMetadataProvider fallbackMetadataProvider,
             ILocalFileSystem localFileSystem,
@@ -41,6 +44,7 @@ namespace ErsatzTV.Core.Metadata
             _metadataRepository = metadataRepository;
             _movieRepository = movieRepository;
             _televisionRepository = televisionRepository;
+            _artistRepository = artistRepository;
             _musicVideoRepository = musicVideoRepository;
             _fallbackMetadataProvider = fallbackMetadataProvider;
             _localFileSystem = localFileSystem;
@@ -70,6 +74,29 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
+        public async Task<ArtistMetadata> GetMetadataForArtist(string artistFolder)
+        {
+            string nfoFileName = Path.Combine(artistFolder, "artist.nfo");
+            Option<ArtistMetadata> maybeMetadata = None;
+            if (_localFileSystem.FileExists(nfoFileName))
+            {
+                maybeMetadata = await LoadArtistMetadata(nfoFileName);
+            }
+
+            return maybeMetadata.Match(
+                metadata =>
+                {
+                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                    return metadata;
+                },
+                () =>
+                {
+                    ArtistMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder);
+                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                    return metadata;
+                });
+        }
+
         public Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName) =>
             LoadMovieMetadata(movie, nfoFileName).Bind(
                 maybeMetadata => maybeMetadata.Match(
@@ -88,6 +115,12 @@ namespace ErsatzTV.Core.Metadata
                     metadata => ApplyMetadataUpdate(episode, metadata),
                     () => Task.FromResult(false)));
 
+        public Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName) =>
+            LoadArtistMetadata(nfoFileName).Bind(
+                maybeMetadata => maybeMetadata.Match(
+                    metadata => ApplyMetadataUpdate(artist, metadata),
+                    () => Task.FromResult(false)));
+
         public Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName) =>
             LoadMusicVideoMetadata(nfoFileName).Bind(
                 maybeMetadata => maybeMetadata.Match(
@@ -100,8 +133,13 @@ namespace ErsatzTV.Core.Metadata
         public Task<bool> RefreshFallbackMetadata(Episode episode) =>
             ApplyMetadataUpdate(episode, _fallbackMetadataProvider.GetFallbackMetadata(episode));
 
+        public Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder) =>
+            ApplyMetadataUpdate(artist, _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder));
+
         public Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo) =>
-            ApplyMetadataUpdate(musicVideo, _fallbackMetadataProvider.GetFallbackMetadata(musicVideo));
+            _fallbackMetadataProvider.GetFallbackMetadata(musicVideo).Match(
+                metadata => ApplyMetadataUpdate(musicVideo, metadata),
+                () => Task.FromResult(false));
 
         public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
             ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
@@ -118,7 +156,6 @@ namespace ErsatzTV.Core.Metadata
                         MetadataKind = MetadataKind.Sidecar,
                         DateAdded = DateTime.UtcNow,
                         DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
-                        Artist = nfo.Artist,
                         Album = nfo.Album,
                         Title = nfo.Title,
                         Plot = nfo.Plot,
@@ -146,7 +183,7 @@ namespace ErsatzTV.Core.Metadata
             }
 
             await Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
-                existing =>
+                async existing =>
                 {
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
@@ -167,9 +204,17 @@ namespace ErsatzTV.Core.Metadata
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
 
-                    return _metadataRepository.Update(existing);
+                    bool updated = await UpdateMetadataCollections(
+                        existing,
+                        metadata,
+                        (_, _) => Task.FromResult(false),
+                        (_, _) => Task.FromResult(false),
+                        (_, _) => Task.FromResult(false),
+                        _televisionRepository.AddActor);
+
+                    return await _metadataRepository.Update(existing) || updated;
                 },
-                () =>
+                async () =>
                 {
                     metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
@@ -177,7 +222,7 @@ namespace ErsatzTV.Core.Metadata
                     metadata.EpisodeId = episode.Id;
                     episode.EpisodeMetadata = new List<EpisodeMetadata> { metadata };
 
-                    return _metadataRepository.Add(metadata);
+                    return await _metadataRepository.Add(metadata);
                 });
 
             return true;
@@ -211,7 +256,8 @@ namespace ErsatzTV.Core.Metadata
                         metadata,
                         _movieRepository.AddGenre,
                         _movieRepository.AddTag,
-                        _movieRepository.AddStudio);
+                        _movieRepository.AddStudio,
+                        _movieRepository.AddActor);
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
@@ -254,7 +300,8 @@ namespace ErsatzTV.Core.Metadata
                         metadata,
                         _televisionRepository.AddGenre,
                         _televisionRepository.AddTag,
-                        _televisionRepository.AddStudio);
+                        _televisionRepository.AddStudio,
+                        _televisionRepository.AddActor);
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
@@ -269,11 +316,104 @@ namespace ErsatzTV.Core.Metadata
                     return await _metadataRepository.Add(metadata);
                 });
 
+        private Task<bool> ApplyMetadataUpdate(Artist artist, ArtistMetadata metadata) =>
+            Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
+                async existing =>
+                {
+                    existing.Title = metadata.Title;
+                    existing.Disambiguation = metadata.Disambiguation;
+                    existing.Biography = metadata.Biography;
+
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+
+                    existing.DateUpdated = metadata.DateUpdated;
+                    existing.MetadataKind = metadata.MetadataKind;
+                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+
+                    var updated = false;
+
+                    foreach (Genre genre in existing.Genres.Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                        .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 _artistRepository.AddGenre(existing, genre))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Style style in existing.Styles.Filter(s => metadata.Styles.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Styles.Remove(style);
+                        if (await _metadataRepository.RemoveStyle(style))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Style style in metadata.Styles.Filter(s => existing.Styles.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Styles.Add(style);
+                        if (await _artistRepository.AddStyle(existing, style))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Mood mood in existing.Moods.Filter(m => metadata.Moods.All(m2 => m2.Name != m.Name))
+                        .ToList())
+                    {
+                        existing.Moods.Remove(mood);
+                        if (await _metadataRepository.RemoveMood(mood))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Mood mood in metadata.Moods.Filter(s => existing.Moods.All(m2 => m2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Moods.Add(mood);
+                        if (await _artistRepository.AddMood(existing, mood))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    return await _metadataRepository.Update(existing) || updated;
+                },
+                async () =>
+                {
+                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+                    metadata.ArtistId = artist.Id;
+                    artist.ArtistMetadata = new List<ArtistMetadata> { metadata };
+
+                    return await _metadataRepository.Add(metadata);
+                });
+
         private Task<bool> ApplyMetadataUpdate(MusicVideo musicVideo, MusicVideoMetadata metadata) =>
             Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
                 async existing =>
                 {
-                    existing.Artist = metadata.Artist;
                     existing.Title = metadata.Title;
                     existing.Year = metadata.Year;
                     existing.Plot = metadata.Plot;
@@ -297,7 +437,8 @@ namespace ErsatzTV.Core.Metadata
                         metadata,
                         _musicVideoRepository.AddGenre,
                         _musicVideoRepository.AddTag,
-                        _musicVideoRepository.AddStudio);
+                        _musicVideoRepository.AddStudio,
+                        (_, _) => Task.FromResult(false));
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
@@ -319,20 +460,27 @@ namespace ErsatzTV.Core.Metadata
                 await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
                 Option<TvShowNfo> maybeNfo = TvShowSerializer.Deserialize(fileStream) as TvShowNfo;
                 return maybeNfo.Match<Option<ShowMetadata>>(
-                    nfo => new ShowMetadata
+                    nfo =>
                     {
-                        MetadataKind = MetadataKind.Sidecar,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
-                        Title = nfo.Title,
-                        Plot = nfo.Plot,
-                        Outline = nfo.Outline,
-                        Tagline = nfo.Tagline,
-                        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(),
-                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
+                        DateTime dateAdded = DateTime.UtcNow;
+                        DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
+                        return new ShowMetadata
+                        {
+                            MetadataKind = MetadataKind.Sidecar,
+                            DateAdded = dateAdded,
+                            DateUpdated = dateUpdated,
+                            Title = nfo.Title,
+                            Plot = nfo.Plot,
+                            Outline = nfo.Outline,
+                            Tagline = nfo.Tagline,
+                            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(),
+                            Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
+                            Actors = Actors(nfo.Actors, dateAdded, dateUpdated)
+                        };
                     },
                     None);
             }
@@ -343,6 +491,34 @@ namespace ErsatzTV.Core.Metadata
             }
         }
 
+        private async Task<Option<ArtistMetadata>> LoadArtistMetadata(string nfoFileName)
+        {
+            try
+            {
+                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+                Option<ArtistNfo> maybeNfo = ArtistSerializer.Deserialize(fileStream) as ArtistNfo;
+                return maybeNfo.Match<Option<ArtistMetadata>>(
+                    nfo => new ArtistMetadata
+                    {
+                        MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                        Title = nfo.Name,
+                        Disambiguation = nfo.Disambiguation,
+                        Biography = nfo.Biography,
+                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                        Styles = nfo.Styles.Map(s => new Style { Name = s }).ToList(),
+                        Moods = nfo.Moods.Map(m => new Mood { Name = m }).ToList()
+                    },
+                    None);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogInformation(ex, "Failed to read artist nfo metadata from {Path}", nfoFileName);
+                return None;
+            }
+        }
+
         private async Task<Option<Tuple<EpisodeMetadata, int>>> LoadEpisodeMetadata(Episode episode, string nfoFileName)
         {
             try
@@ -352,14 +528,18 @@ namespace ErsatzTV.Core.Metadata
                 return maybeNfo.Match<Option<Tuple<EpisodeMetadata, int>>>(
                     nfo =>
                     {
+                        DateTime dateAdded = DateTime.UtcNow;
+                        DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
                         var metadata = new EpisodeMetadata
                         {
                             MetadataKind = MetadataKind.Sidecar,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                            DateAdded = dateAdded,
+                            DateUpdated = dateUpdated,
                             Title = nfo.Title,
                             ReleaseDate = GetAired(0, nfo.Aired),
-                            Plot = nfo.Plot
+                            Plot = nfo.Plot,
+                            Actors = Actors(nfo.Actors, dateAdded, dateUpdated)
                         };
                         return Tuple(metadata, nfo.Episode);
                     },
@@ -379,20 +559,27 @@ namespace ErsatzTV.Core.Metadata
                 await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
                 Option<MovieNfo> maybeNfo = MovieSerializer.Deserialize(fileStream) as MovieNfo;
                 return maybeNfo.Match<Option<MovieMetadata>>(
-                    nfo => new MovieMetadata
+                    nfo =>
                     {
-                        MetadataKind = MetadataKind.Sidecar,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
-                        Title = nfo.Title,
-                        Year = nfo.Year,
-                        ReleaseDate = nfo.Premiered,
-                        Plot = nfo.Plot,
-                        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(),
-                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
+                        DateTime dateAdded = DateTime.UtcNow;
+                        DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
+                        return new MovieMetadata
+                        {
+                            MetadataKind = MetadataKind.Sidecar,
+                            DateAdded = dateAdded,
+                            DateUpdated = dateUpdated,
+                            Title = nfo.Title,
+                            Year = nfo.Year,
+                            ReleaseDate = nfo.Premiered,
+                            Plot = nfo.Plot,
+                            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(),
+                            Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
+                            Actors = Actors(nfo.Actors, dateAdded, dateUpdated)
+                        };
                     },
                     None);
             }
@@ -440,74 +627,135 @@ namespace ErsatzTV.Core.Metadata
             T incoming,
             Func<T, Genre, Task<bool>> addGenre,
             Func<T, Tag, Task<bool>> addTag,
-            Func<T, Studio, Task<bool>> addStudio)
+            Func<T, Studio, Task<bool>> addStudio,
+            Func<T, Actor, Task<bool>> addActor)
             where T : Domain.Metadata
         {
             var updated = false;
 
-            foreach (Genre genre in existing.Genres.Filter(g => incoming.Genres.All(g2 => g2.Name != g.Name))
-                .ToList())
+            if (existing is not EpisodeMetadata)
             {
-                existing.Genres.Remove(genre);
-                if (await _metadataRepository.RemoveGenre(genre))
+                foreach (Genre genre in existing.Genres.Filter(g => incoming.Genres.All(g2 => g2.Name != g.Name))
+                    .ToList())
                 {
-                    updated = true;
+                    existing.Genres.Remove(genre);
+                    if (await _metadataRepository.RemoveGenre(genre))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Genre genre in incoming.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
+                    .ToList())
+                {
+                    existing.Genres.Add(genre);
+                    if (await addGenre(existing, genre))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Tag tag in existing.Tags.Filter(t => incoming.Tags.All(t2 => t2.Name != t.Name))
+                    .ToList())
+                {
+                    existing.Tags.Remove(tag);
+                    if (await _metadataRepository.RemoveTag(tag))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Tag tag in incoming.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
+                    .ToList())
+                {
+                    existing.Tags.Add(tag);
+                    if (await addTag(existing, tag))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Studio studio in existing.Studios
+                    .Filter(s => incoming.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existing.Studios.Remove(studio);
+                    if (await _metadataRepository.RemoveStudio(studio))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Studio studio in incoming.Studios
+                    .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                    .ToList())
+                {
+                    existing.Studios.Add(studio);
+                    if (await addStudio(existing, studio))
+                    {
+                        updated = true;
+                    }
                 }
             }
 
-            foreach (Genre genre in incoming.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
-                .ToList())
+            if (existing is not MusicVideoMetadata)
             {
-                existing.Genres.Add(genre);
-                if (await addGenre(existing, genre))
+                foreach (Actor actor in existing.Actors
+                    .Filter(a => incoming.Actors.All(a2 => a2.Name != a.Name))
+                    .ToList())
                 {
-                    updated = true;
+                    existing.Actors.Remove(actor);
+                    if (await _metadataRepository.RemoveActor(actor))
+                    {
+                        updated = true;
+                    }
                 }
-            }
 
-            foreach (Tag tag in existing.Tags.Filter(t => incoming.Tags.All(t2 => t2.Name != t.Name))
-                .ToList())
-            {
-                existing.Tags.Remove(tag);
-                if (await _metadataRepository.RemoveTag(tag))
+                foreach (Actor actor in incoming.Actors
+                    .Filter(a => existing.Actors.All(a2 => a2.Name != a.Name))
+                    .ToList())
                 {
-                    updated = true;
-                }
-            }
-
-            foreach (Tag tag in incoming.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
-                .ToList())
-            {
-                existing.Tags.Add(tag);
-                if (await addTag(existing, tag))
-                {
-                    updated = true;
-                }
-            }
-
-            foreach (Studio studio in existing.Studios
-                .Filter(s => incoming.Studios.All(s2 => s2.Name != s.Name))
-                .ToList())
-            {
-                existing.Studios.Remove(studio);
-                if (await _metadataRepository.RemoveStudio(studio))
-                {
-                    updated = true;
-                }
-            }
-
-            foreach (Studio studio in incoming.Studios
-                .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
-                .ToList())
-            {
-                existing.Studios.Add(studio);
-                if (await addStudio(existing, studio))
-                {
-                    updated = true;
+                    existing.Actors.Add(actor);
+                    if (await addActor(existing, actor))
+                    {
+                        updated = true;
+                    }
                 }
             }
 
             return updated;
         }
+
+        private List<Actor> Actors(List<ActorNfo> actorNfos, DateTime dateAdded, DateTime dateUpdated)
+        {
+            var result = new List<Actor>();
+
+            for (var i = 0; i < actorNfos.Count; i++)
+            {
+                ActorNfo actorNfo = actorNfos[i];
+
+                var actor = new Actor
+                {
+                    Name = actorNfo.Name,
+                    Role = actorNfo.Role,
+                    Order = actorNfo.Order ?? i
+                };
+
+                if (!string.IsNullOrWhiteSpace(actorNfo.Thumb))
+                {
+                    actor.Artwork = new Artwork
+                    {
+                        Path = actorNfo.Thumb,
+                        ArtworkKind = ArtworkKind.Thumbnail,
+                        DateAdded = dateAdded,
+                        DateUpdated = dateUpdated
+                    };
+                }
+
+                result.Add(actor);
+            }
+
+            return result;
+        }
     }
 }

ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs

@@ -19,6 +19,7 @@ namespace ErsatzTV.Core.Metadata
 {
     public class MusicVideoFolderScanner : LocalFolderScanner, IMusicVideoFolderScanner
     {
+        private readonly IArtistRepository _artistRepository;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILocalMetadataProvider _localMetadataProvider;
         private readonly ILogger<MusicVideoFolderScanner> _logger;
@@ -35,6 +36,7 @@ namespace ErsatzTV.Core.Metadata
             IImageCache imageCache,
             ISearchIndex searchIndex,
             ISearchRepository searchRepository,
+            IArtistRepository artistRepository,
             IMusicVideoRepository musicVideoRepository,
             IMediator mediator,
             ILogger<MusicVideoFolderScanner> logger) : base(
@@ -48,6 +50,7 @@ namespace ErsatzTV.Core.Metadata
             _localMetadataProvider = localMetadataProvider;
             _searchIndex = searchIndex;
             _searchRepository = searchRepository;
+            _artistRepository = artistRepository;
             _musicVideoRepository = musicVideoRepository;
             _mediator = mediator;
             _logger = logger;
@@ -67,23 +70,175 @@ namespace ErsatzTV.Core.Metadata
                 return new MediaSourceInaccessible();
             }
 
-            var foldersCompleted = 0;
+            var allArtistFolders = _localFileSystem.ListSubdirectories(libraryPath.Path)
+                .Filter(ShouldIncludeFolder)
+                .OrderBy(identity)
+                .ToList();
 
-            var folderQueue = new Queue<string>();
-            folderQueue.Enqueue(libraryPath.Path);
-
-            while (folderQueue.Count > 0)
+            foreach (string artistFolder in allArtistFolders)
             {
-                decimal percentCompletion = (decimal) foldersCompleted / (foldersCompleted + folderQueue.Count);
+                // _logger.LogDebug("Scanning artist folder {Folder}", artistFolder);
+
+                decimal percentCompletion = (decimal) allArtistFolders.IndexOf(artistFolder) / allArtistFolders.Count;
                 await _mediator.Publish(
                     new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
 
+                Either<BaseError, MediaItemScanResult<Artist>> maybeArtist =
+                    await FindOrCreateArtist(libraryPath.Id, artistFolder)
+                        .BindT(artist => UpdateMetadataForArtist(artist, artistFolder))
+                        .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.Thumbnail))
+                        .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.FanArt));
+
+                await maybeArtist.Match(
+                    async result =>
+                    {
+                        await ScanMusicVideos(
+                            libraryPath,
+                            ffprobePath,
+                            result.Item,
+                            artistFolder,
+                            // force scanning all folders if we're adding a new artist
+                            result.IsAdded ? DateTimeOffset.MinValue : lastScan);
+
+                        if (result.IsAdded)
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+                        else if (result.IsUpdated)
+                        {
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+                    },
+                    error =>
+                    {
+                        _logger.LogWarning(
+                            "Error processing artist in folder {Folder}: {Error}",
+                            artistFolder,
+                            error.Value);
+                        return Task.FromResult(Unit.Default);
+                    });
+            }
+
+            foreach (string path in await _musicVideoRepository.FindOrphanPaths(libraryPath))
+            {
+                _logger.LogInformation("Removing improperly named music video at {Path}", path);
+                List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
+                await _searchIndex.RemoveItems(musicVideoIds);
+            }
+
+            foreach (string path in await _musicVideoRepository.FindMusicVideoPaths(libraryPath))
+            {
+                if (!_localFileSystem.FileExists(path))
+                {
+                    _logger.LogInformation("Removing missing music video at {Path}", path);
+                    List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
+                    await _searchIndex.RemoveItems(musicVideoIds);
+                }
+            }
+
+            List<int> artistIds = await _artistRepository.DeleteEmptyArtists(libraryPath);
+            await _searchIndex.RemoveItems(artistIds);
+
+            _searchIndex.Commit();
+            return Unit.Default;
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> FindOrCreateArtist(
+            int libraryPathId,
+            string artistFolder)
+        {
+            ArtistMetadata metadata = await _localMetadataProvider.GetMetadataForArtist(artistFolder);
+            Option<Artist> maybeArtist = await _artistRepository.GetArtistByMetadata(libraryPathId, metadata);
+            return await maybeArtist.Match(
+                artist => Right<BaseError, MediaItemScanResult<Artist>>(new MediaItemScanResult<Artist>(artist))
+                    .AsTask(),
+                async () => await _artistRepository.AddArtist(libraryPathId, artistFolder, metadata));
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateMetadataForArtist(
+            MediaItemScanResult<Artist> result,
+            string artistFolder)
+        {
+            try
+            {
+                Artist artist = result.Item;
+                await LocateNfoFileForArtist(artistFolder).Match(
+                    async nfoFile =>
+                    {
+                        bool shouldUpdate = Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
+                            m => m.MetadataKind == MetadataKind.Fallback ||
+                                 m.DateUpdated < _localFileSystem.GetLastWriteTime(nfoFile),
+                            true);
+
+                        if (shouldUpdate)
+                        {
+                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                            if (await _localMetadataProvider.RefreshSidecarMetadata(artist, nfoFile))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+                    },
+                    async () =>
+                    {
+                        if (!Optional(artist.ArtistMetadata).Flatten().Any())
+                        {
+                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", artistFolder);
+                            if (await _localMetadataProvider.RefreshFallbackMetadata(artist, artistFolder))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+                    });
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateArtworkForArtist(
+            MediaItemScanResult<Artist> result,
+            string artistFolder,
+            ArtworkKind artworkKind)
+        {
+            try
+            {
+                Artist artist = result.Item;
+                await LocateArtworkForArtist(artistFolder, artworkKind).IfSomeAsync(
+                    async artworkFile =>
+                    {
+                        ArtistMetadata metadata = artist.ArtistMetadata.Head();
+                        await RefreshArtwork(artworkFile, metadata, artworkKind);
+                    });
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        public async Task ScanMusicVideos(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            Artist artist,
+            string artistFolder,
+            DateTimeOffset lastScan)
+        {
+            var folderQueue = new Queue<string>();
+            folderQueue.Enqueue(artistFolder);
+
+            while (folderQueue.Count > 0)
+            {
                 string musicVideoFolder = folderQueue.Dequeue();
-                foldersCompleted++;
+                // _logger.LogDebug("Scanning music video folder {Folder}", musicVideoFolder);
 
                 var allFiles = _localFileSystem.ListFiles(musicVideoFolder)
                     .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
-                    .Filter(f => f.Contains(" - "))
                     .ToList();
 
                 foreach (string subdirectory in _localFileSystem.ListSubdirectories(musicVideoFolder)
@@ -101,7 +256,7 @@ namespace ErsatzTV.Core.Metadata
                 {
                     // TODO: figure out how to rebuild playouts
                     Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo = await _musicVideoRepository
-                        .GetOrAdd(libraryPath, file)
+                        .GetOrAdd(artist, libraryPath, file)
                         .BindT(musicVideo => UpdateStatistics(musicVideo, ffprobePath))
                         .BindT(UpdateMetadata)
                         .BindT(UpdateThumbnail);
@@ -125,19 +280,6 @@ namespace ErsatzTV.Core.Metadata
                         });
                 }
             }
-
-            foreach (string path in await _musicVideoRepository.FindMusicVideoPaths(libraryPath))
-            {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Removing missing music video at {Path}", path);
-                    List<int> ids = await _musicVideoRepository.DeleteByPath(libraryPath, path);
-                    await _searchIndex.RemoveItems(ids);
-                }
-            }
-
-            _searchIndex.Commit();
-            return Unit.Default;
         }
 
         private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMetadata(
@@ -167,6 +309,8 @@ namespace ErsatzTV.Core.Metadata
                     {
                         if (!Optional(musicVideo.MusicVideoMetadata).Flatten().Any())
                         {
+                            musicVideo.MusicVideoMetadata ??= new List<MusicVideoMetadata>();
+
                             string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
                             _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
                             if (await _localMetadataProvider.RefreshFallbackMetadata(musicVideo))
@@ -184,6 +328,26 @@ namespace ErsatzTV.Core.Metadata
             }
         }
 
+        private Option<string> LocateNfoFileForArtist(string artistFolder) =>
+            Optional(Path.Combine(artistFolder, "artist.nfo"))
+                .Filter(s => _localFileSystem.FileExists(s));
+
+        private Option<string> LocateArtworkForArtist(string artistFolder, ArtworkKind artworkKind)
+        {
+            string segment = artworkKind switch
+            {
+                ArtworkKind.Thumbnail => "thumb",
+                ArtworkKind.FanArt => "fanart",
+                _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
+            };
+
+            return ImageFileExtensions
+                .Map(ext => $"{segment}.{ext}")
+                .Map(f => Path.Combine(artistFolder, f))
+                .Filter(s => _localFileSystem.FileExists(s))
+                .HeadOrNone();
+        }
+
         private Option<string> LocateNfoFile(MusicVideo musicVideo)
         {
             string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;

ErsatzTV.Core/Metadata/Nfo/ActorNfo.cs

@@ -0,0 +1,19 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    public class ActorNfo
+    {
+        [XmlElement("name")]
+        public string Name { get; set; }
+
+        [XmlElement("role")]
+        public string Role { get; set; }
+
+        [XmlElement("order")]
+        public int? Order { get; set; }
+
+        [XmlElement("thumb")]
+        public string Thumb { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/ArtistNfo.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    [XmlRoot("artist")]
+    public class ArtistNfo
+    {
+        [XmlElement("name")]
+        public string Name { get; set; }
+
+        [XmlElement("disambiguation")]
+        public string Disambiguation { get; set; }
+
+        [XmlElement("genre")]
+        public List<string> Genres { get; set; }
+
+        [XmlElement("style")]
+        public List<string> Styles { get; set; }
+
+        [XmlElement("mood")]
+        public List<string> Moods { get; set; }
+
+        [XmlElement("biography")]
+        public string Biography { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs

@@ -36,5 +36,8 @@ namespace ErsatzTV.Core.Metadata.Nfo
 
         [XmlElement("studio")]
         public List<string> Studios { get; set; }
+
+        [XmlElement("actor")]
+        public List<ActorNfo> Actors { get; set; }
     }
 }

ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs

@@ -1,4 +1,5 @@
-using System.Xml.Serialization;
+using System.Collections.Generic;
+using System.Xml.Serialization;
 
 namespace ErsatzTV.Core.Metadata.Nfo
 {
@@ -25,5 +26,8 @@ namespace ErsatzTV.Core.Metadata.Nfo
 
         [XmlElement("plot")]
         public string Plot { get; set; }
+
+        [XmlElement("actor")]
+        public List<ActorNfo> Actors { get; set; }
     }
 }

ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs

@@ -32,5 +32,8 @@ namespace ErsatzTV.Core.Metadata.Nfo
 
         [XmlElement("studio")]
         public List<string> Studios { get; set; }
+
+        [XmlElement("actor")]
+        public List<ActorNfo> Actors { get; set; }
     }
 }

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -87,6 +87,14 @@ namespace ErsatzTV.Core.Metadata
                 await maybeShow.Match(
                     async result =>
                     {
+                        await ScanSeasons(
+                            libraryPath,
+                            ffprobePath,
+                            result.Item,
+                            showFolder,
+                            // force scanning all folders if we're adding a new show
+                            result.IsAdded ? DateTimeOffset.MinValue : lastScan);
+
                         if (result.IsAdded)
                         {
                             await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
@@ -95,14 +103,6 @@ namespace ErsatzTV.Core.Metadata
                         {
                             await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
                         }
-
-                        await ScanSeasons(
-                            libraryPath,
-                            ffprobePath,
-                            result.Item,
-                            showFolder,
-                            // force scanning all folders if we're adding a new show
-                            result.IsAdded ? DateTimeOffset.MinValue : lastScan);
                     },
                     error =>
                     {
@@ -401,10 +401,6 @@ namespace ErsatzTV.Core.Metadata
                 .HeadOrNone();
         }
 
-        private bool ShouldIncludeFolder(string folder) =>
-            !Path.GetFileName(folder).StartsWith('.') &&
-            !_localFileSystem.FileExists(Path.Combine(folder, ".etvignore"));
-
         private static Option<int> SeasonNumberForFolder(string folder)
         {
             if (int.TryParse(folder.Split(" ").Last(), out int seasonNumber))

ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs

@@ -45,10 +45,10 @@ namespace ErsatzTV.Core.Plex
         public async Task<Either<BaseError, Unit>> ScanLibrary(
             PlexConnection connection,
             PlexServerAuthToken token,
-            PlexLibrary plexMediaSourceLibrary)
+            PlexLibrary library)
         {
             Either<BaseError, List<PlexMovie>> entries = await _plexServerApiClient.GetMovieLibraryContents(
-                plexMediaSourceLibrary,
+                library,
                 connection,
                 token);
 
@@ -58,13 +58,13 @@ namespace ErsatzTV.Core.Plex
                     foreach (PlexMovie incoming in movieEntries)
                     {
                         decimal percentCompletion = (decimal) movieEntries.IndexOf(incoming) / movieEntries.Count;
-                        await _mediator.Publish(new LibraryScanProgress(plexMediaSourceLibrary.Id, percentCompletion));
+                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
                         // TODO: figure out how to rebuild playlists
                         Either<BaseError, MediaItemScanResult<PlexMovie>> maybeMovie = await _movieRepository
-                            .GetOrAdd(plexMediaSourceLibrary, incoming)
+                            .GetOrAdd(library, incoming)
                             .BindT(existing => UpdateStatistics(existing, incoming, connection, token))
-                            .BindT(existing => UpdateMetadata(existing, incoming))
+                            .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
                             .BindT(existing => UpdateArtwork(existing, incoming));
 
                         await maybeMovie.Match(
@@ -92,16 +92,16 @@ namespace ErsatzTV.Core.Plex
                     }
 
                     var movieKeys = movieEntries.Map(s => s.Key).ToList();
-                    List<int> ids = await _movieRepository.RemoveMissingPlexMovies(plexMediaSourceLibrary, movieKeys);
+                    List<int> ids = await _movieRepository.RemoveMissingPlexMovies(library, movieKeys);
                     await _searchIndex.RemoveItems(ids);
 
-                    await _mediator.Publish(new LibraryScanProgress(plexMediaSourceLibrary.Id, 0));
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
                 },
                 error =>
                 {
                     _logger.LogWarning(
                         "Error synchronizing plex library {Path}: {Error}",
-                        plexMediaSourceLibrary.Name,
+                        library.Name,
                         error.Value);
 
                     return Task.CompletedTask;
@@ -148,73 +148,112 @@ namespace ErsatzTV.Core.Plex
 
         private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateMetadata(
             MediaItemScanResult<PlexMovie> result,
-            PlexMovie incoming)
+            PlexMovie incoming,
+            PlexLibrary library,
+            PlexConnection connection,
+            PlexServerAuthToken token)
         {
             PlexMovie existing = result.Item;
             MovieMetadata existingMetadata = existing.MovieMetadata.Head();
-            MovieMetadata incomingMetadata = incoming.MovieMetadata.Head();
 
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+            if (incoming.MovieMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
             {
                 _logger.LogDebug(
                     "Refreshing {Attribute} from {Path}",
                     "Plex Metadata",
                     existing.MediaVersions.Head().MediaFiles.Head().Path);
 
-                foreach (Genre genre in existingMetadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    existingMetadata.Genres.Remove(genre);
-                    if (await _metadataRepository.RemoveGenre(genre))
-                    {
-                        result.IsUpdated = true;
-                    }
-                }
+                Either<BaseError, MovieMetadata> maybeMetadata =
+                    await _plexServerApiClient.GetMovieMetadata(
+                        library,
+                        incoming.Key.Split("/").Last(),
+                        connection,
+                        token);
 
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    existingMetadata.Genres.Add(genre);
-                    if (await _movieRepository.AddGenre(existingMetadata, genre))
+                await maybeMetadata.Match(
+                    async fullMetadata =>
                     {
-                        result.IsUpdated = true;
-                    }
-                }
+                        foreach (Genre genre in existingMetadata.Genres
+                            .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Genres.Remove(genre);
+                            if (await _metadataRepository.RemoveGenre(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 (Genre genre in fullMetadata.Genres
+                            .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Genres.Add(genre);
+                            if (await _movieRepository.AddGenre(existingMetadata, genre))
+                            {
+                                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;
-                    }
-                }
+                        foreach (Studio studio in existingMetadata.Studios
+                            .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Studios.Remove(studio);
+                            if (await _metadataRepository.RemoveStudio(studio))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
 
-                if (incomingMetadata.SortTitle != existingMetadata.SortTitle)
-                {
-                    existingMetadata.SortTitle = incomingMetadata.SortTitle;
-                    if (await _movieRepository.UpdateSortTitle(existingMetadata))
-                    {
-                        result.IsUpdated = true;
-                    }
-                }
+                        foreach (Studio studio in fullMetadata.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;
+                            }
+                        }
 
-                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+                        foreach (Actor actor in existingMetadata.Actors
+                            .Filter(a => fullMetadata.Actors.All(a2 => a2.Name != a.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Actors.Remove(actor);
+                            if (await _metadataRepository.RemoveActor(actor))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        foreach (Actor actor in fullMetadata.Actors
+                            .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Actors.Add(actor);
+                            if (await _movieRepository.AddActor(existingMetadata, actor))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        if (fullMetadata.SortTitle != existingMetadata.SortTitle)
+                        {
+                            existingMetadata.SortTitle = fullMetadata.SortTitle;
+                            if (await _movieRepository.UpdateSortTitle(existingMetadata))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        if (result.IsUpdated)
+                        {
+                            await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
+                        }
+                    },
+                    _ => Task.CompletedTask);
 
                 // TODO: update other metadata?
             }

ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs

@@ -46,10 +46,10 @@ namespace ErsatzTV.Core.Plex
         public async Task<Either<BaseError, Unit>> ScanLibrary(
             PlexConnection connection,
             PlexServerAuthToken token,
-            PlexLibrary plexMediaSourceLibrary)
+            PlexLibrary library)
         {
             Either<BaseError, List<PlexShow>> entries = await _plexServerApiClient.GetShowLibraryContents(
-                plexMediaSourceLibrary,
+                library,
                 connection,
                 token);
 
@@ -59,17 +59,19 @@ namespace ErsatzTV.Core.Plex
                     foreach (PlexShow incoming in showEntries)
                     {
                         decimal percentCompletion = (decimal) showEntries.IndexOf(incoming) / showEntries.Count;
-                        await _mediator.Publish(new LibraryScanProgress(plexMediaSourceLibrary.Id, percentCompletion));
+                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
                         // TODO: figure out how to rebuild playlists
                         Either<BaseError, MediaItemScanResult<PlexShow>> maybeShow = await _televisionRepository
-                            .GetOrAddPlexShow(plexMediaSourceLibrary, incoming)
-                            .BindT(existing => UpdateMetadata(existing, incoming))
+                            .GetOrAddPlexShow(library, incoming)
+                            .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
                             .BindT(existing => UpdateArtwork(existing, incoming));
 
                         await maybeShow.Match(
                             async result =>
                             {
+                                await ScanSeasons(library, result.Item, connection, token);
+
                                 if (result.IsAdded)
                                 {
                                     await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
@@ -80,8 +82,6 @@ namespace ErsatzTV.Core.Plex
                                         _searchRepository,
                                         new List<MediaItem> { result.Item });
                                 }
-
-                                await ScanSeasons(plexMediaSourceLibrary, result.Item, connection, token);
                             },
                             error =>
                             {
@@ -95,10 +95,10 @@ namespace ErsatzTV.Core.Plex
 
                     var showKeys = showEntries.Map(s => s.Key).ToList();
                     List<int> ids =
-                        await _televisionRepository.RemoveMissingPlexShows(plexMediaSourceLibrary, showKeys);
+                        await _televisionRepository.RemoveMissingPlexShows(library, showKeys);
                     await _searchIndex.RemoveItems(ids);
 
-                    await _mediator.Publish(new LibraryScanProgress(plexMediaSourceLibrary.Id, 0));
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
 
                     _searchIndex.Commit();
                     return Unit.Default;
@@ -107,7 +107,7 @@ namespace ErsatzTV.Core.Plex
                 {
                     _logger.LogWarning(
                         "Error synchronizing plex library {Path}: {Error}",
-                        plexMediaSourceLibrary.Name,
+                        library.Name,
                         error.Value);
 
                     return Left<BaseError, Unit>(error).AsTask();
@@ -116,61 +116,98 @@ namespace ErsatzTV.Core.Plex
 
         private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateMetadata(
             MediaItemScanResult<PlexShow> result,
-            PlexShow incoming)
+            PlexShow incoming,
+            PlexLibrary library,
+            PlexConnection connection,
+            PlexServerAuthToken token)
         {
             PlexShow existing = result.Item;
             ShowMetadata existingMetadata = existing.ShowMetadata.Head();
-            ShowMetadata incomingMetadata = incoming.ShowMetadata.Head();
 
-            // TODO: this probably doesn't work
-            // plex doesn't seem to update genres returned by the main library call
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+            if (incoming.ShowMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
             {
-                foreach (Genre genre in existingMetadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    existingMetadata.Genres.Remove(genre);
-                    if (await _metadataRepository.RemoveGenre(genre))
-                    {
-                        result.IsUpdated = true;
-                    }
-                }
+                Either<BaseError, ShowMetadata> maybeMetadata =
+                    await _plexServerApiClient.GetShowMetadata(
+                        library,
+                        incoming.Key.Replace("/children", string.Empty).Split("/").Last(),
+                        connection,
+                        token);
 
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    existingMetadata.Genres.Add(genre);
-                    if (await _televisionRepository.AddGenre(existingMetadata, genre))
+                await maybeMetadata.Match(
+                    async fullMetadata =>
                     {
-                        result.IsUpdated = true;
-                    }
-                }
+                        foreach (Genre genre in existingMetadata.Genres
+                            .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Genres.Remove(genre);
+                            if (await _metadataRepository.RemoveGenre(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 (Genre genre in fullMetadata.Genres
+                            .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Genres.Add(genre);
+                            if (await _televisionRepository.AddGenre(existingMetadata, genre))
+                            {
+                                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;
-                    }
-                }
+                        foreach (Studio studio in existingMetadata.Studios
+                            .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Studios.Remove(studio);
+                            if (await _metadataRepository.RemoveStudio(studio))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
 
-                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+                        foreach (Studio studio in fullMetadata.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;
+                            }
+                        }
+
+                        foreach (Actor actor in existingMetadata.Actors
+                            .Filter(a => fullMetadata.Actors.All(a2 => a2.Name != a.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Actors.Remove(actor);
+                            if (await _metadataRepository.RemoveActor(actor))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        foreach (Actor actor in fullMetadata.Actors
+                            .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
+                            .ToList())
+                        {
+                            existingMetadata.Actors.Add(actor);
+                            if (await _televisionRepository.AddActor(existingMetadata, actor))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        if (result.IsUpdated)
+                        {
+                            await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
+                        }
+                    },
+                    _ => Task.CompletedTask);
             }
 
             return result;
@@ -345,6 +382,7 @@ namespace ErsatzTV.Core.Plex
             if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
             {
                 await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Thumbnail);
+                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
             }
 
             return existing;

ErsatzTV.Core/Scheduling/PlayoutBuilder.cs

@@ -475,20 +475,28 @@ namespace ErsatzTV.Core.Scheduling
             }
         }
 
-        private static string DisplayTitle(MediaItem mediaItem) =>
-            mediaItem switch
+        private static string DisplayTitle(MediaItem mediaItem)
+        {
+            switch (mediaItem)
             {
-                Episode e => e.EpisodeMetadata.Any() && e.Season != null
-                    ? $"{e.EpisodeMetadata.Head().Title} - s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00}"
-                    : "[unknown episode]",
-                Movie m => m.MovieMetadata.HeadOrNone().Match(
-                    mm => mm.Title ?? string.Empty,
-                    () => "[unknown movie]"),
-                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
-                    mvm => $"{mvm.Artist} - {mvm.Title}",
-                    () => "[unknown music video]"),
-                _ => string.Empty
-            };
+                case Episode e:
+                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                    return e.EpisodeMetadata.HeadOrNone()
+                        .Map(em => $"{showTitle}s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00} - {em.Title}")
+                        .IfNone("[unknown episode]");
+                case Movie m:
+                    return m.MovieMetadata.HeadOrNone().Match(mm => mm.Title ?? string.Empty, () => "[unknown movie]");
+                case MusicVideo mv:
+                    string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
+                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
+                    return mv.MusicVideoMetadata.HeadOrNone()
+                        .Map(mvm => $"{artistName}{mvm.Title}")
+                        .IfNone("[unknown music video]");
+                default:
+                    return string.Empty;
+            }
+        }
 
         private static CollectionKey CollectionKeyForItem(ProgramScheduleItem item) =>
             item.CollectionType switch

ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ArtistConfiguration.cs

@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations
+{
+    public class ArtistConfiguration : IEntityTypeConfiguration<Artist>
+    {
+        public void Configure(EntityTypeBuilder<Artist> builder)
+        {
+            builder.ToTable("Artist");
+
+            builder.HasMany(a => a.MusicVideos)
+                .WithOne(mv => mv.Artist)
+                .HasForeignKey(mv => mv.ArtistId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(a => a.ArtistMetadata)
+                .WithOne(am => am.Artist)
+                .HasForeignKey(am => am.ArtistId)
+                .OnDelete(DeleteBehavior.Cascade);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/Configurations/Metadata/ActorConfiguration.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations
+{
+    public class ActorConfiguration : IEntityTypeConfiguration<Actor>
+    {
+        public void Configure(EntityTypeBuilder<Actor> builder)
+        {
+            builder.ToTable("Actor");
+
+            builder.HasOne(a => a.Artwork)
+                .WithOne()
+                .HasForeignKey<Actor>(a => a.ArtworkId)
+                .OnDelete(DeleteBehavior.Cascade);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtistMetadataConfiguration.cs

@@ -0,0 +1,30 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations
+{
+    public class ArtistMetadataConfiguration : IEntityTypeConfiguration<ArtistMetadata>
+    {
+        public void Configure(EntityTypeBuilder<ArtistMetadata> builder)
+        {
+            builder.ToTable("ArtistMetadata");
+
+            builder.HasMany(sm => sm.Artwork)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(sm => sm.Genres)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(sm => sm.Styles)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(sm => sm.Moods)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/Configurations/Metadata/EpisodeMetadataConfiguration.cs

@@ -13,6 +13,10 @@ namespace ErsatzTV.Infrastructure.Data.Configurations
             builder.HasMany(em => em.Artwork)
                 .WithOne()
                 .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(em => em.Actors)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
         }
     }
 }

ErsatzTV.Infrastructure/Data/Configurations/Metadata/MovieMetadataConfiguration.cs

@@ -25,6 +25,10 @@ namespace ErsatzTV.Infrastructure.Data.Configurations
             builder.HasMany(mm => mm.Studios)
                 .WithOne()
                 .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(mm => mm.Actors)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
         }
     }
 }

ErsatzTV.Infrastructure/Data/Configurations/Metadata/ShowMetadataConfiguration.cs

@@ -25,6 +25,10 @@ namespace ErsatzTV.Infrastructure.Data.Configurations
             builder.HasMany(sm => sm.Studios)
                 .WithOne()
                 .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(sm => sm.Actors)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
         }
     }
 }

ErsatzTV.Infrastructure/Data/Repositories/ArtistRepository.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Infrastructure.Data.Repositories
+{
+    public class ArtistRepository : IArtistRepository
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public ArtistRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Option<int> maybeId = await dbContext.ArtistMetadata
+                .Where(
+                    s => s.Title == metadata.Title && (metadata.MetadataKind == MetadataKind.Fallback ||
+                                                       s.Disambiguation == metadata.Disambiguation))
+                .Where(s => s.Artist.LibraryPathId == libraryPathId)
+                .SingleOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.ArtistId);
+
+            return await maybeId.Match(
+                id =>
+                {
+                    return dbContext.Artists
+                        .AsNoTracking()
+                        .Include(s => s.ArtistMetadata)
+                        .ThenInclude(sm => sm.Artwork)
+                        .Include(s => s.ArtistMetadata)
+                        .ThenInclude(sm => sm.Genres)
+                        .Include(s => s.ArtistMetadata)
+                        .ThenInclude(sm => sm.Styles)
+                        .Include(s => s.ArtistMetadata)
+                        .ThenInclude(sm => sm.Moods)
+                        .Include(s => s.LibraryPath)
+                        .ThenInclude(lp => lp.Library)
+                        .OrderBy(s => s.Id)
+                        .SingleOrDefaultAsync(s => s.Id == id)
+                        .Map(Optional);
+                },
+                () => Option<Artist>.None.AsTask());
+        }
+
+        public async Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
+            int libraryPathId,
+            string artistFolder,
+            ArtistMetadata metadata)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            try
+            {
+                metadata.DateAdded = DateTime.UtcNow;
+                metadata.Genres ??= new List<Genre>();
+                metadata.Styles ??= new List<Style>();
+                metadata.Moods ??= new List<Mood>();
+                var artist = new Artist
+                {
+                    LibraryPathId = libraryPathId,
+                    ArtistMetadata = new List<ArtistMetadata> { metadata }
+                };
+
+                await dbContext.Artists.AddAsync(artist);
+                await dbContext.SaveChangesAsync();
+                await dbContext.Entry(artist).Reference(s => s.LibraryPath).LoadAsync();
+                await dbContext.Entry(artist.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+
+                return new MediaItemScanResult<Artist>(artist) { IsAdded = true };
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.Message);
+            }
+        }
+
+        public async Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<Artist> artists = await dbContext.Artists
+                .Filter(a => a.LibraryPathId == libraryPath.Id)
+                .Filter(a => a.MusicVideos.Count == 0)
+                .ToListAsync();
+            var ids = artists.Map(a => a.Id).ToList();
+            dbContext.Artists.RemoveRange(artists);
+            await dbContext.SaveChangesAsync();
+            return ids;
+        }
+
+        public async Task<Option<Artist>> GetArtist(int artistId)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.Artists
+                .Include(m => m.ArtistMetadata)
+                .ThenInclude(m => m.Artwork)
+                .Include(m => m.ArtistMetadata)
+                .ThenInclude(m => m.Genres)
+                .Include(m => m.ArtistMetadata)
+                .ThenInclude(m => m.Styles)
+                .Include(m => m.ArtistMetadata)
+                .ThenInclude(m => m.Moods)
+                .OrderBy(m => m.Id)
+                .SingleOrDefaultAsync(m => m.Id == artistId)
+                .Map(Optional);
+        }
+
+        public async Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.ArtistMetadata
+                .AsNoTracking()
+                .Filter(am => ids.Contains(am.ArtistId))
+                .Include(am => am.Artwork)
+                .OrderBy(am => am.SortTitle)
+                .ToListAsync();
+        }
+
+        public Task<bool> AddGenre(ArtistMetadata metadata, Genre genre) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Genre (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+        public Task<bool> AddStyle(ArtistMetadata metadata, Style style) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Style (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+                new { style.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+        public Task<bool> AddMood(ArtistMetadata metadata, Mood mood) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Mood (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+                new { mood.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+    }
+}

ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Threading.Tasks;
+using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
@@ -11,9 +13,14 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
 {
     public class ChannelRepository : IChannelRepository
     {
+        private readonly IDbConnection _dbConnection;
         private readonly TvContext _dbContext;
 
-        public ChannelRepository(TvContext dbContext) => _dbContext = dbContext;
+        public ChannelRepository(TvContext dbContext, IDbConnection dbConnection)
+        {
+            _dbContext = dbContext;
+            _dbConnection = dbConnection;
+        }
 
         public async Task<Channel> Add(Channel channel)
         {
@@ -67,6 +74,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(i => i.MediaItem)
                 .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
                 .ThenInclude(mm => mm.Artwork)
+                .Include(c => c.Playouts)
+                .ThenInclude(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).Artist)
+                .ThenInclude(a => a.ArtistMetadata)
                 .ToListAsync();
 
         public Task Update(Channel channel)
@@ -81,5 +93,10 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             _dbContext.Channels.Remove(channel);
             await _dbContext.SaveChangesAsync();
         }
+
+        public Task<int> CountPlayouts(int channelId) =>
+            _dbConnection.QuerySingleAsync<int>(
+                @"SELECT COUNT(*) FROM Playout WHERE ChannelId = @ChannelId",
+                new { ChannelId = channelId });
     }
 }

ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs

@@ -15,10 +15,15 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
     {
         private readonly IDbConnection _dbConnection;
         private readonly TvContext _dbContext;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-        public MediaCollectionRepository(TvContext dbContext, IDbConnection dbConnection)
+        public MediaCollectionRepository(
+            TvContext dbContext,
+            IDbContextFactory<TvContext> dbContextFactory,
+            IDbConnection dbConnection)
         {
             _dbContext = dbContext;
+            _dbContextFactory = dbContextFactory;
             _dbConnection = dbConnection;
         }
 
@@ -29,7 +34,6 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             return collection;
         }
 
-
         public async Task<bool> AddMediaItem(int collectionId, int mediaItemId)
         {
             var modified = false;
@@ -130,9 +134,15 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)
                 .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as Artist).ArtistMetadata)
+                .ThenInclude(mvm => mvm.Artwork)
+                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
                 .ThenInclude(mvm => mvm.Artwork)
                 .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as MusicVideo).Artist)
+                .ThenInclude(a => a.ArtistMetadata)
+                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Show).ShowMetadata)
                 .ThenInclude(sm => sm.Artwork)
                 .Include(c => c.MediaItems)
@@ -162,6 +172,22 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         public Task<List<Collection>> GetAll() =>
             _dbContext.Collections.ToListAsync();
 
+        public Task<int> CountAllCollections() =>
+            _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM Collection");
+
+        public async Task<List<Collection>> GetPagedCollections(int pageNumber, int pageSize)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.Collections.FromSqlRaw(
+                    @"SELECT * FROM Collection
+                    ORDER BY Name
+                    LIMIT {0} OFFSET {1}",
+                    pageSize,
+                    pageNumber * pageSize)
+                .AsNoTracking()
+                .ToListAsync();
+        }
+
         public Task<Option<List<MediaItem>>> GetItems(int id) =>
             Get(id).MapT(GetItemsForCollection).Bind(x => x.Sequence());
 
@@ -201,6 +227,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             result.AddRange(await GetShowItems(collection));
             result.AddRange(await GetSeasonItems(collection));
             result.AddRange(await GetEpisodeItems(collection));
+            result.AddRange(await GetArtistItems(collection));
             result.AddRange(await GetMusicVideoItems(collection));
 
             return result.Distinct().ToList();
@@ -221,6 +248,25 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ToListAsync();
         }
 
+        private async Task<List<MusicVideo>> GetArtistItems(Collection collection)
+        {
+            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT MusicVideo.Id FROM CollectionItem ci
+            INNER JOIN Artist on Artist.Id = ci.MediaItemId
+            INNER JOIN MusicVideo on Artist.Id = MusicVideo.ArtistId
+            WHERE ci.CollectionId = @CollectionId",
+                new { CollectionId = collection.Id });
+
+            return await _dbContext.MusicVideos
+                .Include(m => m.Artist)
+                .ThenInclude(a => a.ArtistMetadata)
+                .Include(m => m.MusicVideoMetadata)
+                .Include(m => m.MediaVersions)
+                .Filter(m => ids.Contains(m.Id))
+                .ToListAsync();
+        }
+
+
         private async Task<List<MusicVideo>> GetMusicVideoItems(Collection collection)
         {
             IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
@@ -230,6 +276,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 new { CollectionId = collection.Id });
 
             return await _dbContext.MusicVideos
+                .Include(m => m.Artist)
+                .ThenInclude(a => a.ArtistMetadata)
                 .Include(m => m.MusicVideoMetadata)
                 .Include(m => m.MediaVersions)
                 .Filter(m => ids.Contains(m.Id))
@@ -250,6 +298,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(e => e.EpisodeMetadata)
                 .Include(e => e.MediaVersions)
                 .Include(e => e.Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
                 .Filter(e => ids.Contains(e.Id))
                 .ToListAsync();
         }
@@ -267,6 +317,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(e => e.EpisodeMetadata)
                 .Include(e => e.MediaVersions)
                 .Include(e => e.Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
                 .Filter(e => ids.Contains(e.Id))
                 .ToListAsync();
         }
@@ -283,6 +335,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(e => e.EpisodeMetadata)
                 .Include(e => e.MediaVersions)
                 .Include(e => e.Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
                 .Filter(e => ids.Contains(e.Id))
                 .ToListAsync();
         }

ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs

@@ -155,6 +155,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
 
         public async Task Update(
             PlexMediaSource plexMediaSource,
+            List<PlexConnection> sortedConnections,
             List<PlexConnection> toAdd,
             List<PlexConnection> toDelete)
         {
@@ -174,27 +175,34 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                     plexMediaSource.Id
                 });
 
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
             foreach (PlexConnection add in toAdd)
             {
-                add.PlexMediaSourceId = plexMediaSource.Id;
-                dbContext.Entry(add).State = EntityState.Added;
+                await _dbConnection.ExecuteAsync(
+                    @"INSERT INTO PlexConnection (IsActive, Uri, PlexMediaSourceId)
+                    VALUES (0, @Uri, @PlexMediaSourceId)",
+                    new { add.Uri, PlexMediaSourceId = plexMediaSource.Id });
             }
 
             foreach (PlexConnection delete in toDelete)
             {
-                dbContext.Entry(delete).State = EntityState.Deleted;
+                await _dbConnection.ExecuteAsync(
+                    @"DELETE FROM PlexConnection WHERE Id = @Id",
+                    new { delete.Id });
             }
 
-            await dbContext.SaveChangesAsync();
-
-            PlexMediaSource pms = await dbContext.PlexMediaSources.FindAsync(plexMediaSource.Id);
-            await dbContext.Entry(pms).Collection(x => x.Connections).LoadAsync();
-            if (plexMediaSource.Connections.Any() && plexMediaSource.Connections.All(c => !c.IsActive))
+            int activeCount = await _dbConnection.QuerySingleAsync<int>(
+                @"SELECT COUNT(*) FROM PlexConnection WHERE IsActive = 1 AND PlexMediaSourceId = @PlexMediaSourceId",
+                new { PlexMediaSourceId = plexMediaSource.Id });
+            if (activeCount == 0)
             {
-                plexMediaSource.Connections.Head().IsActive = true;
-                await dbContext.SaveChangesAsync();
+                Option<PlexConnection> toActivate =
+                    sortedConnections.FirstOrDefault(c => toDelete.All(d => d.Id != c.Id));
+
+                // update on uri because connections from Plex API don't have our local ids
+                await toActivate.IfSomeAsync(
+                    async c => await _dbConnection.ExecuteAsync(
+                        @"UPDATE PlexConnection SET IsActive = 1 WHERE Uri = @Uri",
+                        new { c.Uri }));
             }
         }
 
@@ -292,6 +300,23 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             return movieIds.Append(showIds).ToList();
         }
 
+        public async Task<List<int>> DeletePlex(PlexMediaSource plexMediaSource)
+        {
+            List<int> mediaItemIds = await _dbConnection.QueryAsync<int>(
+                    @"SELECT MediaItem.Id FROM MediaItem
+                  INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                  INNER JOIN Library L on LP.LibraryId = L.Id
+                  WHERE L.MediaSourceId = @PlexMediaSourceId",
+                    new { PlexMediaSourceId = plexMediaSource.Id })
+                .Map(result => result.ToList());
+
+            await _dbConnection.ExecuteAsync(
+                @"DELETE FROM MediaSource WHERE Id = @PlexMediaSourceId",
+                new { PlexMediaSourceId = plexMediaSource.Id });
+
+            return mediaItemIds;
+        }
+
         public async Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds)
         {
             await _dbConnection.ExecuteAsync(

ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs

@@ -22,6 +22,10 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             _dbConnection = dbConnection;
         }
 
+        public Task<bool> RemoveActor(Actor actor) =>
+            _dbConnection.ExecuteAsync("DELETE FROM Actor WHERE Id = @ActorId", new { ActorId = actor.Id })
+                .Map(result => result > 0);
+
         public async Task<bool> Update(Metadata metadata)
         {
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
@@ -33,16 +37,44 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         {
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             dbContext.Entry(metadata).State = EntityState.Added;
-            foreach (Genre genre in metadata.Genres)
+
+            foreach (Genre genre in Optional(metadata.Genres).Flatten())
             {
                 dbContext.Entry(genre).State = EntityState.Added;
             }
 
-            foreach (Tag tag in metadata.Tags)
+            foreach (Tag tag in Optional(metadata.Tags).Flatten())
             {
                 dbContext.Entry(tag).State = EntityState.Added;
             }
 
+            foreach (Studio studio in Optional(metadata.Studios).Flatten())
+            {
+                dbContext.Entry(studio).State = EntityState.Added;
+            }
+
+            if (metadata is ArtistMetadata artistMetadata)
+            {
+                foreach (Style style in Optional(artistMetadata.Styles).Flatten())
+                {
+                    dbContext.Entry(style).State = EntityState.Added;
+                }
+
+                foreach (Mood mood in Optional(artistMetadata.Moods).Flatten())
+                {
+                    dbContext.Entry(mood).State = EntityState.Added;
+                }
+            }
+
+            foreach (Actor actor in Optional(metadata.Actors).Flatten())
+            {
+                dbContext.Entry(actor).State = EntityState.Added;
+                if (actor.Artwork != null)
+                {
+                    dbContext.Entry(actor.Artwork).State = EntityState.Added;
+                }
+            }
+
             return await dbContext.SaveChangesAsync() > 0;
         }
 
@@ -156,6 +188,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                             VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path)",
                         parameters)
                     .ToUnit(),
+                ArtistMetadata => _dbConnection.ExecuteAsync(
+                        @"INSERT INTO Artwork (ArtworkKind, ArtistMetadataId, DateAdded, DateUpdated, Path)
+                            Values (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path)",
+                        parameters)
+                    .ToUnit(),
                 MusicVideoMetadata => _dbConnection.ExecuteAsync(
                         @"INSERT INTO Artwork (ArtworkKind, MusicVideoMetadataId, DateAdded, DateUpdated, Path)
                             VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path)",
@@ -185,6 +222,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             _dbConnection.ExecuteAsync(
                 @"UPDATE MovieMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
                 new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
+        
+        public Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated) =>
+            _dbConnection.ExecuteAsync(
+                @"UPDATE EpisodeMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
+                new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
 
         public Task<bool> RemoveGenre(Genre genre) =>
             _dbConnection.ExecuteAsync("DELETE FROM Genre WHERE Id = @GenreId", new { GenreId = genre.Id })
@@ -197,5 +239,13 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         public Task<bool> RemoveStudio(Studio studio) =>
             _dbConnection.ExecuteAsync("DELETE FROM Studio WHERE Id = @StudioId", new { StudioId = studio.Id })
                 .Map(result => result > 0);
+
+        public Task<bool> RemoveStyle(Style style) =>
+            _dbConnection.ExecuteAsync("DELETE FROM Style WHERE Id = @StyleId", new { StyleId = style.Id })
+                .Map(result => result > 0);
+
+        public Task<bool> RemoveMood(Mood mood) =>
+            _dbConnection.ExecuteAsync("DELETE FROM Mood WHERE Id = @MoodId", new { MoodId = mood.Id })
+                .Map(result => result > 0);
     }
 }

ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs

@@ -43,6 +43,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(m => m.Tags)
                 .Include(m => m.MovieMetadata)
                 .ThenInclude(m => m.Studios)
+                .Include(m => m.MovieMetadata)
+                .ThenInclude(m => m.Actors)
+                .ThenInclude(a => a.Artwork)
+                .Include(m => m.MediaVersions)
+                .ThenInclude(mv => mv.Streams)
                 .OrderBy(m => m.Id)
                 .SingleOrDefaultAsync(m => m.Id == movieId)
                 .Map(Optional);
@@ -60,6 +65,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(mm => mm.Tags)
                 .Include(i => i.MovieMetadata)
                 .ThenInclude(mm => mm.Studios)
+                .Include(i => i.MovieMetadata)
+                .ThenInclude(mm => mm.Actors)
                 .Include(i => i.LibraryPath)
                 .ThenInclude(lp => lp.Library)
                 .Include(i => i.MediaVersions)
@@ -90,6 +97,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(i => i.MovieMetadata)
                 .ThenInclude(mm => mm.Studios)
                 .Include(i => i.MovieMetadata)
+                .ThenInclude(mm => mm.Actors)
+                .Include(i => i.MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)
                 .Include(i => i.MediaVersions)
                 .ThenInclude(mv => mv.MediaFiles)
@@ -185,6 +194,31 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 "INSERT INTO Studio (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
                 new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
 
+        public async Task<bool> AddActor(MovieMetadata metadata, Actor actor)
+        {
+            int? artworkId = null;
+
+            if (actor.Artwork != null)
+            {
+                artworkId = await _dbConnection.QuerySingleAsync<int>(
+                    @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
+                      VALUES (@ArtworkKind, @DateAdded, @DateUpdated, @Path);
+                      SELECT last_insert_rowid()",
+                    new
+                    {
+                        ArtworkKind = (int) actor.Artwork.ArtworkKind,
+                        actor.Artwork.DateAdded,
+                        actor.Artwork.DateUpdated,
+                        actor.Artwork.Path
+                    });
+            }
+
+            return await _dbConnection.ExecuteAsync(
+                    "INSERT INTO Actor (Name, Role, \"Order\", MovieMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
+                    new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
+                .Map(result => result > 0);
+        }
+
         public async Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys)
         {
             List<int> ids = await _dbConnection.QueryAsync<int>(

ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs

@@ -26,6 +26,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         }
 
         public async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
+            Artist artist,
             LibraryPath libraryPath,
             string path)
         {
@@ -50,10 +51,22 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
 
             return await maybeExisting.Match(
-                mediaItem =>
-                    Right<BaseError, MediaItemScanResult<MusicVideo>>(
-                        new MediaItemScanResult<MusicVideo>(mediaItem) { IsAdded = false }).AsTask(),
-                async () => await AddMusicVideo(dbContext, libraryPath.Id, path));
+                async mediaItem =>
+                {
+                    if (mediaItem.ArtistId != artist.Id)
+                    {
+                        await _dbConnection.ExecuteAsync(
+                            @"UPDATE MusicVideo SET ArtistId = @ArtistId WHERE Id = @Id",
+                            new { mediaItem.Id, ArtistId = artist.Id });
+
+                        mediaItem.ArtistId = artist.Id;
+                        mediaItem.Artist = artist;
+                    }
+
+                    return Right<BaseError, MediaItemScanResult<MusicVideo>>(
+                        new MediaItemScanResult<MusicVideo>(mediaItem) { IsAdded = false });
+                },
+                async () => await AddMusicVideo(dbContext, artist, libraryPath.Id, path));
         }
 
         public Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath) =>
@@ -72,7 +85,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 @"SELECT M.Id
                 FROM MusicVideo M
                 INNER JOIN MediaItem MI on M.Id = MI.Id
-                INNER JOIN MediaVersion MV on M.Id = MV.EpisodeId
+                INNER JOIN MediaVersion MV on M.Id = MV.MusicVideoId
                 INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
                 WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
                 new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
@@ -110,6 +123,9 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             return await dbContext.MusicVideoMetadata
                 .AsNoTracking()
                 .Filter(mvm => ids.Contains(mvm.MusicVideoId))
+                .Include(mvm => mvm.MusicVideo)
+                .ThenInclude(mv => mv.Artist)
+                .ThenInclude(a => a.ArtistMetadata)
                 .Include(mvm => mvm.Artwork)
                 .OrderBy(mvm => mvm.SortTitle)
                 .ToListAsync();
@@ -132,8 +148,44 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Map(Optional);
         }
 
+        public Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath) =>
+            _dbConnection.QueryAsync<string>(
+                @"SELECT MF.Path
+                FROM MediaFile MF
+                INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
+                INNER JOIN MusicVideo M on MV.MusicVideoId = M.Id
+                INNER JOIN MediaItem MI on M.Id = MI.Id
+                WHERE MI.LibraryPathId = @LibraryPathId
+                  AND NOT EXISTS (SELECT * FROM MusicVideoMetadata WHERE MusicVideoId = M.Id)",
+                new { LibraryPathId = libraryPath.Id });
+
+        public Task<int> GetMusicVideoCount(int artistId) =>
+            _dbConnection.QuerySingleAsync<int>(
+                @"SELECT COUNT(*) FROM MusicVideo WHERE ArtistId = @ArtistId",
+                new { ArtistId = artistId });
+
+        public async Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.MusicVideoMetadata
+                .AsNoTracking()
+                .Include(m => m.Artwork)
+                .Include(m => m.Genres)
+                .Include(m => m.Tags)
+                .Include(m => m.Studios)
+                .Include(m => m.MusicVideo)
+                .ThenInclude(mv => mv.Artist)
+                .ThenInclude(a => a.ArtistMetadata)
+                .Filter(m => m.MusicVideo.ArtistId == artistId)
+                .OrderBy(m => m.SortTitle)
+                .Skip((pageNumber - 1) * pageSize)
+                .Take(pageSize)
+                .ToListAsync();
+        }
+
         private static async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> AddMusicVideo(
             TvContext dbContext,
+            Artist artist,
             int libraryPathId,
             string path)
         {
@@ -141,6 +193,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             {
                 var musicVideo = new MusicVideo
                 {
+                    ArtistId = artist.Id,
                     LibraryPathId = libraryPathId,
                     MediaVersions = new List<MediaVersion>
                     {

ErsatzTV.Infrastructure/Data/Repositories/PlayoutRepository.cs

@@ -101,6 +101,9 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
                 .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).Artist)
+                .ThenInclude(mm => mm.ArtistMetadata)
+                .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
                 .ThenInclude(em => em.Artwork)
                 .Include(i => i.MediaItem)

ErsatzTV.Infrastructure/Data/Repositories/SearchRepository.cs

@@ -39,6 +39,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(mm => mm.Tags)
                 .Include(mi => (mi as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Studios)
+                .Include(mi => (mi as Movie).MovieMetadata)
+                .ThenInclude(mm => mm.Actors)
                 .Include(mi => (mi as Movie).MediaVersions)
                 .ThenInclude(mm => mm.Streams)
                 .Include(mi => (mi as Show).ShowMetadata)
@@ -47,6 +49,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(mm => mm.Tags)
                 .Include(mi => (mi as Show).ShowMetadata)
                 .ThenInclude(mm => mm.Studios)
+                .Include(mi => (mi as Show).ShowMetadata)
+                .ThenInclude(mm => mm.Actors)
                 .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
                 .ThenInclude(mm => mm.Genres)
                 .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
@@ -55,98 +59,35 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(mm => mm.Studios)
                 .Include(mi => (mi as MusicVideo).MediaVersions)
                 .ThenInclude(mm => mm.Streams)
+                .Include(mi => (mi as Artist).ArtistMetadata)
+                .ThenInclude(mm => mm.Genres)
+                .Include(mi => (mi as Artist).ArtistMetadata)
+                .ThenInclude(mm => mm.Styles)
+                .Include(mi => (mi as Artist).ArtistMetadata)
+                .ThenInclude(mm => mm.Moods)
                 .OrderBy(mi => mi.Id)
                 .SingleOrDefaultAsync(mi => mi.Id == id)
                 .Map(Optional);
         }
 
-        public async Task<List<MediaItem>> SearchMediaItemsByTitle(string query)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT M.Id FROM Movie M
-                    INNER JOIN MovieMetadata MM on M.Id = MM.MovieId
-                    WHERE MM.Title LIKE @Query
-                    UNION
-                    SELECT S.Id FROM Show S
-                    INNER JOIN ShowMetadata SM on S.Id = SM.ShowId
-                    WHERE SM.Title LIKE @Query
-                    GROUP BY SM.Title, SM.Year",
-                    new { Query = $"%{query}%" })
-                .Map(results => results.ToList());
-
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.MediaItems
-                .Filter(m => ids.Contains(m.Id))
-                .Include(m => (m as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => (m as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .OfType<MediaItem>()
-                .ToListAsync();
-        }
-
-        public async Task<List<MediaItem>> SearchMediaItemsByGenre(string genre)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT M.Id FROM Movie M
-                    INNER JOIN MovieMetadata MM on M.Id = MM.MovieId
-                    INNER JOIN Genre G on MM.Id = G.MovieMetadataId
-                    WHERE G.Name LIKE @Query
-                    UNION
-                    SELECT S.Id FROM Show S
-                    INNER JOIN ShowMetadata SM on S.Id = SM.ShowId
-                    INNER JOIN Genre G2 on SM.Id = G2.ShowMetadataId
-                    WHERE G2.Name LIKE @Query
-                    GROUP BY SM.Title, SM.Year",
-                    new { Query = genre })
-                .Map(results => results.ToList());
-
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.MediaItems
-                .Filter(m => ids.Contains(m.Id))
-                .Include(m => (m as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => (m as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .OfType<MediaItem>()
-                .ToListAsync();
-        }
-
-        public async Task<List<MediaItem>> SearchMediaItemsByTag(string tag)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT M.Id FROM Movie M
-                    INNER JOIN MovieMetadata MM on M.Id = MM.MovieId
-                    INNER JOIN Tag T on MM.Id = T.MovieMetadataId
-                    WHERE T.Name LIKE @Query
-                    UNION
-                    SELECT S.Id FROM Show S
-                    INNER JOIN ShowMetadata SM on S.Id = SM.ShowId
-                    INNER JOIN Tag T2 on SM.Id = T2.ShowMetadataId
-                    WHERE T2.Name LIKE @Query
-                    GROUP BY SM.Title, SM.Year",
-                    new { Query = tag })
-                .Map(results => results.ToList());
-
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.MediaItems
-                .Filter(m => ids.Contains(m.Id))
-                .Include(m => (m as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => (m as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .OfType<MediaItem>()
-                .ToListAsync();
-        }
-
         public Task<List<string>> GetLanguagesForShow(Show show) =>
             _dbConnection.QueryAsync<string>(
                 @"SELECT DISTINCT Language
                     FROM MediaStream
-                    INNER JOIN MediaVersion MV on MediaStream.MediaVersionId = MV.Id
-                    INNER JOIN Episode E on MV.EpisodeId = E.Id
-                    INNER JOIN Season S on E.SeasonId = S.Id
-                    WHERE S.ShowId = @ShowId",
+                    INNER JOIN MediaVersion MV ON MediaStream.MediaVersionId = MV.Id
+                    INNER JOIN Episode E ON MV.EpisodeId = E.Id
+                    INNER JOIN Season S ON E.SeasonId = S.Id
+                    WHERE MediaStreamKind = 2 AND S.ShowId = @ShowId",
                 new { ShowId = show.Id }).Map(result => result.ToList());
+
+        public Task<List<string>> GetLanguagesForArtist(Artist artist) =>
+            _dbConnection.QueryAsync<string>(
+                @"SELECT DISTINCT Language
+                    FROM MediaStream
+                    INNER JOIN MediaVersion V ON MediaStream.MediaVersionId = V.Id
+                    INNER JOIN MusicVideo MV ON V.MusicVideoId = MV.Id
+                    INNER JOIN Artist A on MV.ArtistId = A.Id
+                    WHERE MediaStreamKind = 2 AND A.Id = @ArtistId",
+                new { ArtistId = artist.Id }).Map(result => result.ToList());
     }
 }