add music videos library (#125)

* add music videos library

* add music video tables

* first pass at music video library scan

* support music videos in playouts

* display music videos in search results and collections

* fix music video thumbnails

* remove some obsolete fields

ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs

@@ -3,6 +3,7 @@
     public enum LibraryMediaKind
     {
         Movies = 1,
-        Shows = 2
+        Shows = 2,
+        MusicVideos = 3
     }
 }

ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs

@@ -13,16 +13,6 @@ namespace ErsatzTV.Core.Domain
         public TimeSpan Duration { get; set; }
         public string SampleAspectRatio { get; set; }
         public string DisplayAspectRatio { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string VideoCodec { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string VideoProfile { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string AudioCodec { get; set; }
-
         public VideoScanKind VideoScanKind { get; set; }
         public DateTime DateAdded { get; set; }
         public DateTime DateUpdated { get; set; }

ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs

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

ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class MusicVideoMetadata : Metadata
+    {
+        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/FFmpeg/FFmpegProcessBuilder.cs

@@ -332,11 +332,12 @@ namespace ErsatzTV.Core.FFmpeg
 
         public FFmpegProcessBuilder WithVideoTrackTimeScale(Option<int> videoTrackTimeScale)
         {
-            videoTrackTimeScale.IfSome(timeScale =>
-            {
-                _arguments.Add("-video_track_timescale");
-                _arguments.Add($"{timeScale}");
-            });
+            videoTrackTimeScale.IfSome(
+                timeScale =>
+                {
+                    _arguments.Add("-video_track_timescale");
+                    _arguments.Add($"{timeScale}");
+                });
             return this;
         }
 

ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs

@@ -1,11 +1,13 @@
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ILocalMetadataProvider
     {
         Task<ShowMetadata> GetMetadataForShow(string showFolder);
+        Task<Option<MusicVideoMetadata>> GetMetadataForMusicVideo(string filePath);
         Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path);
         Task<bool> RefreshSidecarMetadata(Show televisionShow, string showFolder);
         Task<bool> RefreshFallbackMetadata(MediaItem mediaItem);

ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs

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

ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs

@@ -0,0 +1,26 @@
+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 IMusicVideoRepository
+    {
+        Task<Option<MusicVideo>> GetByMetadata(LibraryPath libraryPath, MusicVideoMetadata metadata);
+
+        Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> Add(
+            LibraryPath libraryPath,
+            string filePath,
+            MusicVideoMetadata metadata);
+
+        Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath);
+        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+        Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre);
+        Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag);
+        Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio);
+        Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids);
+        Task<Option<MusicVideo>> GetMusicVideo(int musicVideoId);
+    }
+}

ErsatzTV.Core/Iptv/ChannelGuide.cs

@@ -221,6 +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]"),
                 _ => "[unknown]"
             };
         }
@@ -253,6 +255,8 @@ namespace ErsatzTV.Core.Iptv
                 Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
                 Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
                     .IfNone(string.Empty),
+                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => mvm.Plot ?? string.Empty)
+                    .IfNone(string.Empty),
                 _ => string.Empty
             };
         }

ErsatzTV.Core/Metadata/LocalFolderScanner.cs

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

ErsatzTV.Core/Metadata/LocalMetadataProvider.cs

@@ -18,18 +18,21 @@ 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 MusicVideoSerializer = new(typeof(MusicVideoNfo));
         private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILogger<LocalMetadataProvider> _logger;
 
         private readonly IMetadataRepository _metadataRepository;
         private readonly IMovieRepository _movieRepository;
+        private readonly IMusicVideoRepository _musicVideoRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
         public LocalMetadataProvider(
             IMetadataRepository metadataRepository,
             IMovieRepository movieRepository,
             ITelevisionRepository televisionRepository,
+            IMusicVideoRepository musicVideoRepository,
             IFallbackMetadataProvider fallbackMetadataProvider,
             ILocalFileSystem localFileSystem,
             ILogger<LocalMetadataProvider> logger)
@@ -37,6 +40,7 @@ namespace ErsatzTV.Core.Metadata
             _metadataRepository = metadataRepository;
             _movieRepository = movieRepository;
             _televisionRepository = televisionRepository;
+            _musicVideoRepository = musicVideoRepository;
             _fallbackMetadataProvider = fallbackMetadataProvider;
             _localFileSystem = localFileSystem;
             _logger = logger;
@@ -65,6 +69,23 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
+        public async Task<Option<MusicVideoMetadata>> GetMetadataForMusicVideo(string filePath)
+        {
+            string nfoFileName = Path.ChangeExtension(filePath, "nfo");
+            Option<MusicVideoMetadata> maybeMetadata = None;
+            if (_localFileSystem.FileExists(nfoFileName))
+            {
+                maybeMetadata = await LoadMusicVideoMetadata(nfoFileName);
+            }
+
+            return maybeMetadata.Map(
+                metadata =>
+                {
+                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                    return metadata;
+                });
+        }
+
         public Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path) =>
             mediaItem switch
             {
@@ -78,6 +99,11 @@ namespace ErsatzTV.Core.Metadata
                         maybeMetadata => maybeMetadata.Match(
                             metadata => ApplyMetadataUpdate(m, metadata),
                             () => Task.FromResult(false))),
+                MusicVideo mv => LoadMetadata(mv, path)
+                    .Bind(
+                        maybeMetadata => maybeMetadata.Match(
+                            metadata => ApplyMetadataUpdate(mv, metadata),
+                            () => Task.FromResult(false))),
                 _ => Task.FromResult(false)
             };
 
@@ -98,6 +124,37 @@ namespace ErsatzTV.Core.Metadata
         public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
             ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
 
+        private async Task<Option<MusicVideoMetadata>> LoadMusicVideoMetadata(string nfoFileName)
+        {
+            try
+            {
+                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+                Option<MusicVideoNfo> maybeNfo = MusicVideoSerializer.Deserialize(fileStream) as MusicVideoNfo;
+                return maybeNfo.Match<Option<MusicVideoMetadata>>(
+                    nfo => new MusicVideoMetadata
+                    {
+                        MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                        Artist = nfo.Artist,
+                        Album = nfo.Album,
+                        Title = nfo.Title,
+                        Plot = nfo.Plot,
+                        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()
+                    },
+                    None);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogInformation(ex, "Failed to read music video nfo metadata from {Path}", nfoFileName);
+                return None;
+            }
+        }
+
         private async Task<bool> ApplyMetadataUpdate(Episode episode, Tuple<EpisodeMetadata, int> metadataEpisodeNumber)
         {
             (EpisodeMetadata metadata, int episodeNumber) = metadataEpisodeNumber;
@@ -344,6 +401,106 @@ namespace ErsatzTV.Core.Metadata
                     return await _metadataRepository.Add(metadata);
                 });
 
+        private Task<bool> ApplyMetadataUpdate(MusicVideo musicVideo, MusicVideoMetadata metadata) =>
+            Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
+                async existing =>
+                {
+                    var updated = false;
+
+                    existing.Artist = metadata.Artist;
+                    existing.Title = metadata.Title;
+                    existing.Year = metadata.Year;
+                    existing.Plot = metadata.Plot;
+                    existing.Album = metadata.Album;
+
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
+
+                    existing.DateUpdated = metadata.DateUpdated;
+                    existing.MetadataKind = metadata.MetadataKind;
+                    existing.OriginalTitle = metadata.OriginalTitle;
+                    existing.ReleaseDate = metadata.ReleaseDate;
+                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+
+                    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 _musicVideoRepository.AddGenre(existing, genre))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Tag tag in existing.Tags.Filter(t => metadata.Tags.All(t2 => t2.Name != t.Name))
+                        .ToList())
+                    {
+                        existing.Tags.Remove(tag);
+                        if (await _metadataRepository.RemoveTag(tag))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Tag tag in metadata.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
+                        .ToList())
+                    {
+                        existing.Tags.Add(tag);
+                        if (await _musicVideoRepository.AddTag(existing, tag))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in existing.Studios
+                        .Filter(s => metadata.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Remove(studio);
+                        if (await _metadataRepository.RemoveStudio(studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in metadata.Studios
+                        .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                        .ToList())
+                    {
+                        existing.Studios.Add(studio);
+                        if (await _musicVideoRepository.AddStudio(existing, studio))
+                        {
+                            updated = true;
+                        }
+                    }
+
+                    return await _metadataRepository.Update(existing) || updated;
+                },
+                async () =>
+                {
+                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+                    metadata.MusicVideoId = musicVideo.Id;
+                    musicVideo.MusicVideoMetadata = new List<MusicVideoMetadata> { metadata };
+
+                    return await _metadataRepository.Add(metadata);
+                });
+
         private async Task<Option<MovieMetadata>> LoadMetadata(Movie mediaItem, string nfoFileName)
         {
             if (nfoFileName == null || !File.Exists(nfoFileName))
@@ -377,6 +534,17 @@ namespace ErsatzTV.Core.Metadata
             return await LoadTelevisionShowMetadata(nfoFileName);
         }
 
+        private async Task<Option<MusicVideoMetadata>> LoadMetadata(MusicVideo musicVideo, string nfoFileName)
+        {
+            if (nfoFileName == null || !File.Exists(nfoFileName))
+            {
+                _logger.LogDebug("NFO file does not exist at {Path}", nfoFileName);
+                return None;
+            }
+
+            return await LoadMusicVideoMetadata(nfoFileName);
+        }
+
         private async Task<Option<ShowMetadata>> LoadTelevisionShowMetadata(string nfoFileName)
         {
             try
@@ -589,5 +757,36 @@ namespace ErsatzTV.Core.Metadata
             [XmlElement("plot")]
             public string Plot { get; set; }
         }
+
+        [XmlRoot("musicvideo")]
+        public class MusicVideoNfo
+        {
+            [XmlElement("artist")]
+            public string Artist { get; set; }
+
+            [XmlElement("title")]
+            public string Title { get; set; }
+
+            [XmlElement("album")]
+            public string Album { get; set; }
+
+            [XmlElement("plot")]
+            public string Plot { get; set; }
+
+            [XmlElement("premiered")]
+            public string Premiered { get; set; }
+
+            [XmlElement("year")]
+            public int Year { get; set; }
+
+            [XmlElement("genre")]
+            public List<string> Genres { get; set; }
+
+            [XmlElement("tag")]
+            public List<string> Tags { get; set; }
+
+            [XmlElement("studio")]
+            public List<string> Studios { get; set; }
+        }
     }
 }

ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs

@@ -37,6 +37,7 @@ namespace ErsatzTV.Core.Metadata
                 {
                     Movie m => m.MediaVersions.Head().MediaFiles.Head().Path,
                     Episode e => e.MediaVersions.Head().MediaFiles.Head().Path,
+                    MusicVideo mv => mv.MediaVersions.Head().MediaFiles.Head().Path,
                     _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                 };
 
@@ -63,6 +64,7 @@ namespace ErsatzTV.Core.Metadata
             {
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
             };
 

ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Images;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Metadata
+{
+    public class MusicVideoFolderScanner : LocalFolderScanner, IMusicVideoFolderScanner
+    {
+        private readonly ILocalFileSystem _localFileSystem;
+        private readonly ILocalMetadataProvider _localMetadataProvider;
+        private readonly ILogger<MusicVideoFolderScanner> _logger;
+        private readonly IMusicVideoRepository _musicVideoRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public MusicVideoFolderScanner(
+            ILocalFileSystem localFileSystem,
+            ILocalStatisticsProvider localStatisticsProvider,
+            ILocalMetadataProvider localMetadataProvider,
+            IMetadataRepository metadataRepository,
+            IImageCache imageCache,
+            ISearchIndex searchIndex,
+            IMusicVideoRepository musicVideoRepository,
+            ILogger<MusicVideoFolderScanner> logger) : base(
+            localFileSystem,
+            localStatisticsProvider,
+            metadataRepository,
+            imageCache,
+            logger)
+        {
+            _localFileSystem = localFileSystem;
+            _localMetadataProvider = localMetadataProvider;
+            _searchIndex = searchIndex;
+            _musicVideoRepository = musicVideoRepository;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            DateTimeOffset lastScan)
+        {
+            if (!_localFileSystem.IsLibraryPathAccessible(libraryPath))
+            {
+                return new MediaSourceInaccessible();
+            }
+
+            var folderQueue = new Queue<string>();
+            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path).OrderBy(identity))
+            {
+                folderQueue.Enqueue(folder);
+            }
+
+            while (folderQueue.Count > 0)
+            {
+                string movieFolder = folderQueue.Dequeue();
+
+                var allFiles = _localFileSystem.ListFiles(movieFolder)
+                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                    .Filter(
+                        f => !ExtraFiles.Any(
+                            e => Path.GetFileNameWithoutExtension(f).EndsWith(e, StringComparison.OrdinalIgnoreCase)))
+                    .ToList();
+
+                if (allFiles.Count == 0)
+                {
+                    foreach (string subdirectory in _localFileSystem.ListSubdirectories(movieFolder).OrderBy(identity))
+                    {
+                        folderQueue.Enqueue(subdirectory);
+                    }
+
+                    continue;
+                }
+
+                if (_localFileSystem.GetLastWriteTime(movieFolder) < lastScan)
+                {
+                    continue;
+                }
+
+                foreach (string file in allFiles.OrderBy(identity))
+                {
+                    // TODO: figure out how to rebuild playouts
+                    Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo =
+                        await FindOrCreateMusicVideo(libraryPath, file)
+                            .BindT(musicVideo => UpdateStatistics(musicVideo, ffprobePath))
+                            .BindT(UpdateMetadata)
+                            .BindT(UpdateThumbnail);
+
+                    await maybeMusicVideo.Match(
+                        async result =>
+                        {
+                            if (result.IsAdded)
+                            {
+                                await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
+                            {
+                                await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                            }
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning("Error processing music video at {Path}: {Error}", file, error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+            }
+
+            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);
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> FindOrCreateMusicVideo(
+            LibraryPath libraryPath,
+            string filePath)
+        {
+            Option<MusicVideoMetadata> maybeMetadata = await _localMetadataProvider.GetMetadataForMusicVideo(filePath);
+            return await maybeMetadata.Match(
+                async metadata =>
+                {
+                    Option<MusicVideo> maybeMusicVideo =
+                        await _musicVideoRepository.GetByMetadata(libraryPath, metadata);
+                    return await maybeMusicVideo.Match(
+                        musicVideo =>
+                            Right<BaseError, MediaItemScanResult<MusicVideo>>(
+                                    new MediaItemScanResult<MusicVideo>(musicVideo))
+                                .AsTask(),
+                        async () => await _musicVideoRepository.Add(libraryPath, filePath, metadata));
+                },
+                () => Left<BaseError, MediaItemScanResult<MusicVideo>>(
+                    BaseError.New("Unable to locate metadata for music video")).AsTask());
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMetadata(
+            MediaItemScanResult<MusicVideo> result)
+        {
+            try
+            {
+                MusicVideo musicVideo = result.Item;
+                return await LocateNfoFile(musicVideo).Match<Task<Either<BaseError, MediaItemScanResult<MusicVideo>>>>(
+                    async nfoFile =>
+                    {
+                        bool shouldUpdate = Optional(musicVideo.MusicVideoMetadata).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(musicVideo, nfoFile))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        return result;
+                    },
+                    () => Left<BaseError, MediaItemScanResult<MusicVideo>>(
+                        BaseError.New("Unable to locate metadata for music video")).AsTask());
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        private Option<string> LocateNfoFile(MusicVideo musicVideo)
+        {
+            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+            return Optional(Path.ChangeExtension(path, "nfo"))
+                .Filter(s => _localFileSystem.FileExists(s))
+                .HeadOrNone();
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateThumbnail(
+            MediaItemScanResult<MusicVideo> result)
+        {
+            try
+            {
+                MusicVideo musicVideo = result.Item;
+                await LocateThumbnail(musicVideo).IfSomeAsync(
+                    async thumbnailFile =>
+                    {
+                        MusicVideoMetadata metadata = musicVideo.MusicVideoMetadata.Head();
+                        await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail);
+                    });
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        private Option<string> LocateThumbnail(MusicVideo musicVideo)
+        {
+            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+            return ImageFileExtensions
+                .Map(ext => Path.ChangeExtension(path, ext))
+                .Filter(f => _localFileSystem.FileExists(f))
+                .HeadOrNone();
+        }
+    }
+}

ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs

@@ -48,6 +48,9 @@ namespace ErsatzTV.Core.Scheduling
                     Movie m => m.MovieMetadata.HeadOrNone().Match(
                         mm => mm.ReleaseDate ?? DateTime.MaxValue,
                         () => DateTime.MaxValue),
+                    MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                        mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                        () => DateTime.MaxValue),
                     _ => DateTime.MaxValue
                 };
 
@@ -59,6 +62,9 @@ namespace ErsatzTV.Core.Scheduling
                     Movie m => m.MovieMetadata.HeadOrNone().Match(
                         mm => mm.ReleaseDate ?? DateTime.MaxValue,
                         () => DateTime.MaxValue),
+                    MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                        mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                        () => DateTime.MaxValue),
                     _ => DateTime.MaxValue
                 };
 

ErsatzTV.Core/Scheduling/PlayoutBuilder.cs

@@ -99,6 +99,8 @@ namespace ErsatzTV.Core.Scheduling
                                    TimeSpan.Zero,
                         Episode e => e.MediaVersions.HeadOrNone().Map(mv => mv.Duration).IfNone(TimeSpan.Zero) ==
                                      TimeSpan.Zero,
+                        MusicVideo mv => mv.MediaVersions.HeadOrNone().Map(v => v.Duration).IfNone(TimeSpan.Zero) ==
+                                         TimeSpan.Zero,
                         _ => true
                     })).Map(c => c.Key);
             if (zeroDurationCollection.IsSome)
@@ -180,6 +182,7 @@ namespace ErsatzTV.Core.Scheduling
                         {
                             Movie m => m.MediaVersions.Head(),
                             Episode e => e.MediaVersions.Head(),
+                            MusicVideo mv => mv.MediaVersions.Head(),
                             _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                         };
 
@@ -240,6 +243,7 @@ namespace ErsatzTV.Core.Scheduling
                                         {
                                             Movie m => m.MediaVersions.Head(),
                                             Episode e => e.MediaVersions.Head(),
+                                            MusicVideo mv => mv.MediaVersions.Head(),
                                             _ => throw new ArgumentOutOfRangeException(nameof(peekMediaItem))
                                         };
 
@@ -274,6 +278,7 @@ namespace ErsatzTV.Core.Scheduling
                                         {
                                             Movie m => m.MediaVersions.Head(),
                                             Episode e => e.MediaVersions.Head(),
+                                            MusicVideo mv => mv.MediaVersions.Head(),
                                             _ => throw new ArgumentOutOfRangeException(nameof(peekMediaItem))
                                         };
 
@@ -479,6 +484,9 @@ namespace ErsatzTV.Core.Scheduling
                 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
             };