Merge branch 'master' into bhowe34/fix-replace-missing-metadata-for-music

39 files changed, 4087 insertions, 4024 deletions

diff --git a/src/Jellyfin.Drawing.Skia/SkiaCodecException.cs b/src/Jellyfin.Drawing.Skia/SkiaCodecException.cs
deleted file mode 100644
index 581fa000d..000000000
--- a/src/Jellyfin.Drawing.Skia/SkiaCodecException.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-using System.Globalization;
-using SkiaSharp;
-
-namespace Jellyfin.Drawing.Skia;
-
-/// <summary>
-/// Represents errors that occur during interaction with Skia codecs.
-/// </summary>
-public class SkiaCodecException : SkiaException
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SkiaCodecException" /> class.
-    /// </summary>
-    /// <param name="result">The non-successful codec result returned by Skia.</param>
-    public SkiaCodecException(SKCodecResult result)
-    {
-        CodecResult = result;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SkiaCodecException" /> class
-    /// with a specified error message.
-    /// </summary>
-    /// <param name="result">The non-successful codec result returned by Skia.</param>
-    /// <param name="message">The message that describes the error.</param>
-    public SkiaCodecException(SKCodecResult result, string message)
-        : base(message)
-    {
-        CodecResult = result;
-    }
-
-    /// <summary>
-    /// Gets the non-successful codec result returned by Skia.
-    /// </summary>
-    public SKCodecResult CodecResult { get; }
-
-    /// <inheritdoc />
-    public override string ToString()
-        => string.Format(
-            CultureInfo.InvariantCulture,
-            "Non-success codec result: {0}\n{1}",
-            CodecResult,
-            base.ToString());
-}
diff --git a/src/Jellyfin.Drawing.Skia/SkiaEncoder.cs b/src/Jellyfin.Drawing.Skia/SkiaEncoder.cs
index 5721e2882..4ae5a9a48 100644
--- a/src/Jellyfin.Drawing.Skia/SkiaEncoder.cs
+++ b/src/Jellyfin.Drawing.Skia/SkiaEncoder.cs
@@ -182,7 +182,6 @@ public class SkiaEncoder : IImageEncoder
     /// <inheritdoc />
     /// <exception cref="ArgumentNullException">The path is null.</exception>
     /// <exception cref="FileNotFoundException">The path is not valid.</exception>
-    /// <exception cref="SkiaCodecException">The file at the specified path could not be used to generate a codec.</exception>
     public string GetImageBlurHash(int xComp, int yComp, string path)
     {
         ArgumentException.ThrowIfNullOrEmpty(path);
diff --git a/src/Jellyfin.Drawing.Skia/SkiaException.cs b/src/Jellyfin.Drawing.Skia/SkiaException.cs
deleted file mode 100644
index d0e69d42c..000000000
--- a/src/Jellyfin.Drawing.Skia/SkiaException.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-
-namespace Jellyfin.Drawing.Skia;
-
-/// <summary>
-/// Represents errors that occur during interaction with Skia.
-/// </summary>
-public class SkiaException : Exception
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SkiaException"/> class.
-    /// </summary>
-    public SkiaException()
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SkiaException"/> class with a specified error message.
-    /// </summary>
-    /// <param name="message">The message that describes the error.</param>
-    public SkiaException(string message) : base(message)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SkiaException"/> class with a specified error message and a
-    /// reference to the inner exception that is the cause of this exception.
-    /// </summary>
-    /// <param name="message">The error message that explains the reason for the exception.</param>
-    /// <param name="innerException">
-    /// The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if
-    /// no inner exception is specified.
-    /// </param>
-    public SkiaException(string message, Exception innerException)
-        : base(message, innerException)
-    {
-    }
-}
diff --git a/src/Jellyfin.Drawing/ImageProcessor.cs b/src/Jellyfin.Drawing/ImageProcessor.cs
index 65a8f4e83..213328a39 100644
--- a/src/Jellyfin.Drawing/ImageProcessor.cs
+++ b/src/Jellyfin.Drawing/ImageProcessor.cs
@@ -7,6 +7,7 @@ using System.Net.Mime;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using AsyncKeyedLock;
 using Jellyfin.Data.Entities;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller;
@@ -38,7 +39,7 @@ public sealed class ImageProcessor : IImageProcessor, IDisposable
     private readonly IServerApplicationPaths _appPaths;
     private readonly IImageEncoder _imageEncoder;
 
-    private readonly SemaphoreSlim _parallelEncodingLimit;
+    private readonly AsyncNonKeyedLocker _parallelEncodingLimit;
 
     private bool _disposed;
 
@@ -68,7 +69,7 @@ public sealed class ImageProcessor : IImageProcessor, IDisposable
             semaphoreCount = 2 * Environment.ProcessorCount;
         }
 
-        _parallelEncodingLimit = new(semaphoreCount, semaphoreCount);
+        _parallelEncodingLimit = new(semaphoreCount);
     }
 
     private string ResizedImageCachePath => Path.Combine(_appPaths.ImageCachePath, "resized-images");
@@ -193,18 +194,13 @@ public sealed class ImageProcessor : IImageProcessor, IDisposable
         {
             if (!File.Exists(cacheFilePath))
             {
-                // Limit number of parallel (more precisely: concurrent) image encodings to prevent a high memory usage
-                await _parallelEncodingLimit.WaitAsync().ConfigureAwait(false);
-
                 string resultPath;
-                try
+
+                // Limit number of parallel (more precisely: concurrent) image encodings to prevent a high memory usage
+                using (await _parallelEncodingLimit.LockAsync().ConfigureAwait(false))
                 {
                     resultPath = _imageEncoder.EncodeImage(originalImagePath, dateModified, cacheFilePath, autoOrient, orientation, quality, options, outputFormat);
                 }
-                finally
-                {
-                    _parallelEncodingLimit.Release();
-                }
 
                 if (string.Equals(resultPath, originalImagePath, StringComparison.OrdinalIgnoreCase))
                 {
diff --git a/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj b/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
index 23c4c0a9a..4a02f90f9 100644
--- a/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
+++ b/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
@@ -21,4 +21,8 @@
     <Compile Include="..\..\SharedVersion.cs" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="AsyncKeyedLock" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/Jellyfin.Extensions/StringExtensions.cs b/src/Jellyfin.Extensions/StringExtensions.cs
index fd8f7e59a..9d8afc23c 100644
--- a/src/Jellyfin.Extensions/StringExtensions.cs
+++ b/src/Jellyfin.Extensions/StringExtensions.cs
@@ -61,6 +61,11 @@ namespace Jellyfin.Extensions
         /// <returns>The part left of the <paramref name="needle" />.</returns>
         public static ReadOnlySpan<char> LeftPart(this ReadOnlySpan<char> haystack, char needle)
         {
+            if (haystack.IsEmpty)
+            {
+                return ReadOnlySpan<char>.Empty;
+            }
+
             var pos = haystack.IndexOf(needle);
             return pos == -1 ? haystack : haystack[..pos];
         }
@@ -73,6 +78,11 @@ namespace Jellyfin.Extensions
         /// <returns>The part right of the <paramref name="needle" />.</returns>
         public static ReadOnlySpan<char> RightPart(this ReadOnlySpan<char> haystack, char needle)
         {
+            if (haystack.IsEmpty)
+            {
+                return ReadOnlySpan<char>.Empty;
+            }
+
             var pos = haystack.LastIndexOf(needle);
             if (pos == -1)
             {
diff --git a/src/Jellyfin.LiveTv/Channels/ChannelManager.cs b/src/Jellyfin.LiveTv/Channels/ChannelManager.cs
index bc968f8ee..1948a9ab9 100644
--- a/src/Jellyfin.LiveTv/Channels/ChannelManager.cs
+++ b/src/Jellyfin.LiveTv/Channels/ChannelManager.cs
@@ -8,12 +8,12 @@ using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using AsyncKeyedLock;
 using Jellyfin.Data.Entities;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using Jellyfin.Extensions.Json;
 using MediaBrowser.Common.Extensions;
-using MediaBrowser.Common.Progress;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Dto;
@@ -50,7 +50,7 @@ namespace Jellyfin.LiveTv.Channels
         private readonly IFileSystem _fileSystem;
         private readonly IProviderManager _providerManager;
         private readonly IMemoryCache _memoryCache;
-        private readonly SemaphoreSlim _resourcePool = new SemaphoreSlim(1, 1);
+        private readonly AsyncNonKeyedLocker _resourcePool = new(1);
         private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
         private bool _disposed = false;
 
@@ -667,7 +667,7 @@ namespace Jellyfin.LiveTv.Channels
                 ChannelIds = new Guid[] { internalChannel.Id }
             };
 
-            var result = await GetChannelItemsInternal(query, new SimpleProgress<double>(), cancellationToken).ConfigureAwait(false);
+            var result = await GetChannelItemsInternal(query, new Progress<double>(), cancellationToken).ConfigureAwait(false);
 
             foreach (var item in result.Items)
             {
@@ -680,7 +680,7 @@ namespace Jellyfin.LiveTv.Channels
                             EnableTotalRecordCount = false,
                             ChannelIds = new Guid[] { internalChannel.Id }
                         },
-                        new SimpleProgress<double>(),
+                        new Progress<double>(),
                         cancellationToken).ConfigureAwait(false);
                 }
             }
@@ -762,7 +762,7 @@ namespace Jellyfin.LiveTv.Channels
         /// <inheritdoc />
         public async Task<QueryResult<BaseItemDto>> GetChannelItems(InternalItemsQuery query, CancellationToken cancellationToken)
         {
-            var internalResult = await GetChannelItemsInternal(query, new SimpleProgress<double>(), cancellationToken).ConfigureAwait(false);
+            var internalResult = await GetChannelItemsInternal(query, new Progress<double>(), cancellationToken).ConfigureAwait(false);
 
             var returnItems = _dtoService.GetBaseItemDtos(internalResult.Items, query.DtoOptions, query.User);
 
@@ -811,9 +811,7 @@ namespace Jellyfin.LiveTv.Channels
             {
             }
 
-            await _resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
-
-            try
+            using (await _resourcePool.LockAsync(cancellationToken).ConfigureAwait(false))
             {
                 try
                 {
@@ -860,10 +858,6 @@ namespace Jellyfin.LiveTv.Channels
 
                 return result;
             }
-            finally
-            {
-                _resourcePool.Release();
-            }
         }
 
         private async Task CacheResponse(ChannelItemResult result, string path)
diff --git a/src/Jellyfin.LiveTv/Channels/RefreshChannelsScheduledTask.cs b/src/Jellyfin.LiveTv/Channels/RefreshChannelsScheduledTask.cs
index 556e052d4..79c5873d5 100644
--- a/src/Jellyfin.LiveTv/Channels/RefreshChannelsScheduledTask.cs
+++ b/src/Jellyfin.LiveTv/Channels/RefreshChannelsScheduledTask.cs
@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using MediaBrowser.Common.Progress;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Globalization;
@@ -66,7 +65,7 @@ namespace Jellyfin.LiveTv.Channels
         {
             var manager = (ChannelManager)_channelManager;
 
-            await manager.RefreshChannels(new SimpleProgress<double>(), cancellationToken).ConfigureAwait(false);
+            await manager.RefreshChannels(new Progress<double>(), cancellationToken).ConfigureAwait(false);
 
             await new ChannelPostScanTask(_channelManager, _logger, _libraryManager).Run(progress, cancellationToken)
                     .ConfigureAwait(false);
diff --git a/src/Jellyfin.LiveTv/Configuration/LiveTvConfigurationExtensions.cs b/src/Jellyfin.LiveTv/Configuration/LiveTvConfigurationExtensions.cs
index 67d0e5295..f7888496f 100644
--- a/src/Jellyfin.LiveTv/Configuration/LiveTvConfigurationExtensions.cs
+++ b/src/Jellyfin.LiveTv/Configuration/LiveTvConfigurationExtensions.cs
@@ -1,4 +1,5 @@
 using MediaBrowser.Common.Configuration;
+using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.LiveTv;
 
 namespace Jellyfin.LiveTv.Configuration;
@@ -15,4 +16,12 @@ public static class LiveTvConfigurationExtensions
     /// <returns>The <see cref="LiveTvOptions"/>.</returns>
     public static LiveTvOptions GetLiveTvConfiguration(this IConfigurationManager configurationManager)
         => configurationManager.GetConfiguration<LiveTvOptions>("livetv");
+
+    /// <summary>
+    /// Gets the <see cref="XbmcMetadataOptions"/>.
+    /// </summary>
+    /// <param name="configurationManager">The <see cref="IConfigurationManager"/>.</param>
+    /// <returns>The <see cref="XbmcMetadataOptions"/>.</returns>
+    public static XbmcMetadataOptions GetNfoConfiguration(this IConfigurationManager configurationManager)
+        => configurationManager.GetConfiguration<XbmcMetadataOptions>("xbmcmetadata");
 }
diff --git a/src/Jellyfin.LiveTv/DefaultLiveTvService.cs b/src/Jellyfin.LiveTv/DefaultLiveTvService.cs
new file mode 100644
index 000000000..318cc7acd
--- /dev/null
+++ b/src/Jellyfin.LiveTv/DefaultLiveTvService.cs
@@ -0,0 +1,998 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Data.Events;
+using Jellyfin.Extensions;
+using Jellyfin.LiveTv.Configuration;
+using Jellyfin.LiveTv.Timers;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.LiveTv;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv
+{
+    public sealed class DefaultLiveTvService : ILiveTvService, ISupportsDirectStreamProvider, ISupportsNewTimerIds
+    {
+        public const string ServiceName = "Emby";
+
+        private readonly ILogger<DefaultLiveTvService> _logger;
+        private readonly IServerConfigurationManager _config;
+        private readonly ITunerHostManager _tunerHostManager;
+        private readonly IListingsManager _listingsManager;
+        private readonly IRecordingsManager _recordingsManager;
+        private readonly ILibraryManager _libraryManager;
+        private readonly LiveTvDtoService _tvDtoService;
+        private readonly TimerManager _timerManager;
+        private readonly SeriesTimerManager _seriesTimerManager;
+
+        public DefaultLiveTvService(
+            ILogger<DefaultLiveTvService> logger,
+            IServerConfigurationManager config,
+            ITunerHostManager tunerHostManager,
+            IListingsManager listingsManager,
+            IRecordingsManager recordingsManager,
+            ILibraryManager libraryManager,
+            LiveTvDtoService tvDtoService,
+            TimerManager timerManager,
+            SeriesTimerManager seriesTimerManager)
+        {
+            _logger = logger;
+            _config = config;
+            _libraryManager = libraryManager;
+            _tunerHostManager = tunerHostManager;
+            _listingsManager = listingsManager;
+            _recordingsManager = recordingsManager;
+            _tvDtoService = tvDtoService;
+            _timerManager = timerManager;
+            _seriesTimerManager = seriesTimerManager;
+
+            _timerManager.TimerFired += OnTimerManagerTimerFired;
+        }
+
+        public event EventHandler<GenericEventArgs<TimerInfo>> TimerCreated;
+
+        public event EventHandler<GenericEventArgs<string>> TimerCancelled;
+
+        /// <inheritdoc />
+        public string Name => ServiceName;
+
+        /// <inheritdoc />
+        public string HomePageUrl => "https://github.com/jellyfin/jellyfin";
+
+        public async Task RefreshSeriesTimers(CancellationToken cancellationToken)
+        {
+            var seriesTimers = await GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
+
+            foreach (var timer in seriesTimers)
+            {
+                UpdateTimersForSeriesTimer(timer, false, true);
+            }
+        }
+
+        public async Task RefreshTimers(CancellationToken cancellationToken)
+        {
+            var timers = await GetTimersAsync(cancellationToken).ConfigureAwait(false);
+
+            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
+
+            foreach (var timer in timers)
+            {
+                if (DateTime.UtcNow > timer.EndDate && _recordingsManager.GetActiveRecordingPath(timer.Id) is null)
+                {
+                    _timerManager.Delete(timer);
+                    continue;
+                }
+
+                if (string.IsNullOrWhiteSpace(timer.ProgramId) || string.IsNullOrWhiteSpace(timer.ChannelId))
+                {
+                    continue;
+                }
+
+                var program = GetProgramInfoFromCache(timer);
+                if (program is null)
+                {
+                    _timerManager.Delete(timer);
+                    continue;
+                }
+
+                CopyProgramInfoToTimerInfo(program, timer, tempChannelCache);
+                _timerManager.Update(timer);
+            }
+        }
+
+        private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
+        {
+            var channels = new List<ChannelInfo>();
+
+            foreach (var hostInstance in _tunerHostManager.TunerHosts)
+            {
+                try
+                {
+                    var tunerChannels = await hostInstance.GetChannels(enableCache, cancellationToken).ConfigureAwait(false);
+
+                    channels.AddRange(tunerChannels);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error getting channels");
+                }
+            }
+
+            await _listingsManager.AddProviderMetadata(channels, enableCache, cancellationToken).ConfigureAwait(false);
+
+            return channels;
+        }
+
+        public Task<IEnumerable<ChannelInfo>> GetChannelsAsync(CancellationToken cancellationToken)
+        {
+            return GetChannelsAsync(false, cancellationToken);
+        }
+
+        public Task CancelSeriesTimerAsync(string timerId, CancellationToken cancellationToken)
+        {
+            var timers = _timerManager
+                .GetAll()
+                .Where(i => string.Equals(i.SeriesTimerId, timerId, StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+            foreach (var timer in timers)
+            {
+                CancelTimerInternal(timer.Id, true, true);
+            }
+
+            var remove = _seriesTimerManager.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
+            if (remove is not null)
+            {
+                _seriesTimerManager.Delete(remove);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private void CancelTimerInternal(string timerId, bool isSeriesCancelled, bool isManualCancellation)
+        {
+            var timer = _timerManager.GetTimer(timerId);
+            if (timer is not null)
+            {
+                var statusChanging = timer.Status != RecordingStatus.Cancelled;
+                timer.Status = RecordingStatus.Cancelled;
+
+                if (isManualCancellation)
+                {
+                    timer.IsManual = true;
+                }
+
+                if (string.IsNullOrWhiteSpace(timer.SeriesTimerId) || isSeriesCancelled)
+                {
+                    _timerManager.Delete(timer);
+                }
+                else
+                {
+                    _timerManager.AddOrUpdate(timer, false);
+                }
+
+                if (statusChanging && TimerCancelled is not null)
+                {
+                    TimerCancelled(this, new GenericEventArgs<string>(timerId));
+                }
+            }
+
+            _recordingsManager.CancelRecording(timerId, timer);
+        }
+
+        public Task CancelTimerAsync(string timerId, CancellationToken cancellationToken)
+        {
+            CancelTimerInternal(timerId, false, true);
+            return Task.CompletedTask;
+        }
+
+        public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<string> CreateTimer(TimerInfo info, CancellationToken cancellationToken)
+        {
+            var existingTimer = string.IsNullOrWhiteSpace(info.ProgramId) ?
+                null :
+                _timerManager.GetTimerByProgramId(info.ProgramId);
+
+            if (existingTimer is not null)
+            {
+                if (existingTimer.Status == RecordingStatus.Cancelled
+                    || existingTimer.Status == RecordingStatus.Completed)
+                {
+                    existingTimer.Status = RecordingStatus.New;
+                    existingTimer.IsManual = true;
+                    _timerManager.Update(existingTimer);
+                    return Task.FromResult(existingTimer.Id);
+                }
+
+                throw new ArgumentException("A scheduled recording already exists for this program.");
+            }
+
+            info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
+
+            LiveTvProgram programInfo = null;
+
+            if (!string.IsNullOrWhiteSpace(info.ProgramId))
+            {
+                programInfo = GetProgramInfoFromCache(info);
+            }
+
+            if (programInfo is null)
+            {
+                _logger.LogInformation("Unable to find program with Id {0}. Will search using start date", info.ProgramId);
+                programInfo = GetProgramInfoFromCache(info.ChannelId, info.StartDate);
+            }
+
+            if (programInfo is not null)
+            {
+                CopyProgramInfoToTimerInfo(programInfo, info);
+            }
+
+            info.IsManual = true;
+            _timerManager.Add(info);
+
+            TimerCreated?.Invoke(this, new GenericEventArgs<TimerInfo>(info));
+
+            return Task.FromResult(info.Id);
+        }
+
+        public async Task<string> CreateSeriesTimer(SeriesTimerInfo info, CancellationToken cancellationToken)
+        {
+            info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
+
+            // populate info.seriesID
+            var program = GetProgramInfoFromCache(info.ProgramId);
+
+            if (program is not null)
+            {
+                info.SeriesId = program.ExternalSeriesId;
+            }
+            else
+            {
+                throw new InvalidOperationException("SeriesId for program not found");
+            }
+
+            // If any timers have already been manually created, make sure they don't get cancelled
+            var existingTimers = (await GetTimersAsync(CancellationToken.None).ConfigureAwait(false))
+                .Where(i =>
+                {
+                    if (string.Equals(i.ProgramId, info.ProgramId, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(info.ProgramId))
+                    {
+                        return true;
+                    }
+
+                    if (string.Equals(i.SeriesId, info.SeriesId, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(info.SeriesId))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                })
+                .ToList();
+
+            _seriesTimerManager.Add(info);
+
+            foreach (var timer in existingTimers)
+            {
+                timer.SeriesTimerId = info.Id;
+                timer.IsManual = true;
+
+                _timerManager.AddOrUpdate(timer, false);
+            }
+
+            UpdateTimersForSeriesTimer(info, true, false);
+
+            return info.Id;
+        }
+
+        public Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
+        {
+            var instance = _seriesTimerManager.GetAll().FirstOrDefault(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
+
+            if (instance is not null)
+            {
+                instance.ChannelId = info.ChannelId;
+                instance.Days = info.Days;
+                instance.EndDate = info.EndDate;
+                instance.IsPostPaddingRequired = info.IsPostPaddingRequired;
+                instance.IsPrePaddingRequired = info.IsPrePaddingRequired;
+                instance.PostPaddingSeconds = info.PostPaddingSeconds;
+                instance.PrePaddingSeconds = info.PrePaddingSeconds;
+                instance.Priority = info.Priority;
+                instance.RecordAnyChannel = info.RecordAnyChannel;
+                instance.RecordAnyTime = info.RecordAnyTime;
+                instance.RecordNewOnly = info.RecordNewOnly;
+                instance.SkipEpisodesInLibrary = info.SkipEpisodesInLibrary;
+                instance.KeepUpTo = info.KeepUpTo;
+                instance.KeepUntil = info.KeepUntil;
+                instance.StartDate = info.StartDate;
+
+                _seriesTimerManager.Update(instance);
+
+                UpdateTimersForSeriesTimer(instance, true, true);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        public Task UpdateTimerAsync(TimerInfo updatedTimer, CancellationToken cancellationToken)
+        {
+            var existingTimer = _timerManager.GetTimer(updatedTimer.Id);
+
+            if (existingTimer is null)
+            {
+                throw new ResourceNotFoundException();
+            }
+
+            // Only update if not currently active
+            if (_recordingsManager.GetActiveRecordingPath(updatedTimer.Id) is null)
+            {
+                existingTimer.PrePaddingSeconds = updatedTimer.PrePaddingSeconds;
+                existingTimer.PostPaddingSeconds = updatedTimer.PostPaddingSeconds;
+                existingTimer.IsPostPaddingRequired = updatedTimer.IsPostPaddingRequired;
+                existingTimer.IsPrePaddingRequired = updatedTimer.IsPrePaddingRequired;
+
+                _timerManager.Update(existingTimer);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private static void UpdateExistingTimerWithNewMetadata(TimerInfo existingTimer, TimerInfo updatedTimer)
+        {
+            // Update the program info but retain the status
+            existingTimer.ChannelId = updatedTimer.ChannelId;
+            existingTimer.CommunityRating = updatedTimer.CommunityRating;
+            existingTimer.EndDate = updatedTimer.EndDate;
+            existingTimer.EpisodeNumber = updatedTimer.EpisodeNumber;
+            existingTimer.EpisodeTitle = updatedTimer.EpisodeTitle;
+            existingTimer.Genres = updatedTimer.Genres;
+            existingTimer.IsMovie = updatedTimer.IsMovie;
+            existingTimer.IsSeries = updatedTimer.IsSeries;
+            existingTimer.Tags = updatedTimer.Tags;
+            existingTimer.IsProgramSeries = updatedTimer.IsProgramSeries;
+            existingTimer.IsRepeat = updatedTimer.IsRepeat;
+            existingTimer.Name = updatedTimer.Name;
+            existingTimer.OfficialRating = updatedTimer.OfficialRating;
+            existingTimer.OriginalAirDate = updatedTimer.OriginalAirDate;
+            existingTimer.Overview = updatedTimer.Overview;
+            existingTimer.ProductionYear = updatedTimer.ProductionYear;
+            existingTimer.ProgramId = updatedTimer.ProgramId;
+            existingTimer.SeasonNumber = updatedTimer.SeasonNumber;
+            existingTimer.StartDate = updatedTimer.StartDate;
+            existingTimer.ShowId = updatedTimer.ShowId;
+            existingTimer.ProviderIds = updatedTimer.ProviderIds;
+            existingTimer.SeriesProviderIds = updatedTimer.SeriesProviderIds;
+        }
+
+        public Task<IEnumerable<TimerInfo>> GetTimersAsync(CancellationToken cancellationToken)
+        {
+            var excludeStatues = new List<RecordingStatus>
+            {
+                RecordingStatus.Completed
+            };
+
+            var timers = _timerManager.GetAll()
+                .Where(i => !excludeStatues.Contains(i.Status));
+
+            return Task.FromResult(timers);
+        }
+
+        public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null)
+        {
+            var config = _config.GetLiveTvConfiguration();
+
+            var defaults = new SeriesTimerInfo()
+            {
+                PostPaddingSeconds = Math.Max(config.PostPaddingSeconds, 0),
+                PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0),
+                RecordAnyChannel = false,
+                RecordAnyTime = true,
+                RecordNewOnly = true,
+
+                Days = new List<DayOfWeek>
+                {
+                    DayOfWeek.Sunday,
+                    DayOfWeek.Monday,
+                    DayOfWeek.Tuesday,
+                    DayOfWeek.Wednesday,
+                    DayOfWeek.Thursday,
+                    DayOfWeek.Friday,
+                    DayOfWeek.Saturday
+                }
+            };
+
+            if (program is not null)
+            {
+                defaults.SeriesId = program.SeriesId;
+                defaults.ProgramId = program.Id;
+                defaults.RecordNewOnly = !program.IsRepeat;
+                defaults.Name = program.Name;
+            }
+
+            defaults.SkipEpisodesInLibrary = defaults.RecordNewOnly;
+            defaults.KeepUntil = KeepUntil.UntilDeleted;
+
+            return Task.FromResult(defaults);
+        }
+
+        public Task<IEnumerable<SeriesTimerInfo>> GetSeriesTimersAsync(CancellationToken cancellationToken)
+        {
+            return Task.FromResult((IEnumerable<SeriesTimerInfo>)_seriesTimerManager.GetAll());
+        }
+
+        public async Task<IEnumerable<ProgramInfo>> GetProgramsAsync(string channelId, DateTime startDateUtc, DateTime endDateUtc, CancellationToken cancellationToken)
+        {
+            var channels = await GetChannelsAsync(true, cancellationToken).ConfigureAwait(false);
+            var channel = channels.First(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase));
+
+            return await _listingsManager.GetProgramsAsync(channel, startDateUtc, endDateUtc, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        public Task<MediaSourceInfo> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task<ILiveStream> GetChannelStreamWithDirectStreamProvider(string channelId, string streamId, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
+        {
+            _logger.LogInformation("Streaming Channel {Id}", channelId);
+
+            var result = string.IsNullOrEmpty(streamId) ?
+                null :
+                currentLiveStreams.FirstOrDefault(i => string.Equals(i.OriginalStreamId, streamId, StringComparison.OrdinalIgnoreCase));
+
+            if (result is not null && result.EnableStreamSharing)
+            {
+                result.ConsumerCount++;
+
+                _logger.LogInformation("Live stream {0} consumer count is now {1}", streamId, result.ConsumerCount);
+
+                return result;
+            }
+
+            foreach (var hostInstance in _tunerHostManager.TunerHosts)
+            {
+                try
+                {
+                    result = await hostInstance.GetChannelStream(channelId, streamId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
+
+                    var openedMediaSource = result.MediaSource;
+
+                    result.OriginalStreamId = streamId;
+
+                    _logger.LogInformation("Returning mediasource streamId {0}, mediaSource.Id {1}, mediaSource.LiveStreamId {2}", streamId, openedMediaSource.Id, openedMediaSource.LiveStreamId);
+
+                    return result;
+                }
+                catch (FileNotFoundException)
+                {
+                }
+                catch (OperationCanceledException)
+                {
+                }
+            }
+
+            throw new ResourceNotFoundException("Tuner not found.");
+        }
+
+        public async Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(string channelId, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(channelId))
+            {
+                throw new ArgumentNullException(nameof(channelId));
+            }
+
+            foreach (var hostInstance in _tunerHostManager.TunerHosts)
+            {
+                try
+                {
+                    var sources = await hostInstance.GetChannelStreamMediaSources(channelId, cancellationToken).ConfigureAwait(false);
+
+                    if (sources.Count > 0)
+                    {
+                        return sources;
+                    }
+                }
+                catch (NotImplementedException)
+                {
+                }
+            }
+
+            throw new NotImplementedException();
+        }
+
+        public Task CloseLiveStream(string id, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task ResetTuner(string id, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        private async void OnTimerManagerTimerFired(object sender, GenericEventArgs<TimerInfo> e)
+        {
+            var timer = e.Argument;
+
+            _logger.LogInformation("Recording timer fired for {0}.", timer.Name);
+
+            try
+            {
+                var recordingEndDate = timer.EndDate.AddSeconds(timer.PostPaddingSeconds);
+                if (recordingEndDate <= DateTime.UtcNow)
+                {
+                    _logger.LogWarning("Recording timer fired for updatedTimer {0}, Id: {1}, but the program has already ended.", timer.Name, timer.Id);
+                    _timerManager.Delete(timer);
+                    return;
+                }
+
+                var activeRecordingInfo = new ActiveRecordingInfo
+                {
+                    CancellationTokenSource = new CancellationTokenSource(),
+                    Timer = timer,
+                    Id = timer.Id
+                };
+
+                if (_recordingsManager.GetActiveRecordingPath(timer.Id) is not null)
+                {
+                    _logger.LogInformation("Skipping RecordStream because it's already in progress.");
+                    return;
+                }
+
+                LiveTvProgram programInfo = null;
+                if (!string.IsNullOrWhiteSpace(timer.ProgramId))
+                {
+                    programInfo = GetProgramInfoFromCache(timer);
+                }
+
+                if (programInfo is null)
+                {
+                    _logger.LogInformation("Unable to find program with Id {0}. Will search using start date", timer.ProgramId);
+                    programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.StartDate);
+                }
+
+                if (programInfo is not null)
+                {
+                    CopyProgramInfoToTimerInfo(programInfo, timer);
+                }
+
+                await _recordingsManager.RecordStream(activeRecordingInfo, GetLiveTvChannel(timer), recordingEndDate)
+                    .ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error recording stream");
+            }
+        }
+
+        private BaseItem GetLiveTvChannel(TimerInfo timer)
+        {
+            var internalChannelId = _tvDtoService.GetInternalChannelId(Name, timer.ChannelId);
+            return _libraryManager.GetItemById(internalChannelId);
+        }
+
+        private LiveTvProgram GetProgramInfoFromCache(string programId)
+        {
+            var query = new InternalItemsQuery
+            {
+                ItemIds = [_tvDtoService.GetInternalProgramId(programId)],
+                Limit = 1,
+                DtoOptions = new DtoOptions()
+            };
+
+            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().FirstOrDefault();
+        }
+
+        private LiveTvProgram GetProgramInfoFromCache(TimerInfo timer)
+        {
+            return GetProgramInfoFromCache(timer.ProgramId);
+        }
+
+        private LiveTvProgram GetProgramInfoFromCache(string channelId, DateTime startDateUtc)
+        {
+            var query = new InternalItemsQuery
+            {
+                IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
+                Limit = 1,
+                DtoOptions = new DtoOptions(true)
+                {
+                    EnableImages = false
+                },
+                MinStartDate = startDateUtc.AddMinutes(-3),
+                MaxStartDate = startDateUtc.AddMinutes(3),
+                OrderBy = new[] { (ItemSortBy.StartDate, SortOrder.Ascending) }
+            };
+
+            if (!string.IsNullOrWhiteSpace(channelId))
+            {
+                query.ChannelIds = [_tvDtoService.GetInternalChannelId(Name, channelId)];
+            }
+
+            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().FirstOrDefault();
+        }
+
+        private bool ShouldCancelTimerForSeriesTimer(SeriesTimerInfo seriesTimer, TimerInfo timer)
+        {
+            if (timer.IsManual)
+            {
+                return false;
+            }
+
+            if (!seriesTimer.RecordAnyTime
+                && Math.Abs(seriesTimer.StartDate.TimeOfDay.Ticks - timer.StartDate.TimeOfDay.Ticks) >= TimeSpan.FromMinutes(10).Ticks)
+            {
+                return true;
+            }
+
+            if (seriesTimer.RecordNewOnly && timer.IsRepeat)
+            {
+                return true;
+            }
+
+            if (!seriesTimer.RecordAnyChannel
+                && !string.Equals(timer.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            return seriesTimer.SkipEpisodesInLibrary && IsProgramAlreadyInLibrary(timer);
+        }
+
+        private void HandleDuplicateShowIds(List<TimerInfo> timers)
+        {
+            // sort showings by HD channels first, then by startDate, record earliest showing possible
+            foreach (var timer in timers.OrderByDescending(t => GetLiveTvChannel(t).IsHD).ThenBy(t => t.StartDate).Skip(1))
+            {
+                timer.Status = RecordingStatus.Cancelled;
+                _timerManager.Update(timer);
+            }
+        }
+
+        private void SearchForDuplicateShowIds(IEnumerable<TimerInfo> timers)
+        {
+            var groups = timers.ToLookup(i => i.ShowId ?? string.Empty).ToList();
+
+            foreach (var group in groups)
+            {
+                if (string.IsNullOrWhiteSpace(group.Key))
+                {
+                    continue;
+                }
+
+                var groupTimers = group.ToList();
+
+                if (groupTimers.Count < 2)
+                {
+                    continue;
+                }
+
+                // Skip ShowId without SubKey from duplicate removal actions - https://github.com/jellyfin/jellyfin/issues/5856
+                if (group.Key.EndsWith("0000", StringComparison.Ordinal))
+                {
+                    continue;
+                }
+
+                HandleDuplicateShowIds(groupTimers);
+            }
+        }
+
+        private void UpdateTimersForSeriesTimer(SeriesTimerInfo seriesTimer, bool updateTimerSettings, bool deleteInvalidTimers)
+        {
+            var allTimers = GetTimersForSeries(seriesTimer).ToList();
+
+            var enabledTimersForSeries = new List<TimerInfo>();
+            foreach (var timer in allTimers)
+            {
+                var existingTimer = _timerManager.GetTimer(timer.Id)
+                    ?? (string.IsNullOrWhiteSpace(timer.ProgramId)
+                        ? null
+                        : _timerManager.GetTimerByProgramId(timer.ProgramId));
+
+                if (existingTimer is null)
+                {
+                    if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
+                    {
+                        timer.Status = RecordingStatus.Cancelled;
+                    }
+                    else
+                    {
+                        enabledTimersForSeries.Add(timer);
+                    }
+
+                    _timerManager.Add(timer);
+
+                    TimerCreated?.Invoke(this, new GenericEventArgs<TimerInfo>(timer));
+                }
+
+                // Only update if not currently active - test both new timer and existing in case Id's are different
+                // Id's could be different if the timer was created manually prior to series timer creation
+                else if (_recordingsManager.GetActiveRecordingPath(timer.Id) is null
+                         && _recordingsManager.GetActiveRecordingPath(existingTimer.Id) is null)
+                {
+                    UpdateExistingTimerWithNewMetadata(existingTimer, timer);
+
+                    // Needed by ShouldCancelTimerForSeriesTimer
+                    timer.IsManual = existingTimer.IsManual;
+
+                    if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
+                    {
+                        existingTimer.Status = RecordingStatus.Cancelled;
+                    }
+                    else if (!existingTimer.IsManual)
+                    {
+                        existingTimer.Status = RecordingStatus.New;
+                    }
+
+                    if (existingTimer.Status != RecordingStatus.Cancelled)
+                    {
+                        enabledTimersForSeries.Add(existingTimer);
+                    }
+
+                    if (updateTimerSettings)
+                    {
+                        existingTimer.KeepUntil = seriesTimer.KeepUntil;
+                        existingTimer.IsPostPaddingRequired = seriesTimer.IsPostPaddingRequired;
+                        existingTimer.IsPrePaddingRequired = seriesTimer.IsPrePaddingRequired;
+                        existingTimer.PostPaddingSeconds = seriesTimer.PostPaddingSeconds;
+                        existingTimer.PrePaddingSeconds = seriesTimer.PrePaddingSeconds;
+                        existingTimer.Priority = seriesTimer.Priority;
+                        existingTimer.SeriesTimerId = seriesTimer.Id;
+                    }
+
+                    existingTimer.SeriesTimerId = seriesTimer.Id;
+                    _timerManager.Update(existingTimer);
+                }
+            }
+
+            SearchForDuplicateShowIds(enabledTimersForSeries);
+
+            if (deleteInvalidTimers)
+            {
+                var allTimerIds = allTimers
+                    .Select(i => i.Id)
+                    .ToList();
+
+                var deleteStatuses = new[]
+                {
+                    RecordingStatus.New
+                };
+
+                var deletes = _timerManager.GetAll()
+                    .Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase))
+                    .Where(i => !allTimerIds.Contains(i.Id, StringComparison.OrdinalIgnoreCase) && i.StartDate > DateTime.UtcNow)
+                    .Where(i => deleteStatuses.Contains(i.Status))
+                    .ToList();
+
+                foreach (var timer in deletes)
+                {
+                    CancelTimerInternal(timer.Id, false, false);
+                }
+            }
+        }
+
+        private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer)
+        {
+            ArgumentNullException.ThrowIfNull(seriesTimer);
+
+            var query = new InternalItemsQuery
+            {
+                IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
+                ExternalSeriesId = seriesTimer.SeriesId,
+                DtoOptions = new DtoOptions(true)
+                {
+                    EnableImages = false
+                },
+                MinEndDate = DateTime.UtcNow
+            };
+
+            if (string.IsNullOrEmpty(seriesTimer.SeriesId))
+            {
+                query.Name = seriesTimer.Name;
+            }
+
+            if (!seriesTimer.RecordAnyChannel)
+            {
+                query.ChannelIds = [_tvDtoService.GetInternalChannelId(Name, seriesTimer.ChannelId)];
+            }
+
+            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
+
+            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().Select(i => CreateTimer(i, seriesTimer, tempChannelCache));
+        }
+
+        private TimerInfo CreateTimer(LiveTvProgram parent, SeriesTimerInfo seriesTimer, Dictionary<Guid, LiveTvChannel> tempChannelCache)
+        {
+            string channelId = seriesTimer.RecordAnyChannel ? null : seriesTimer.ChannelId;
+
+            if (string.IsNullOrWhiteSpace(channelId) && !parent.ChannelId.IsEmpty())
+            {
+                if (!tempChannelCache.TryGetValue(parent.ChannelId, out LiveTvChannel channel))
+                {
+                    channel = _libraryManager.GetItemList(
+                        new InternalItemsQuery
+                        {
+                            IncludeItemTypes = new[] { BaseItemKind.LiveTvChannel },
+                            ItemIds = new[] { parent.ChannelId },
+                            DtoOptions = new DtoOptions()
+                        }).FirstOrDefault() as LiveTvChannel;
+
+                    if (channel is not null && !string.IsNullOrWhiteSpace(channel.ExternalId))
+                    {
+                        tempChannelCache[parent.ChannelId] = channel;
+                    }
+                }
+
+                if (channel is not null || tempChannelCache.TryGetValue(parent.ChannelId, out channel))
+                {
+                    channelId = channel.ExternalId;
+                }
+            }
+
+            var timer = new TimerInfo
+            {
+                ChannelId = channelId,
+                Id = (seriesTimer.Id + parent.ExternalId).GetMD5().ToString("N", CultureInfo.InvariantCulture),
+                StartDate = parent.StartDate,
+                EndDate = parent.EndDate.Value,
+                ProgramId = parent.ExternalId,
+                PrePaddingSeconds = seriesTimer.PrePaddingSeconds,
+                PostPaddingSeconds = seriesTimer.PostPaddingSeconds,
+                IsPostPaddingRequired = seriesTimer.IsPostPaddingRequired,
+                IsPrePaddingRequired = seriesTimer.IsPrePaddingRequired,
+                KeepUntil = seriesTimer.KeepUntil,
+                Priority = seriesTimer.Priority,
+                Name = parent.Name,
+                Overview = parent.Overview,
+                SeriesId = parent.ExternalSeriesId,
+                SeriesTimerId = seriesTimer.Id,
+                ShowId = parent.ShowId
+            };
+
+            CopyProgramInfoToTimerInfo(parent, timer, tempChannelCache);
+
+            return timer;
+        }
+
+        private void CopyProgramInfoToTimerInfo(LiveTvProgram programInfo, TimerInfo timerInfo)
+        {
+            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
+            CopyProgramInfoToTimerInfo(programInfo, timerInfo, tempChannelCache);
+        }
+
+        private void CopyProgramInfoToTimerInfo(LiveTvProgram programInfo, TimerInfo timerInfo, Dictionary<Guid, LiveTvChannel> tempChannelCache)
+        {
+            string channelId = null;
+
+            if (!programInfo.ChannelId.IsEmpty())
+            {
+                if (!tempChannelCache.TryGetValue(programInfo.ChannelId, out LiveTvChannel channel))
+                {
+                    channel = _libraryManager.GetItemList(
+                        new InternalItemsQuery
+                        {
+                            IncludeItemTypes = new[] { BaseItemKind.LiveTvChannel },
+                            ItemIds = new[] { programInfo.ChannelId },
+                            DtoOptions = new DtoOptions()
+                        }).FirstOrDefault() as LiveTvChannel;
+
+                    if (channel is not null && !string.IsNullOrWhiteSpace(channel.ExternalId))
+                    {
+                        tempChannelCache[programInfo.ChannelId] = channel;
+                    }
+                }
+
+                if (channel is not null || tempChannelCache.TryGetValue(programInfo.ChannelId, out channel))
+                {
+                    channelId = channel.ExternalId;
+                }
+            }
+
+            timerInfo.Name = programInfo.Name;
+            timerInfo.StartDate = programInfo.StartDate;
+            timerInfo.EndDate = programInfo.EndDate.Value;
+
+            if (!string.IsNullOrWhiteSpace(channelId))
+            {
+                timerInfo.ChannelId = channelId;
+            }
+
+            timerInfo.SeasonNumber = programInfo.ParentIndexNumber;
+            timerInfo.EpisodeNumber = programInfo.IndexNumber;
+            timerInfo.IsMovie = programInfo.IsMovie;
+            timerInfo.ProductionYear = programInfo.ProductionYear;
+            timerInfo.EpisodeTitle = programInfo.EpisodeTitle;
+            timerInfo.OriginalAirDate = programInfo.PremiereDate;
+            timerInfo.IsProgramSeries = programInfo.IsSeries;
+
+            timerInfo.IsSeries = programInfo.IsSeries;
+
+            timerInfo.CommunityRating = programInfo.CommunityRating;
+            timerInfo.Overview = programInfo.Overview;
+            timerInfo.OfficialRating = programInfo.OfficialRating;
+            timerInfo.IsRepeat = programInfo.IsRepeat;
+            timerInfo.SeriesId = programInfo.ExternalSeriesId;
+            timerInfo.ProviderIds = programInfo.ProviderIds;
+            timerInfo.Tags = programInfo.Tags;
+
+            var seriesProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var providerId in timerInfo.ProviderIds)
+            {
+                const string Search = "Series";
+                if (providerId.Key.StartsWith(Search, StringComparison.OrdinalIgnoreCase))
+                {
+                    seriesProviderIds[providerId.Key.Substring(Search.Length)] = providerId.Value;
+                }
+            }
+
+            timerInfo.SeriesProviderIds = seriesProviderIds;
+        }
+
+        private bool IsProgramAlreadyInLibrary(TimerInfo program)
+        {
+            if ((program.EpisodeNumber.HasValue && program.SeasonNumber.HasValue) || !string.IsNullOrWhiteSpace(program.EpisodeTitle))
+            {
+                var seriesIds = _libraryManager.GetItemIds(
+                    new InternalItemsQuery
+                    {
+                        IncludeItemTypes = new[] { BaseItemKind.Series },
+                        Name = program.Name
+                    }).ToArray();
+
+                if (seriesIds.Length == 0)
+                {
+                    return false;
+                }
+
+                if (program.EpisodeNumber.HasValue && program.SeasonNumber.HasValue)
+                {
+                    var result = _libraryManager.GetItemIds(new InternalItemsQuery
+                    {
+                        IncludeItemTypes = new[] { BaseItemKind.Episode },
+                        ParentIndexNumber = program.SeasonNumber.Value,
+                        IndexNumber = program.EpisodeNumber.Value,
+                        AncestorIds = seriesIds,
+                        IsVirtualItem = false,
+                        Limit = 1
+                    });
+
+                    if (result.Count > 0)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/EmbyTV.cs b/src/Jellyfin.LiveTv/EmbyTV/EmbyTV.cs
deleted file mode 100644
index e7e927b2d..000000000
--- a/src/Jellyfin.LiveTv/EmbyTV/EmbyTV.cs
+++ /dev/null
@@ -1,2537 +0,0 @@
-#nullable disable
-
-#pragma warning disable CS1591
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Net.Http;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Xml;
-using Jellyfin.Data.Enums;
-using Jellyfin.Data.Events;
-using Jellyfin.Extensions;
-using Jellyfin.LiveTv.Configuration;
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Common.Extensions;
-using MediaBrowser.Common.Progress;
-using MediaBrowser.Controller.Configuration;
-using MediaBrowser.Controller.Dto;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Entities.TV;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Controller.MediaEncoding;
-using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.Configuration;
-using MediaBrowser.Model.Dto;
-using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.LiveTv;
-using MediaBrowser.Model.MediaInfo;
-using MediaBrowser.Model.Providers;
-using Microsoft.Extensions.Logging;
-
-namespace Jellyfin.LiveTv.EmbyTV
-{
-    public sealed class EmbyTV : ILiveTvService, ISupportsDirectStreamProvider, ISupportsNewTimerIds, IDisposable
-    {
-        public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
-
-        private readonly ILogger<EmbyTV> _logger;
-        private readonly IHttpClientFactory _httpClientFactory;
-        private readonly IServerConfigurationManager _config;
-
-        private readonly ItemDataProvider<SeriesTimerInfo> _seriesTimerProvider;
-        private readonly TimerManager _timerProvider;
-
-        private readonly LiveTvManager _liveTvManager;
-        private readonly ITunerHostManager _tunerHostManager;
-        private readonly IFileSystem _fileSystem;
-
-        private readonly ILibraryMonitor _libraryMonitor;
-        private readonly ILibraryManager _libraryManager;
-        private readonly IProviderManager _providerManager;
-        private readonly IMediaEncoder _mediaEncoder;
-        private readonly IMediaSourceManager _mediaSourceManager;
-        private readonly IStreamHelper _streamHelper;
-
-        private readonly ConcurrentDictionary<string, ActiveRecordingInfo> _activeRecordings =
-            new ConcurrentDictionary<string, ActiveRecordingInfo>(StringComparer.OrdinalIgnoreCase);
-
-        private readonly ConcurrentDictionary<string, EpgChannelData> _epgChannels =
-            new ConcurrentDictionary<string, EpgChannelData>(StringComparer.OrdinalIgnoreCase);
-
-        private readonly SemaphoreSlim _recordingDeleteSemaphore = new SemaphoreSlim(1, 1);
-
-        private bool _disposed;
-
-        public EmbyTV(
-            IStreamHelper streamHelper,
-            IMediaSourceManager mediaSourceManager,
-            ILogger<EmbyTV> logger,
-            IHttpClientFactory httpClientFactory,
-            IServerConfigurationManager config,
-            ILiveTvManager liveTvManager,
-            ITunerHostManager tunerHostManager,
-            IFileSystem fileSystem,
-            ILibraryManager libraryManager,
-            ILibraryMonitor libraryMonitor,
-            IProviderManager providerManager,
-            IMediaEncoder mediaEncoder)
-        {
-            Current = this;
-
-            _logger = logger;
-            _httpClientFactory = httpClientFactory;
-            _config = config;
-            _fileSystem = fileSystem;
-            _libraryManager = libraryManager;
-            _libraryMonitor = libraryMonitor;
-            _providerManager = providerManager;
-            _mediaEncoder = mediaEncoder;
-            _liveTvManager = (LiveTvManager)liveTvManager;
-            _tunerHostManager = tunerHostManager;
-            _mediaSourceManager = mediaSourceManager;
-            _streamHelper = streamHelper;
-
-            _seriesTimerProvider = new SeriesTimerManager(_logger, Path.Combine(DataPath, "seriestimers.json"));
-            _timerProvider = new TimerManager(_logger, Path.Combine(DataPath, "timers.json"));
-            _timerProvider.TimerFired += OnTimerProviderTimerFired;
-
-            _config.NamedConfigurationUpdated += OnNamedConfigurationUpdated;
-        }
-
-        public event EventHandler<GenericEventArgs<TimerInfo>> TimerCreated;
-
-        public event EventHandler<GenericEventArgs<string>> TimerCancelled;
-
-        public static EmbyTV Current { get; private set; }
-
-        /// <inheritdoc />
-        public string Name => "Emby";
-
-        public string DataPath => Path.Combine(_config.CommonApplicationPaths.DataPath, "livetv");
-
-        /// <inheritdoc />
-        public string HomePageUrl => "https://github.com/jellyfin/jellyfin";
-
-        private string DefaultRecordingPath => Path.Combine(DataPath, "recordings");
-
-        private string RecordingPath
-        {
-            get
-            {
-                var path = _config.GetLiveTvConfiguration().RecordingPath;
-
-                return string.IsNullOrWhiteSpace(path)
-                    ? DefaultRecordingPath
-                    : path;
-            }
-        }
-
-        private async void OnNamedConfigurationUpdated(object sender, ConfigurationUpdateEventArgs e)
-        {
-            if (string.Equals(e.Key, "livetv", StringComparison.OrdinalIgnoreCase))
-            {
-                await CreateRecordingFolders().ConfigureAwait(false);
-            }
-        }
-
-        public Task Start()
-        {
-            _timerProvider.RestartTimers();
-
-            return CreateRecordingFolders();
-        }
-
-        internal async Task CreateRecordingFolders()
-        {
-            try
-            {
-                var recordingFolders = GetRecordingFolders().ToArray();
-                var virtualFolders = _libraryManager.GetVirtualFolders();
-
-                var allExistingPaths = virtualFolders.SelectMany(i => i.Locations).ToList();
-
-                var pathsAdded = new List<string>();
-
-                foreach (var recordingFolder in recordingFolders)
-                {
-                    var pathsToCreate = recordingFolder.Locations
-                        .Where(i => !allExistingPaths.Any(p => _fileSystem.AreEqual(p, i)))
-                        .ToList();
-
-                    if (pathsToCreate.Count == 0)
-                    {
-                        continue;
-                    }
-
-                    var mediaPathInfos = pathsToCreate.Select(i => new MediaPathInfo(i)).ToArray();
-
-                    var libraryOptions = new LibraryOptions
-                    {
-                        PathInfos = mediaPathInfos
-                    };
-                    try
-                    {
-                        await _libraryManager.AddVirtualFolder(recordingFolder.Name, recordingFolder.CollectionType, libraryOptions, true).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error creating virtual folder");
-                    }
-
-                    pathsAdded.AddRange(pathsToCreate);
-                }
-
-                var config = _config.GetLiveTvConfiguration();
-
-                var pathsToRemove = config.MediaLocationsCreated
-                    .Except(recordingFolders.SelectMany(i => i.Locations))
-                    .ToList();
-
-                if (pathsAdded.Count > 0 || pathsToRemove.Count > 0)
-                {
-                    pathsAdded.InsertRange(0, config.MediaLocationsCreated);
-                    config.MediaLocationsCreated = pathsAdded.Except(pathsToRemove).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
-                    _config.SaveConfiguration("livetv", config);
-                }
-
-                foreach (var path in pathsToRemove)
-                {
-                    await RemovePathFromLibraryAsync(path).ConfigureAwait(false);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error creating recording folders");
-            }
-        }
-
-        private async Task RemovePathFromLibraryAsync(string path)
-        {
-            _logger.LogDebug("Removing path from library: {0}", path);
-
-            var requiresRefresh = false;
-            var virtualFolders = _libraryManager.GetVirtualFolders();
-
-            foreach (var virtualFolder in virtualFolders)
-            {
-                if (!virtualFolder.Locations.Contains(path, StringComparison.OrdinalIgnoreCase))
-                {
-                    continue;
-                }
-
-                if (virtualFolder.Locations.Length == 1)
-                {
-                    // remove entire virtual folder
-                    try
-                    {
-                        await _libraryManager.RemoveVirtualFolder(virtualFolder.Name, true).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error removing virtual folder");
-                    }
-                }
-                else
-                {
-                    try
-                    {
-                        _libraryManager.RemoveMediaPath(virtualFolder.Name, path);
-                        requiresRefresh = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error removing media path");
-                    }
-                }
-            }
-
-            if (requiresRefresh)
-            {
-                await _libraryManager.ValidateMediaLibrary(new SimpleProgress<double>(), CancellationToken.None).ConfigureAwait(false);
-            }
-        }
-
-        public async Task RefreshSeriesTimers(CancellationToken cancellationToken)
-        {
-            var seriesTimers = await GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
-
-            foreach (var timer in seriesTimers)
-            {
-                UpdateTimersForSeriesTimer(timer, false, true);
-            }
-        }
-
-        public async Task RefreshTimers(CancellationToken cancellationToken)
-        {
-            var timers = await GetTimersAsync(cancellationToken).ConfigureAwait(false);
-
-            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
-
-            foreach (var timer in timers)
-            {
-                if (DateTime.UtcNow > timer.EndDate && !_activeRecordings.ContainsKey(timer.Id))
-                {
-                    OnTimerOutOfDate(timer);
-                    continue;
-                }
-
-                if (string.IsNullOrWhiteSpace(timer.ProgramId) || string.IsNullOrWhiteSpace(timer.ChannelId))
-                {
-                    continue;
-                }
-
-                var program = GetProgramInfoFromCache(timer);
-                if (program is null)
-                {
-                    OnTimerOutOfDate(timer);
-                    continue;
-                }
-
-                CopyProgramInfoToTimerInfo(program, timer, tempChannelCache);
-                _timerProvider.Update(timer);
-            }
-        }
-
-        private void OnTimerOutOfDate(TimerInfo timer)
-        {
-            _timerProvider.Delete(timer);
-        }
-
-        private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
-        {
-            var list = new List<ChannelInfo>();
-
-            foreach (var hostInstance in _tunerHostManager.TunerHosts)
-            {
-                try
-                {
-                    var channels = await hostInstance.GetChannels(enableCache, cancellationToken).ConfigureAwait(false);
-
-                    list.AddRange(channels);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting channels");
-                }
-            }
-
-            foreach (var provider in GetListingProviders())
-            {
-                var enabledChannels = list
-                    .Where(i => IsListingProviderEnabledForTuner(provider.Item2, i.TunerHostId))
-                    .ToList();
-
-                if (enabledChannels.Count > 0)
-                {
-                    try
-                    {
-                        await AddMetadata(provider.Item1, provider.Item2, enabledChannels, enableCache, cancellationToken).ConfigureAwait(false);
-                    }
-                    catch (NotSupportedException)
-                    {
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error adding metadata");
-                    }
-                }
-            }
-
-            return list;
-        }
-
-        private async Task AddMetadata(
-            IListingsProvider provider,
-            ListingsProviderInfo info,
-            IEnumerable<ChannelInfo> tunerChannels,
-            bool enableCache,
-            CancellationToken cancellationToken)
-        {
-            var epgChannels = await GetEpgChannels(provider, info, enableCache, cancellationToken).ConfigureAwait(false);
-
-            foreach (var tunerChannel in tunerChannels)
-            {
-                var epgChannel = GetEpgChannelFromTunerChannel(info, tunerChannel, epgChannels);
-
-                if (epgChannel is not null)
-                {
-                    if (!string.IsNullOrWhiteSpace(epgChannel.Name))
-                    {
-                        // tunerChannel.Name = epgChannel.Name;
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(epgChannel.ImageUrl))
-                    {
-                        tunerChannel.ImageUrl = epgChannel.ImageUrl;
-                    }
-                }
-            }
-        }
-
-        private async Task<EpgChannelData> GetEpgChannels(
-            IListingsProvider provider,
-            ListingsProviderInfo info,
-            bool enableCache,
-            CancellationToken cancellationToken)
-        {
-            if (!enableCache || !_epgChannels.TryGetValue(info.Id, out var result))
-            {
-                var channels = await provider.GetChannels(info, cancellationToken).ConfigureAwait(false);
-
-                foreach (var channel in channels)
-                {
-                    _logger.LogInformation("Found epg channel in {0} {1} {2} {3}", provider.Name, info.ListingsId, channel.Name, channel.Id);
-                }
-
-                result = new EpgChannelData(channels);
-                _epgChannels.AddOrUpdate(info.Id, result, (_, _) => result);
-            }
-
-            return result;
-        }
-
-        private async Task<ChannelInfo> GetEpgChannelFromTunerChannel(IListingsProvider provider, ListingsProviderInfo info, ChannelInfo tunerChannel, CancellationToken cancellationToken)
-        {
-            var epgChannels = await GetEpgChannels(provider, info, true, cancellationToken).ConfigureAwait(false);
-
-            return GetEpgChannelFromTunerChannel(info, tunerChannel, epgChannels);
-        }
-
-        private static string GetMappedChannel(string channelId, NameValuePair[] mappings)
-        {
-            foreach (NameValuePair mapping in mappings)
-            {
-                if (string.Equals(mapping.Name, channelId, StringComparison.OrdinalIgnoreCase))
-                {
-                    return mapping.Value;
-                }
-            }
-
-            return channelId;
-        }
-
-        internal ChannelInfo GetEpgChannelFromTunerChannel(NameValuePair[] mappings, ChannelInfo tunerChannel, List<ChannelInfo> epgChannels)
-        {
-            return GetEpgChannelFromTunerChannel(mappings, tunerChannel, new EpgChannelData(epgChannels));
-        }
-
-        private ChannelInfo GetEpgChannelFromTunerChannel(ListingsProviderInfo info, ChannelInfo tunerChannel, EpgChannelData epgChannels)
-        {
-            return GetEpgChannelFromTunerChannel(info.ChannelMappings, tunerChannel, epgChannels);
-        }
-
-        private ChannelInfo GetEpgChannelFromTunerChannel(
-            NameValuePair[] mappings,
-            ChannelInfo tunerChannel,
-            EpgChannelData epgChannelData)
-        {
-            if (!string.IsNullOrWhiteSpace(tunerChannel.Id))
-            {
-                var mappedTunerChannelId = GetMappedChannel(tunerChannel.Id, mappings);
-
-                if (string.IsNullOrWhiteSpace(mappedTunerChannelId))
-                {
-                    mappedTunerChannelId = tunerChannel.Id;
-                }
-
-                var channel = epgChannelData.GetChannelById(mappedTunerChannelId);
-
-                if (channel is not null)
-                {
-                    return channel;
-                }
-            }
-
-            if (!string.IsNullOrWhiteSpace(tunerChannel.TunerChannelId))
-            {
-                var tunerChannelId = tunerChannel.TunerChannelId;
-                if (tunerChannelId.Contains(".json.schedulesdirect.org", StringComparison.OrdinalIgnoreCase))
-                {
-                    tunerChannelId = tunerChannelId.Replace(".json.schedulesdirect.org", string.Empty, StringComparison.OrdinalIgnoreCase).TrimStart('I');
-                }
-
-                var mappedTunerChannelId = GetMappedChannel(tunerChannelId, mappings);
-
-                if (string.IsNullOrWhiteSpace(mappedTunerChannelId))
-                {
-                    mappedTunerChannelId = tunerChannelId;
-                }
-
-                var channel = epgChannelData.GetChannelById(mappedTunerChannelId);
-
-                if (channel is not null)
-                {
-                    return channel;
-                }
-            }
-
-            if (!string.IsNullOrWhiteSpace(tunerChannel.Number))
-            {
-                var tunerChannelNumber = GetMappedChannel(tunerChannel.Number, mappings);
-
-                if (string.IsNullOrWhiteSpace(tunerChannelNumber))
-                {
-                    tunerChannelNumber = tunerChannel.Number;
-                }
-
-                var channel = epgChannelData.GetChannelByNumber(tunerChannelNumber);
-
-                if (channel is not null)
-                {
-                    return channel;
-                }
-            }
-
-            if (!string.IsNullOrWhiteSpace(tunerChannel.Name))
-            {
-                var normalizedName = EpgChannelData.NormalizeName(tunerChannel.Name);
-
-                var channel = epgChannelData.GetChannelByName(normalizedName);
-
-                if (channel is not null)
-                {
-                    return channel;
-                }
-            }
-
-            return null;
-        }
-
-        public async Task<List<ChannelInfo>> GetChannelsForListingsProvider(ListingsProviderInfo listingsProvider, CancellationToken cancellationToken)
-        {
-            var list = new List<ChannelInfo>();
-
-            foreach (var hostInstance in _tunerHostManager.TunerHosts)
-            {
-                try
-                {
-                    var channels = await hostInstance.GetChannels(false, cancellationToken).ConfigureAwait(false);
-
-                    list.AddRange(channels);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting channels");
-                }
-            }
-
-            return list
-                .Where(i => IsListingProviderEnabledForTuner(listingsProvider, i.TunerHostId))
-                .ToList();
-        }
-
-        public Task<IEnumerable<ChannelInfo>> GetChannelsAsync(CancellationToken cancellationToken)
-        {
-            return GetChannelsAsync(false, cancellationToken);
-        }
-
-        public Task CancelSeriesTimerAsync(string timerId, CancellationToken cancellationToken)
-        {
-            var timers = _timerProvider
-                .GetAll()
-                .Where(i => string.Equals(i.SeriesTimerId, timerId, StringComparison.OrdinalIgnoreCase))
-                .ToList();
-
-            foreach (var timer in timers)
-            {
-                CancelTimerInternal(timer.Id, true, true);
-            }
-
-            var remove = _seriesTimerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
-            if (remove is not null)
-            {
-                _seriesTimerProvider.Delete(remove);
-            }
-
-            return Task.CompletedTask;
-        }
-
-        private void CancelTimerInternal(string timerId, bool isSeriesCancelled, bool isManualCancellation)
-        {
-            var timer = _timerProvider.GetTimer(timerId);
-            if (timer is not null)
-            {
-                var statusChanging = timer.Status != RecordingStatus.Cancelled;
-                timer.Status = RecordingStatus.Cancelled;
-
-                if (isManualCancellation)
-                {
-                    timer.IsManual = true;
-                }
-
-                if (string.IsNullOrWhiteSpace(timer.SeriesTimerId) || isSeriesCancelled)
-                {
-                    _timerProvider.Delete(timer);
-                }
-                else
-                {
-                    _timerProvider.AddOrUpdate(timer, false);
-                }
-
-                if (statusChanging && TimerCancelled is not null)
-                {
-                    TimerCancelled(this, new GenericEventArgs<string>(timerId));
-                }
-            }
-
-            if (_activeRecordings.TryGetValue(timerId, out var activeRecordingInfo))
-            {
-                activeRecordingInfo.Timer = timer;
-                activeRecordingInfo.CancellationTokenSource.Cancel();
-            }
-        }
-
-        public Task CancelTimerAsync(string timerId, CancellationToken cancellationToken)
-        {
-            CancelTimerInternal(timerId, false, true);
-            return Task.CompletedTask;
-        }
-
-        public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<string> CreateTimer(TimerInfo info, CancellationToken cancellationToken)
-        {
-            var existingTimer = string.IsNullOrWhiteSpace(info.ProgramId) ?
-                null :
-                _timerProvider.GetTimerByProgramId(info.ProgramId);
-
-            if (existingTimer is not null)
-            {
-                if (existingTimer.Status == RecordingStatus.Cancelled
-                    || existingTimer.Status == RecordingStatus.Completed)
-                {
-                    existingTimer.Status = RecordingStatus.New;
-                    existingTimer.IsManual = true;
-                    _timerProvider.Update(existingTimer);
-                    return Task.FromResult(existingTimer.Id);
-                }
-
-                throw new ArgumentException("A scheduled recording already exists for this program.");
-            }
-
-            info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
-
-            LiveTvProgram programInfo = null;
-
-            if (!string.IsNullOrWhiteSpace(info.ProgramId))
-            {
-                programInfo = GetProgramInfoFromCache(info);
-            }
-
-            if (programInfo is null)
-            {
-                _logger.LogInformation("Unable to find program with Id {0}. Will search using start date", info.ProgramId);
-                programInfo = GetProgramInfoFromCache(info.ChannelId, info.StartDate);
-            }
-
-            if (programInfo is not null)
-            {
-                CopyProgramInfoToTimerInfo(programInfo, info);
-            }
-
-            info.IsManual = true;
-            _timerProvider.Add(info);
-
-            TimerCreated?.Invoke(this, new GenericEventArgs<TimerInfo>(info));
-
-            return Task.FromResult(info.Id);
-        }
-
-        public async Task<string> CreateSeriesTimer(SeriesTimerInfo info, CancellationToken cancellationToken)
-        {
-            info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
-
-            // populate info.seriesID
-            var program = GetProgramInfoFromCache(info.ProgramId);
-
-            if (program is not null)
-            {
-                info.SeriesId = program.ExternalSeriesId;
-            }
-            else
-            {
-                throw new InvalidOperationException("SeriesId for program not found");
-            }
-
-            // If any timers have already been manually created, make sure they don't get cancelled
-            var existingTimers = (await GetTimersAsync(CancellationToken.None).ConfigureAwait(false))
-                .Where(i =>
-                {
-                    if (string.Equals(i.ProgramId, info.ProgramId, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(info.ProgramId))
-                    {
-                        return true;
-                    }
-
-                    if (string.Equals(i.SeriesId, info.SeriesId, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(info.SeriesId))
-                    {
-                        return true;
-                    }
-
-                    return false;
-                })
-                .ToList();
-
-            _seriesTimerProvider.Add(info);
-
-            foreach (var timer in existingTimers)
-            {
-                timer.SeriesTimerId = info.Id;
-                timer.IsManual = true;
-
-                _timerProvider.AddOrUpdate(timer, false);
-            }
-
-            UpdateTimersForSeriesTimer(info, true, false);
-
-            return info.Id;
-        }
-
-        public Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
-        {
-            var instance = _seriesTimerProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
-
-            if (instance is not null)
-            {
-                instance.ChannelId = info.ChannelId;
-                instance.Days = info.Days;
-                instance.EndDate = info.EndDate;
-                instance.IsPostPaddingRequired = info.IsPostPaddingRequired;
-                instance.IsPrePaddingRequired = info.IsPrePaddingRequired;
-                instance.PostPaddingSeconds = info.PostPaddingSeconds;
-                instance.PrePaddingSeconds = info.PrePaddingSeconds;
-                instance.Priority = info.Priority;
-                instance.RecordAnyChannel = info.RecordAnyChannel;
-                instance.RecordAnyTime = info.RecordAnyTime;
-                instance.RecordNewOnly = info.RecordNewOnly;
-                instance.SkipEpisodesInLibrary = info.SkipEpisodesInLibrary;
-                instance.KeepUpTo = info.KeepUpTo;
-                instance.KeepUntil = info.KeepUntil;
-                instance.StartDate = info.StartDate;
-
-                _seriesTimerProvider.Update(instance);
-
-                UpdateTimersForSeriesTimer(instance, true, true);
-            }
-
-            return Task.CompletedTask;
-        }
-
-        public Task UpdateTimerAsync(TimerInfo updatedTimer, CancellationToken cancellationToken)
-        {
-            var existingTimer = _timerProvider.GetTimer(updatedTimer.Id);
-
-            if (existingTimer is null)
-            {
-                throw new ResourceNotFoundException();
-            }
-
-            // Only update if not currently active
-            if (!_activeRecordings.TryGetValue(updatedTimer.Id, out _))
-            {
-                existingTimer.PrePaddingSeconds = updatedTimer.PrePaddingSeconds;
-                existingTimer.PostPaddingSeconds = updatedTimer.PostPaddingSeconds;
-                existingTimer.IsPostPaddingRequired = updatedTimer.IsPostPaddingRequired;
-                existingTimer.IsPrePaddingRequired = updatedTimer.IsPrePaddingRequired;
-
-                _timerProvider.Update(existingTimer);
-            }
-
-            return Task.CompletedTask;
-        }
-
-        private static void UpdateExistingTimerWithNewMetadata(TimerInfo existingTimer, TimerInfo updatedTimer)
-        {
-            // Update the program info but retain the status
-            existingTimer.ChannelId = updatedTimer.ChannelId;
-            existingTimer.CommunityRating = updatedTimer.CommunityRating;
-            existingTimer.EndDate = updatedTimer.EndDate;
-            existingTimer.EpisodeNumber = updatedTimer.EpisodeNumber;
-            existingTimer.EpisodeTitle = updatedTimer.EpisodeTitle;
-            existingTimer.Genres = updatedTimer.Genres;
-            existingTimer.IsMovie = updatedTimer.IsMovie;
-            existingTimer.IsSeries = updatedTimer.IsSeries;
-            existingTimer.Tags = updatedTimer.Tags;
-            existingTimer.IsProgramSeries = updatedTimer.IsProgramSeries;
-            existingTimer.IsRepeat = updatedTimer.IsRepeat;
-            existingTimer.Name = updatedTimer.Name;
-            existingTimer.OfficialRating = updatedTimer.OfficialRating;
-            existingTimer.OriginalAirDate = updatedTimer.OriginalAirDate;
-            existingTimer.Overview = updatedTimer.Overview;
-            existingTimer.ProductionYear = updatedTimer.ProductionYear;
-            existingTimer.ProgramId = updatedTimer.ProgramId;
-            existingTimer.SeasonNumber = updatedTimer.SeasonNumber;
-            existingTimer.StartDate = updatedTimer.StartDate;
-            existingTimer.ShowId = updatedTimer.ShowId;
-            existingTimer.ProviderIds = updatedTimer.ProviderIds;
-            existingTimer.SeriesProviderIds = updatedTimer.SeriesProviderIds;
-        }
-
-        public string GetActiveRecordingPath(string id)
-        {
-            if (_activeRecordings.TryGetValue(id, out var info))
-            {
-                return info.Path;
-            }
-
-            return null;
-        }
-
-        public ActiveRecordingInfo GetActiveRecordingInfo(string path)
-        {
-            if (string.IsNullOrWhiteSpace(path) || _activeRecordings.IsEmpty)
-            {
-                return null;
-            }
-
-            foreach (var (_, recordingInfo) in _activeRecordings)
-            {
-                if (string.Equals(recordingInfo.Path, path, StringComparison.Ordinal) && !recordingInfo.CancellationTokenSource.IsCancellationRequested)
-                {
-                    var timer = recordingInfo.Timer;
-                    if (timer.Status != RecordingStatus.InProgress)
-                    {
-                        return null;
-                    }
-
-                    return recordingInfo;
-                }
-            }
-
-            return null;
-        }
-
-        public Task<IEnumerable<TimerInfo>> GetTimersAsync(CancellationToken cancellationToken)
-        {
-            var excludeStatues = new List<RecordingStatus>
-            {
-                RecordingStatus.Completed
-            };
-
-            var timers = _timerProvider.GetAll()
-                .Where(i => !excludeStatues.Contains(i.Status));
-
-            return Task.FromResult(timers);
-        }
-
-        public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null)
-        {
-            var config = _config.GetLiveTvConfiguration();
-
-            var defaults = new SeriesTimerInfo()
-            {
-                PostPaddingSeconds = Math.Max(config.PostPaddingSeconds, 0),
-                PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0),
-                RecordAnyChannel = false,
-                RecordAnyTime = true,
-                RecordNewOnly = true,
-
-                Days = new List<DayOfWeek>
-                {
-                    DayOfWeek.Sunday,
-                    DayOfWeek.Monday,
-                    DayOfWeek.Tuesday,
-                    DayOfWeek.Wednesday,
-                    DayOfWeek.Thursday,
-                    DayOfWeek.Friday,
-                    DayOfWeek.Saturday
-                }
-            };
-
-            if (program is not null)
-            {
-                defaults.SeriesId = program.SeriesId;
-                defaults.ProgramId = program.Id;
-                defaults.RecordNewOnly = !program.IsRepeat;
-                defaults.Name = program.Name;
-            }
-
-            defaults.SkipEpisodesInLibrary = defaults.RecordNewOnly;
-            defaults.KeepUntil = KeepUntil.UntilDeleted;
-
-            return Task.FromResult(defaults);
-        }
-
-        public Task<IEnumerable<SeriesTimerInfo>> GetSeriesTimersAsync(CancellationToken cancellationToken)
-        {
-            return Task.FromResult((IEnumerable<SeriesTimerInfo>)_seriesTimerProvider.GetAll());
-        }
-
-        private bool IsListingProviderEnabledForTuner(ListingsProviderInfo info, string tunerHostId)
-        {
-            if (info.EnableAllTuners)
-            {
-                return true;
-            }
-
-            if (string.IsNullOrWhiteSpace(tunerHostId))
-            {
-                throw new ArgumentNullException(nameof(tunerHostId));
-            }
-
-            return info.EnabledTuners.Contains(tunerHostId, StringComparison.OrdinalIgnoreCase);
-        }
-
-        public async Task<IEnumerable<ProgramInfo>> GetProgramsAsync(string channelId, DateTime startDateUtc, DateTime endDateUtc, CancellationToken cancellationToken)
-        {
-            var channels = await GetChannelsAsync(true, cancellationToken).ConfigureAwait(false);
-            var channel = channels.First(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase));
-
-            foreach (var provider in GetListingProviders())
-            {
-                if (!IsListingProviderEnabledForTuner(provider.Item2, channel.TunerHostId))
-                {
-                    _logger.LogDebug("Skipping getting programs for channel {0}-{1} from {2}-{3}, because it's not enabled for this tuner.", channel.Number, channel.Name, provider.Item1.Name, provider.Item2.ListingsId ?? string.Empty);
-                    continue;
-                }
-
-                _logger.LogDebug("Getting programs for channel {0}-{1} from {2}-{3}", channel.Number, channel.Name, provider.Item1.Name, provider.Item2.ListingsId ?? string.Empty);
-
-                var epgChannel = await GetEpgChannelFromTunerChannel(provider.Item1, provider.Item2, channel, cancellationToken).ConfigureAwait(false);
-
-                if (epgChannel is null)
-                {
-                    _logger.LogDebug("EPG channel not found for tuner channel {0}-{1} from {2}-{3}", channel.Number, channel.Name, provider.Item1.Name, provider.Item2.ListingsId ?? string.Empty);
-                    continue;
-                }
-
-                List<ProgramInfo> programs = (await provider.Item1.GetProgramsAsync(provider.Item2, epgChannel.Id, startDateUtc, endDateUtc, cancellationToken)
-                           .ConfigureAwait(false)).ToList();
-
-                // Replace the value that came from the provider with a normalized value
-                foreach (var program in programs)
-                {
-                    program.ChannelId = channelId;
-
-                    program.Id += "_" + channelId;
-                }
-
-                if (programs.Count > 0)
-                {
-                    return programs;
-                }
-            }
-
-            return Enumerable.Empty<ProgramInfo>();
-        }
-
-        private List<Tuple<IListingsProvider, ListingsProviderInfo>> GetListingProviders()
-        {
-            return _config.GetLiveTvConfiguration().ListingProviders
-                .Select(i =>
-                {
-                    var provider = _liveTvManager.ListingProviders.FirstOrDefault(l => string.Equals(l.Type, i.Type, StringComparison.OrdinalIgnoreCase));
-
-                    return provider is null ? null : new Tuple<IListingsProvider, ListingsProviderInfo>(provider, i);
-                })
-                .Where(i => i is not null)
-                .ToList();
-        }
-
-        public Task<MediaSourceInfo> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
-        {
-            throw new NotImplementedException();
-        }
-
-        public async Task<ILiveStream> GetChannelStreamWithDirectStreamProvider(string channelId, string streamId, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
-        {
-            _logger.LogInformation("Streaming Channel {Id}", channelId);
-
-            var result = string.IsNullOrEmpty(streamId) ?
-                null :
-                currentLiveStreams.FirstOrDefault(i => string.Equals(i.OriginalStreamId, streamId, StringComparison.OrdinalIgnoreCase));
-
-            if (result is not null && result.EnableStreamSharing)
-            {
-                result.ConsumerCount++;
-
-                _logger.LogInformation("Live stream {0} consumer count is now {1}", streamId, result.ConsumerCount);
-
-                return result;
-            }
-
-            foreach (var hostInstance in _tunerHostManager.TunerHosts)
-            {
-                try
-                {
-                    result = await hostInstance.GetChannelStream(channelId, streamId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
-
-                    var openedMediaSource = result.MediaSource;
-
-                    result.OriginalStreamId = streamId;
-
-                    _logger.LogInformation("Returning mediasource streamId {0}, mediaSource.Id {1}, mediaSource.LiveStreamId {2}", streamId, openedMediaSource.Id, openedMediaSource.LiveStreamId);
-
-                    return result;
-                }
-                catch (FileNotFoundException)
-                {
-                }
-                catch (OperationCanceledException)
-                {
-                }
-            }
-
-            throw new ResourceNotFoundException("Tuner not found.");
-        }
-
-        public async Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(string channelId, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrWhiteSpace(channelId))
-            {
-                throw new ArgumentNullException(nameof(channelId));
-            }
-
-            foreach (var hostInstance in _tunerHostManager.TunerHosts)
-            {
-                try
-                {
-                    var sources = await hostInstance.GetChannelStreamMediaSources(channelId, cancellationToken).ConfigureAwait(false);
-
-                    if (sources.Count > 0)
-                    {
-                        return sources;
-                    }
-                }
-                catch (NotImplementedException)
-                {
-                }
-            }
-
-            throw new NotImplementedException();
-        }
-
-        public Task CloseLiveStream(string id, CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task ResetTuner(string id, CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        private async void OnTimerProviderTimerFired(object sender, GenericEventArgs<TimerInfo> e)
-        {
-            var timer = e.Argument;
-
-            _logger.LogInformation("Recording timer fired for {0}.", timer.Name);
-
-            try
-            {
-                var recordingEndDate = timer.EndDate.AddSeconds(timer.PostPaddingSeconds);
-
-                if (recordingEndDate <= DateTime.UtcNow)
-                {
-                    _logger.LogWarning("Recording timer fired for updatedTimer {0}, Id: {1}, but the program has already ended.", timer.Name, timer.Id);
-                    OnTimerOutOfDate(timer);
-                    return;
-                }
-
-                var activeRecordingInfo = new ActiveRecordingInfo
-                {
-                    CancellationTokenSource = new CancellationTokenSource(),
-                    Timer = timer,
-                    Id = timer.Id
-                };
-
-                if (!_activeRecordings.ContainsKey(timer.Id))
-                {
-                    await RecordStream(timer, recordingEndDate, activeRecordingInfo).ConfigureAwait(false);
-                }
-                else
-                {
-                    _logger.LogInformation("Skipping RecordStream because it's already in progress.");
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error recording stream");
-            }
-        }
-
-        private string GetRecordingPath(TimerInfo timer, RemoteSearchResult metadata, out string seriesPath)
-        {
-            var recordPath = RecordingPath;
-            var config = _config.GetLiveTvConfiguration();
-            seriesPath = null;
-
-            if (timer.IsProgramSeries)
-            {
-                var customRecordingPath = config.SeriesRecordingPath;
-                var allowSubfolder = true;
-                if (!string.IsNullOrWhiteSpace(customRecordingPath))
-                {
-                    allowSubfolder = string.Equals(customRecordingPath, recordPath, StringComparison.OrdinalIgnoreCase);
-                    recordPath = customRecordingPath;
-                }
-
-                if (allowSubfolder && config.EnableRecordingSubfolders)
-                {
-                    recordPath = Path.Combine(recordPath, "Series");
-                }
-
-                // trim trailing period from the folder name
-                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim().TrimEnd('.').Trim();
-
-                if (metadata is not null && metadata.ProductionYear.HasValue)
-                {
-                    folderName += " (" + metadata.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
-                }
-
-                // Can't use the year here in the folder name because it is the year of the episode, not the series.
-                recordPath = Path.Combine(recordPath, folderName);
-
-                seriesPath = recordPath;
-
-                if (timer.SeasonNumber.HasValue)
-                {
-                    folderName = string.Format(
-                        CultureInfo.InvariantCulture,
-                        "Season {0}",
-                        timer.SeasonNumber.Value);
-                    recordPath = Path.Combine(recordPath, folderName);
-                }
-            }
-            else if (timer.IsMovie)
-            {
-                var customRecordingPath = config.MovieRecordingPath;
-                var allowSubfolder = true;
-                if (!string.IsNullOrWhiteSpace(customRecordingPath))
-                {
-                    allowSubfolder = string.Equals(customRecordingPath, recordPath, StringComparison.OrdinalIgnoreCase);
-                    recordPath = customRecordingPath;
-                }
-
-                if (allowSubfolder && config.EnableRecordingSubfolders)
-                {
-                    recordPath = Path.Combine(recordPath, "Movies");
-                }
-
-                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
-                if (timer.ProductionYear.HasValue)
-                {
-                    folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
-                }
-
-                // trim trailing period from the folder name
-                folderName = folderName.TrimEnd('.').Trim();
-
-                recordPath = Path.Combine(recordPath, folderName);
-            }
-            else if (timer.IsKids)
-            {
-                if (config.EnableRecordingSubfolders)
-                {
-                    recordPath = Path.Combine(recordPath, "Kids");
-                }
-
-                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
-                if (timer.ProductionYear.HasValue)
-                {
-                    folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
-                }
-
-                // trim trailing period from the folder name
-                folderName = folderName.TrimEnd('.').Trim();
-
-                recordPath = Path.Combine(recordPath, folderName);
-            }
-            else if (timer.IsSports)
-            {
-                if (config.EnableRecordingSubfolders)
-                {
-                    recordPath = Path.Combine(recordPath, "Sports");
-                }
-
-                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(timer.Name).Trim());
-            }
-            else
-            {
-                if (config.EnableRecordingSubfolders)
-                {
-                    recordPath = Path.Combine(recordPath, "Other");
-                }
-
-                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(timer.Name).Trim());
-            }
-
-            var recordingFileName = _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer)).Trim() + ".ts";
-
-            return Path.Combine(recordPath, recordingFileName);
-        }
-
-        private async Task RecordStream(TimerInfo timer, DateTime recordingEndDate, ActiveRecordingInfo activeRecordingInfo)
-        {
-            ArgumentNullException.ThrowIfNull(timer);
-
-            LiveTvProgram programInfo = null;
-
-            if (!string.IsNullOrWhiteSpace(timer.ProgramId))
-            {
-                programInfo = GetProgramInfoFromCache(timer);
-            }
-
-            if (programInfo is null)
-            {
-                _logger.LogInformation("Unable to find program with Id {0}. Will search using start date", timer.ProgramId);
-                programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.StartDate);
-            }
-
-            if (programInfo is not null)
-            {
-                CopyProgramInfoToTimerInfo(programInfo, timer);
-            }
-
-            var remoteMetadata = await FetchInternetMetadata(timer, CancellationToken.None).ConfigureAwait(false);
-            var recordPath = GetRecordingPath(timer, remoteMetadata, out string seriesPath);
-
-            var channelItem = _liveTvManager.GetLiveTvChannel(timer, this);
-
-            string liveStreamId = null;
-            RecordingStatus recordingStatus;
-            try
-            {
-                var allMediaSources = await _mediaSourceManager.GetPlaybackMediaSources(channelItem, null, true, false, CancellationToken.None).ConfigureAwait(false);
-
-                var mediaStreamInfo = allMediaSources[0];
-                IDirectStreamProvider directStreamProvider = null;
-
-                if (mediaStreamInfo.RequiresOpening)
-                {
-                    var liveStreamResponse = await _mediaSourceManager.OpenLiveStreamInternal(
-                        new LiveStreamRequest
-                        {
-                            ItemId = channelItem.Id,
-                            OpenToken = mediaStreamInfo.OpenToken
-                        },
-                        CancellationToken.None).ConfigureAwait(false);
-
-                    mediaStreamInfo = liveStreamResponse.Item1.MediaSource;
-                    liveStreamId = mediaStreamInfo.LiveStreamId;
-                    directStreamProvider = liveStreamResponse.Item2;
-                }
-
-                using var recorder = GetRecorder(mediaStreamInfo);
-
-                recordPath = recorder.GetOutputPath(mediaStreamInfo, recordPath);
-                recordPath = EnsureFileUnique(recordPath, timer.Id);
-
-                _libraryMonitor.ReportFileSystemChangeBeginning(recordPath);
-
-                var duration = recordingEndDate - DateTime.UtcNow;
-
-                _logger.LogInformation("Beginning recording. Will record for {0} minutes.", duration.TotalMinutes.ToString(CultureInfo.InvariantCulture));
-
-                _logger.LogInformation("Writing file to: {Path}", recordPath);
-
-                Action onStarted = async () =>
-                {
-                    activeRecordingInfo.Path = recordPath;
-
-                    _activeRecordings.TryAdd(timer.Id, activeRecordingInfo);
-
-                    timer.Status = RecordingStatus.InProgress;
-                    _timerProvider.AddOrUpdate(timer, false);
-
-                    await SaveRecordingMetadata(timer, recordPath, seriesPath).ConfigureAwait(false);
-
-                    await CreateRecordingFolders().ConfigureAwait(false);
-
-                    TriggerRefresh(recordPath);
-                    await EnforceKeepUpTo(timer, seriesPath).ConfigureAwait(false);
-                };
-
-                await recorder.Record(directStreamProvider, mediaStreamInfo, recordPath, duration, onStarted, activeRecordingInfo.CancellationTokenSource.Token).ConfigureAwait(false);
-
-                recordingStatus = RecordingStatus.Completed;
-                _logger.LogInformation("Recording completed: {RecordPath}", recordPath);
-            }
-            catch (OperationCanceledException)
-            {
-                _logger.LogInformation("Recording stopped: {RecordPath}", recordPath);
-                recordingStatus = RecordingStatus.Completed;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error recording to {RecordPath}", recordPath);
-                recordingStatus = RecordingStatus.Error;
-            }
-
-            if (!string.IsNullOrWhiteSpace(liveStreamId))
-            {
-                try
-                {
-                    await _mediaSourceManager.CloseLiveStream(liveStreamId).ConfigureAwait(false);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error closing live stream");
-                }
-            }
-
-            DeleteFileIfEmpty(recordPath);
-
-            TriggerRefresh(recordPath);
-            _libraryMonitor.ReportFileSystemChangeComplete(recordPath, false);
-
-            _activeRecordings.TryRemove(timer.Id, out _);
-
-            if (recordingStatus != RecordingStatus.Completed && DateTime.UtcNow < timer.EndDate && timer.RetryCount < 10)
-            {
-                const int RetryIntervalSeconds = 60;
-                _logger.LogInformation("Retrying recording in {0} seconds.", RetryIntervalSeconds);
-
-                timer.Status = RecordingStatus.New;
-                timer.PrePaddingSeconds = 0;
-                timer.StartDate = DateTime.UtcNow.AddSeconds(RetryIntervalSeconds);
-                timer.RetryCount++;
-                _timerProvider.AddOrUpdate(timer);
-            }
-            else if (File.Exists(recordPath))
-            {
-                timer.RecordingPath = recordPath;
-                timer.Status = RecordingStatus.Completed;
-                _timerProvider.AddOrUpdate(timer, false);
-                OnSuccessfulRecording(timer, recordPath);
-            }
-            else
-            {
-                _timerProvider.Delete(timer);
-            }
-        }
-
-        private async Task<RemoteSearchResult> FetchInternetMetadata(TimerInfo timer, CancellationToken cancellationToken)
-        {
-            if (timer.IsSeries)
-            {
-                if (timer.SeriesProviderIds.Count == 0)
-                {
-                    return null;
-                }
-
-                var query = new RemoteSearchQuery<SeriesInfo>()
-                {
-                    SearchInfo = new SeriesInfo
-                    {
-                        ProviderIds = timer.SeriesProviderIds,
-                        Name = timer.Name,
-                        MetadataCountryCode = _config.Configuration.MetadataCountryCode,
-                        MetadataLanguage = _config.Configuration.PreferredMetadataLanguage
-                    }
-                };
-
-                var results = await _providerManager.GetRemoteSearchResults<Series, SeriesInfo>(query, cancellationToken).ConfigureAwait(false);
-
-                return results.FirstOrDefault();
-            }
-
-            return null;
-        }
-
-        private void DeleteFileIfEmpty(string path)
-        {
-            var file = _fileSystem.GetFileInfo(path);
-
-            if (file.Exists && file.Length == 0)
-            {
-                try
-                {
-                    _fileSystem.DeleteFile(path);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error deleting 0-byte failed recording file {Path}", path);
-                }
-            }
-        }
-
-        private void TriggerRefresh(string path)
-        {
-            _logger.LogInformation("Triggering refresh on {Path}", path);
-
-            var item = GetAffectedBaseItem(Path.GetDirectoryName(path));
-
-            if (item is not null)
-            {
-                _logger.LogInformation("Refreshing recording parent {Path}", item.Path);
-
-                _providerManager.QueueRefresh(
-                    item.Id,
-                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
-                    {
-                        RefreshPaths = new string[]
-                        {
-                            path,
-                            Path.GetDirectoryName(path),
-                            Path.GetDirectoryName(Path.GetDirectoryName(path))
-                        }
-                    },
-                    RefreshPriority.High);
-            }
-        }
-
-        private BaseItem GetAffectedBaseItem(string path)
-        {
-            BaseItem item = null;
-
-            var parentPath = Path.GetDirectoryName(path);
-
-            while (item is null && !string.IsNullOrEmpty(path))
-            {
-                item = _libraryManager.FindByPath(path, null);
-
-                path = Path.GetDirectoryName(path);
-            }
-
-            if (item is not null)
-            {
-                if (item.GetType() == typeof(Folder) && string.Equals(item.Path, parentPath, StringComparison.OrdinalIgnoreCase))
-                {
-                    var parentItem = item.GetParent();
-                    if (parentItem is not null && parentItem is not AggregateFolder)
-                    {
-                        item = parentItem;
-                    }
-                }
-            }
-
-            return item;
-        }
-
-        private async Task EnforceKeepUpTo(TimerInfo timer, string seriesPath)
-        {
-            if (string.IsNullOrWhiteSpace(timer.SeriesTimerId))
-            {
-                return;
-            }
-
-            if (string.IsNullOrWhiteSpace(seriesPath))
-            {
-                return;
-            }
-
-            var seriesTimerId = timer.SeriesTimerId;
-            var seriesTimer = _seriesTimerProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, seriesTimerId, StringComparison.OrdinalIgnoreCase));
-
-            if (seriesTimer is null || seriesTimer.KeepUpTo <= 0)
-            {
-                return;
-            }
-
-            if (_disposed)
-            {
-                return;
-            }
-
-            await _recordingDeleteSemaphore.WaitAsync().ConfigureAwait(false);
-
-            try
-            {
-                if (_disposed)
-                {
-                    return;
-                }
-
-                var timersToDelete = _timerProvider.GetAll()
-                    .Where(i => i.Status == RecordingStatus.Completed && !string.IsNullOrWhiteSpace(i.RecordingPath))
-                    .Where(i => string.Equals(i.SeriesTimerId, seriesTimerId, StringComparison.OrdinalIgnoreCase))
-                    .OrderByDescending(i => i.EndDate)
-                    .Where(i => File.Exists(i.RecordingPath))
-                    .Skip(seriesTimer.KeepUpTo - 1)
-                    .ToList();
-
-                DeleteLibraryItemsForTimers(timersToDelete);
-
-                if (_libraryManager.FindByPath(seriesPath, true) is not Folder librarySeries)
-                {
-                    return;
-                }
-
-                var episodesToDelete = librarySeries.GetItemList(
-                    new InternalItemsQuery
-                    {
-                        OrderBy = new[] { (ItemSortBy.DateCreated, SortOrder.Descending) },
-                        IsVirtualItem = false,
-                        IsFolder = false,
-                        Recursive = true,
-                        DtoOptions = new DtoOptions(true)
-                    })
-                    .Where(i => i.IsFileProtocol && File.Exists(i.Path))
-                    .Skip(seriesTimer.KeepUpTo - 1)
-                    .ToList();
-
-                foreach (var item in episodesToDelete)
-                {
-                    try
-                    {
-                        _libraryManager.DeleteItem(
-                            item,
-                            new DeleteOptions
-                            {
-                                DeleteFileLocation = true
-                            },
-                            true);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error deleting item");
-                    }
-                }
-            }
-            finally
-            {
-                _recordingDeleteSemaphore.Release();
-            }
-        }
-
-        private void DeleteLibraryItemsForTimers(List<TimerInfo> timers)
-        {
-            foreach (var timer in timers)
-            {
-                if (_disposed)
-                {
-                    return;
-                }
-
-                try
-                {
-                    DeleteLibraryItemForTimer(timer);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error deleting recording");
-                }
-            }
-        }
-
-        private void DeleteLibraryItemForTimer(TimerInfo timer)
-        {
-            var libraryItem = _libraryManager.FindByPath(timer.RecordingPath, false);
-
-            if (libraryItem is not null)
-            {
-                _libraryManager.DeleteItem(
-                    libraryItem,
-                    new DeleteOptions
-                    {
-                        DeleteFileLocation = true
-                    },
-                    true);
-            }
-            else if (File.Exists(timer.RecordingPath))
-            {
-                _fileSystem.DeleteFile(timer.RecordingPath);
-            }
-
-            _timerProvider.Delete(timer);
-        }
-
-        private string EnsureFileUnique(string path, string timerId)
-        {
-            var originalPath = path;
-            var index = 1;
-
-            while (FileExists(path, timerId))
-            {
-                var parent = Path.GetDirectoryName(originalPath);
-                var name = Path.GetFileNameWithoutExtension(originalPath);
-                name += " - " + index.ToString(CultureInfo.InvariantCulture);
-
-                path = Path.ChangeExtension(Path.Combine(parent, name), Path.GetExtension(originalPath));
-                index++;
-            }
-
-            return path;
-        }
-
-        private bool FileExists(string path, string timerId)
-        {
-            if (File.Exists(path))
-            {
-                return true;
-            }
-
-            return _activeRecordings
-                .Any(i => string.Equals(i.Value.Path, path, StringComparison.OrdinalIgnoreCase) && !string.Equals(i.Value.Timer.Id, timerId, StringComparison.OrdinalIgnoreCase));
-        }
-
-        private IRecorder GetRecorder(MediaSourceInfo mediaSource)
-        {
-            if (mediaSource.RequiresLooping || !(mediaSource.Container ?? string.Empty).EndsWith("ts", StringComparison.OrdinalIgnoreCase) || (mediaSource.Protocol != MediaProtocol.File && mediaSource.Protocol != MediaProtocol.Http))
-            {
-                return new EncodedRecorder(_logger, _mediaEncoder, _config.ApplicationPaths, _config);
-            }
-
-            return new DirectRecorder(_logger, _httpClientFactory, _streamHelper);
-        }
-
-        private void OnSuccessfulRecording(TimerInfo timer, string path)
-        {
-            PostProcessRecording(timer, path);
-        }
-
-        private void PostProcessRecording(TimerInfo timer, string path)
-        {
-            var options = _config.GetLiveTvConfiguration();
-            if (string.IsNullOrWhiteSpace(options.RecordingPostProcessor))
-            {
-                return;
-            }
-
-            try
-            {
-                var process = new Process
-                {
-                    StartInfo = new ProcessStartInfo
-                    {
-                        Arguments = GetPostProcessArguments(path, options.RecordingPostProcessorArguments),
-                        CreateNoWindow = true,
-                        ErrorDialog = false,
-                        FileName = options.RecordingPostProcessor,
-                        WindowStyle = ProcessWindowStyle.Hidden,
-                        UseShellExecute = false
-                    },
-                    EnableRaisingEvents = true
-                };
-
-                _logger.LogInformation("Running recording post processor {0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
-
-                process.Exited += OnProcessExited;
-                process.Start();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error running recording post processor");
-            }
-        }
-
-        private static string GetPostProcessArguments(string path, string arguments)
-        {
-            return arguments.Replace("{path}", path, StringComparison.OrdinalIgnoreCase);
-        }
-
-        private void OnProcessExited(object sender, EventArgs e)
-        {
-            using (var process = (Process)sender)
-            {
-                _logger.LogInformation("Recording post-processing script completed with exit code {ExitCode}", process.ExitCode);
-            }
-        }
-
-        private async Task SaveRecordingImage(string recordingPath, LiveTvProgram program, ItemImageInfo image)
-        {
-            if (!image.IsLocalFile)
-            {
-                image = await _libraryManager.ConvertImageToLocal(program, image, 0).ConfigureAwait(false);
-            }
-
-            string imageSaveFilenameWithoutExtension = image.Type switch
-            {
-                ImageType.Primary => program.IsSeries ? Path.GetFileNameWithoutExtension(recordingPath) + "-thumb" : "poster",
-                ImageType.Logo => "logo",
-                ImageType.Thumb => program.IsSeries ? Path.GetFileNameWithoutExtension(recordingPath) + "-thumb" : "landscape",
-                ImageType.Backdrop => "fanart",
-                _ => null
-            };
-
-            if (imageSaveFilenameWithoutExtension is null)
-            {
-                return;
-            }
-
-            var imageSavePath = Path.Combine(Path.GetDirectoryName(recordingPath), imageSaveFilenameWithoutExtension);
-
-            // preserve original image extension
-            imageSavePath = Path.ChangeExtension(imageSavePath, Path.GetExtension(image.Path));
-
-            File.Copy(image.Path, imageSavePath, true);
-        }
-
-        private async Task SaveRecordingImages(string recordingPath, LiveTvProgram program)
-        {
-            var image = program.IsSeries ?
-                (program.GetImageInfo(ImageType.Thumb, 0) ?? program.GetImageInfo(ImageType.Primary, 0)) :
-                (program.GetImageInfo(ImageType.Primary, 0) ?? program.GetImageInfo(ImageType.Thumb, 0));
-
-            if (image is not null)
-            {
-                try
-                {
-                    await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error saving recording image");
-                }
-            }
-
-            if (!program.IsSeries)
-            {
-                image = program.GetImageInfo(ImageType.Backdrop, 0);
-                if (image is not null)
-                {
-                    try
-                    {
-                        await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error saving recording image");
-                    }
-                }
-
-                image = program.GetImageInfo(ImageType.Thumb, 0);
-                if (image is not null)
-                {
-                    try
-                    {
-                        await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error saving recording image");
-                    }
-                }
-
-                image = program.GetImageInfo(ImageType.Logo, 0);
-                if (image is not null)
-                {
-                    try
-                    {
-                        await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error saving recording image");
-                    }
-                }
-            }
-        }
-
-        private async Task SaveRecordingMetadata(TimerInfo timer, string recordingPath, string seriesPath)
-        {
-            try
-            {
-                var program = string.IsNullOrWhiteSpace(timer.ProgramId) ? null : _libraryManager.GetItemList(new InternalItemsQuery
-                {
-                    IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
-                    Limit = 1,
-                    ExternalId = timer.ProgramId,
-                    DtoOptions = new DtoOptions(true)
-                }).FirstOrDefault() as LiveTvProgram;
-
-                // dummy this up
-                if (program is null)
-                {
-                    program = new LiveTvProgram
-                    {
-                        Name = timer.Name,
-                        Overview = timer.Overview,
-                        Genres = timer.Genres,
-                        CommunityRating = timer.CommunityRating,
-                        OfficialRating = timer.OfficialRating,
-                        ProductionYear = timer.ProductionYear,
-                        PremiereDate = timer.OriginalAirDate,
-                        IndexNumber = timer.EpisodeNumber,
-                        ParentIndexNumber = timer.SeasonNumber
-                    };
-                }
-
-                if (timer.IsSports)
-                {
-                    program.AddGenre("Sports");
-                }
-
-                if (timer.IsKids)
-                {
-                    program.AddGenre("Kids");
-                    program.AddGenre("Children");
-                }
-
-                if (timer.IsNews)
-                {
-                    program.AddGenre("News");
-                }
-
-                var config = _config.GetLiveTvConfiguration();
-
-                if (config.SaveRecordingNFO)
-                {
-                    if (timer.IsProgramSeries)
-                    {
-                        await SaveSeriesNfoAsync(timer, seriesPath).ConfigureAwait(false);
-                        await SaveVideoNfoAsync(timer, recordingPath, program, false).ConfigureAwait(false);
-                    }
-                    else if (!timer.IsMovie || timer.IsSports || timer.IsNews)
-                    {
-                        await SaveVideoNfoAsync(timer, recordingPath, program, true).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        await SaveVideoNfoAsync(timer, recordingPath, program, false).ConfigureAwait(false);
-                    }
-                }
-
-                if (config.SaveRecordingImages)
-                {
-                    await SaveRecordingImages(recordingPath, program).ConfigureAwait(false);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error saving nfo");
-            }
-        }
-
-        private async Task SaveSeriesNfoAsync(TimerInfo timer, string seriesPath)
-        {
-            var nfoPath = Path.Combine(seriesPath, "tvshow.nfo");
-
-            if (File.Exists(nfoPath))
-            {
-                return;
-            }
-
-            var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
-            await using (stream.ConfigureAwait(false))
-            {
-                var settings = new XmlWriterSettings
-                {
-                    Indent = true,
-                    Encoding = Encoding.UTF8,
-                    Async = true
-                };
-
-                var writer = XmlWriter.Create(stream, settings);
-                await using (writer.ConfigureAwait(false))
-                {
-                    await writer.WriteStartDocumentAsync(true).ConfigureAwait(false);
-                    await writer.WriteStartElementAsync(null, "tvshow", null).ConfigureAwait(false);
-                    if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Tvdb.ToString(), out var id))
-                    {
-                        await writer.WriteElementStringAsync(null, "id", null, id).ConfigureAwait(false);
-                    }
-
-                    if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Imdb.ToString(), out id))
-                    {
-                        await writer.WriteElementStringAsync(null, "imdb_id", null, id).ConfigureAwait(false);
-                    }
-
-                    if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Tmdb.ToString(), out id))
-                    {
-                        await writer.WriteElementStringAsync(null, "tmdbid", null, id).ConfigureAwait(false);
-                    }
-
-                    if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Zap2It.ToString(), out id))
-                    {
-                        await writer.WriteElementStringAsync(null, "zap2itid", null, id).ConfigureAwait(false);
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(timer.Name))
-                    {
-                        await writer.WriteElementStringAsync(null, "title", null, timer.Name).ConfigureAwait(false);
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(timer.OfficialRating))
-                    {
-                        await writer.WriteElementStringAsync(null, "mpaa", null, timer.OfficialRating).ConfigureAwait(false);
-                    }
-
-                    foreach (var genre in timer.Genres)
-                    {
-                        await writer.WriteElementStringAsync(null, "genre", null, genre).ConfigureAwait(false);
-                    }
-
-                    await writer.WriteEndElementAsync().ConfigureAwait(false);
-                    await writer.WriteEndDocumentAsync().ConfigureAwait(false);
-                }
-            }
-        }
-
-        private async Task SaveVideoNfoAsync(TimerInfo timer, string recordingPath, BaseItem item, bool lockData)
-        {
-            var nfoPath = Path.ChangeExtension(recordingPath, ".nfo");
-
-            if (File.Exists(nfoPath))
-            {
-                return;
-            }
-
-            var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
-            await using (stream.ConfigureAwait(false))
-            {
-                var settings = new XmlWriterSettings
-                {
-                    Indent = true,
-                    Encoding = Encoding.UTF8,
-                    Async = true
-                };
-
-                var options = _config.GetNfoConfiguration();
-
-                var isSeriesEpisode = timer.IsProgramSeries;
-
-                var writer = XmlWriter.Create(stream, settings);
-                await using (writer.ConfigureAwait(false))
-                {
-                    await writer.WriteStartDocumentAsync(true).ConfigureAwait(false);
-
-                    if (isSeriesEpisode)
-                    {
-                        await writer.WriteStartElementAsync(null, "episodedetails", null).ConfigureAwait(false);
-
-                        if (!string.IsNullOrWhiteSpace(timer.EpisodeTitle))
-                        {
-                            await writer.WriteElementStringAsync(null, "title", null, timer.EpisodeTitle).ConfigureAwait(false);
-                        }
-
-                        var premiereDate = item.PremiereDate ?? (!timer.IsRepeat ? DateTime.UtcNow : null);
-
-                        if (premiereDate.HasValue)
-                        {
-                            var formatString = options.ReleaseDateFormat;
-
-                            await writer.WriteElementStringAsync(
-                                null,
-                                "aired",
-                                null,
-                                premiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                        }
-
-                        if (item.IndexNumber.HasValue)
-                        {
-                            await writer.WriteElementStringAsync(null, "episode", null, item.IndexNumber.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                        }
-
-                        if (item.ParentIndexNumber.HasValue)
-                        {
-                            await writer.WriteElementStringAsync(null, "season", null, item.ParentIndexNumber.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                        }
-                    }
-                    else
-                    {
-                        await writer.WriteStartElementAsync(null, "movie", null).ConfigureAwait(false);
-
-                        if (!string.IsNullOrWhiteSpace(item.Name))
-                        {
-                            await writer.WriteElementStringAsync(null, "title", null, item.Name).ConfigureAwait(false);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(item.OriginalTitle))
-                        {
-                            await writer.WriteElementStringAsync(null, "originaltitle", null, item.OriginalTitle).ConfigureAwait(false);
-                        }
-
-                        if (item.PremiereDate.HasValue)
-                        {
-                            var formatString = options.ReleaseDateFormat;
-
-                            await writer.WriteElementStringAsync(
-                                null,
-                                "premiered",
-                                null,
-                                item.PremiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                            await writer.WriteElementStringAsync(
-                                null,
-                                "releasedate",
-                                null,
-                                item.PremiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                        }
-                    }
-
-                    await writer.WriteElementStringAsync(
-                        null,
-                        "dateadded",
-                        null,
-                        DateTime.Now.ToString(DateAddedFormat, CultureInfo.InvariantCulture)).ConfigureAwait(false);
-
-                    if (item.ProductionYear.HasValue)
-                    {
-                        await writer.WriteElementStringAsync(null, "year", null, item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                    }
-
-                    if (!string.IsNullOrEmpty(item.OfficialRating))
-                    {
-                        await writer.WriteElementStringAsync(null, "mpaa", null, item.OfficialRating).ConfigureAwait(false);
-                    }
-
-                    var overview = (item.Overview ?? string.Empty)
-                        .StripHtml()
-                        .Replace("&quot;", "'", StringComparison.Ordinal);
-
-                    await writer.WriteElementStringAsync(null, "plot", null, overview).ConfigureAwait(false);
-
-                    if (item.CommunityRating.HasValue)
-                    {
-                        await writer.WriteElementStringAsync(null, "rating", null, item.CommunityRating.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                    }
-
-                    foreach (var genre in item.Genres)
-                    {
-                        await writer.WriteElementStringAsync(null, "genre", null, genre).ConfigureAwait(false);
-                    }
-
-                    var people = item.Id.IsEmpty() ? new List<PersonInfo>() : _libraryManager.GetPeople(item);
-
-                    var directors = people
-                        .Where(i => i.IsType(PersonKind.Director))
-                        .Select(i => i.Name)
-                        .ToList();
-
-                    foreach (var person in directors)
-                    {
-                        await writer.WriteElementStringAsync(null, "director", null, person).ConfigureAwait(false);
-                    }
-
-                    var writers = people
-                        .Where(i => i.IsType(PersonKind.Writer))
-                        .Select(i => i.Name)
-                        .Distinct(StringComparer.OrdinalIgnoreCase)
-                        .ToList();
-
-                    foreach (var person in writers)
-                    {
-                        await writer.WriteElementStringAsync(null, "writer", null, person).ConfigureAwait(false);
-                    }
-
-                    foreach (var person in writers)
-                    {
-                        await writer.WriteElementStringAsync(null, "credits", null, person).ConfigureAwait(false);
-                    }
-
-                    var tmdbCollection = item.GetProviderId(MetadataProvider.TmdbCollection);
-
-                    if (!string.IsNullOrEmpty(tmdbCollection))
-                    {
-                        await writer.WriteElementStringAsync(null, "collectionnumber", null, tmdbCollection).ConfigureAwait(false);
-                    }
-
-                    var imdb = item.GetProviderId(MetadataProvider.Imdb);
-                    if (!string.IsNullOrEmpty(imdb))
-                    {
-                        if (!isSeriesEpisode)
-                        {
-                            await writer.WriteElementStringAsync(null, "id", null, imdb).ConfigureAwait(false);
-                        }
-
-                        await writer.WriteElementStringAsync(null, "imdbid", null, imdb).ConfigureAwait(false);
-
-                        // No need to lock if we have identified the content already
-                        lockData = false;
-                    }
-
-                    var tvdb = item.GetProviderId(MetadataProvider.Tvdb);
-                    if (!string.IsNullOrEmpty(tvdb))
-                    {
-                        await writer.WriteElementStringAsync(null, "tvdbid", null, tvdb).ConfigureAwait(false);
-
-                        // No need to lock if we have identified the content already
-                        lockData = false;
-                    }
-
-                    var tmdb = item.GetProviderId(MetadataProvider.Tmdb);
-                    if (!string.IsNullOrEmpty(tmdb))
-                    {
-                        await writer.WriteElementStringAsync(null, "tmdbid", null, tmdb).ConfigureAwait(false);
-
-                        // No need to lock if we have identified the content already
-                        lockData = false;
-                    }
-
-                    if (lockData)
-                    {
-                        await writer.WriteElementStringAsync(null, "lockdata", null, "true").ConfigureAwait(false);
-                    }
-
-                    if (item.CriticRating.HasValue)
-                    {
-                        await writer.WriteElementStringAsync(null, "criticrating", null, item.CriticRating.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(item.Tagline))
-                    {
-                        await writer.WriteElementStringAsync(null, "tagline", null, item.Tagline).ConfigureAwait(false);
-                    }
-
-                    foreach (var studio in item.Studios)
-                    {
-                        await writer.WriteElementStringAsync(null, "studio", null, studio).ConfigureAwait(false);
-                    }
-
-                    await writer.WriteEndElementAsync().ConfigureAwait(false);
-                    await writer.WriteEndDocumentAsync().ConfigureAwait(false);
-                }
-            }
-        }
-
-        private LiveTvProgram GetProgramInfoFromCache(string programId)
-        {
-            var query = new InternalItemsQuery
-            {
-                ItemIds = new[] { _liveTvManager.GetInternalProgramId(programId) },
-                Limit = 1,
-                DtoOptions = new DtoOptions()
-            };
-
-            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().FirstOrDefault();
-        }
-
-        private LiveTvProgram GetProgramInfoFromCache(TimerInfo timer)
-        {
-            return GetProgramInfoFromCache(timer.ProgramId);
-        }
-
-        private LiveTvProgram GetProgramInfoFromCache(string channelId, DateTime startDateUtc)
-        {
-            var query = new InternalItemsQuery
-            {
-                IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
-                Limit = 1,
-                DtoOptions = new DtoOptions(true)
-                {
-                    EnableImages = false
-                },
-                MinStartDate = startDateUtc.AddMinutes(-3),
-                MaxStartDate = startDateUtc.AddMinutes(3),
-                OrderBy = new[] { (ItemSortBy.StartDate, SortOrder.Ascending) }
-            };
-
-            if (!string.IsNullOrWhiteSpace(channelId))
-            {
-                query.ChannelIds = new[] { _liveTvManager.GetInternalChannelId(Name, channelId) };
-            }
-
-            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().FirstOrDefault();
-        }
-
-        private bool ShouldCancelTimerForSeriesTimer(SeriesTimerInfo seriesTimer, TimerInfo timer)
-        {
-            if (timer.IsManual)
-            {
-                return false;
-            }
-
-            if (!seriesTimer.RecordAnyTime
-                && Math.Abs(seriesTimer.StartDate.TimeOfDay.Ticks - timer.StartDate.TimeOfDay.Ticks) >= TimeSpan.FromMinutes(10).Ticks)
-            {
-                return true;
-            }
-
-            if (seriesTimer.RecordNewOnly && timer.IsRepeat)
-            {
-                return true;
-            }
-
-            if (!seriesTimer.RecordAnyChannel
-                && !string.Equals(timer.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase))
-            {
-                return true;
-            }
-
-            return seriesTimer.SkipEpisodesInLibrary && IsProgramAlreadyInLibrary(timer);
-        }
-
-        private void HandleDuplicateShowIds(List<TimerInfo> timers)
-        {
-            // sort showings by HD channels first, then by startDate, record earliest showing possible
-            foreach (var timer in timers.OrderByDescending(t => _liveTvManager.GetLiveTvChannel(t, this).IsHD).ThenBy(t => t.StartDate).Skip(1))
-            {
-                timer.Status = RecordingStatus.Cancelled;
-                _timerProvider.Update(timer);
-            }
-        }
-
-        private void SearchForDuplicateShowIds(IEnumerable<TimerInfo> timers)
-        {
-            var groups = timers.ToLookup(i => i.ShowId ?? string.Empty).ToList();
-
-            foreach (var group in groups)
-            {
-                if (string.IsNullOrWhiteSpace(group.Key))
-                {
-                    continue;
-                }
-
-                var groupTimers = group.ToList();
-
-                if (groupTimers.Count < 2)
-                {
-                    continue;
-                }
-
-                // Skip ShowId without SubKey from duplicate removal actions - https://github.com/jellyfin/jellyfin/issues/5856
-                if (group.Key.EndsWith("0000", StringComparison.Ordinal))
-                {
-                    continue;
-                }
-
-                HandleDuplicateShowIds(groupTimers);
-            }
-        }
-
-        private void UpdateTimersForSeriesTimer(SeriesTimerInfo seriesTimer, bool updateTimerSettings, bool deleteInvalidTimers)
-        {
-            var allTimers = GetTimersForSeries(seriesTimer).ToList();
-
-            var enabledTimersForSeries = new List<TimerInfo>();
-            foreach (var timer in allTimers)
-            {
-                var existingTimer = _timerProvider.GetTimer(timer.Id)
-                    ?? (string.IsNullOrWhiteSpace(timer.ProgramId)
-                        ? null
-                        : _timerProvider.GetTimerByProgramId(timer.ProgramId));
-
-                if (existingTimer is null)
-                {
-                    if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
-                    {
-                        timer.Status = RecordingStatus.Cancelled;
-                    }
-                    else
-                    {
-                        enabledTimersForSeries.Add(timer);
-                    }
-
-                    _timerProvider.Add(timer);
-
-                    TimerCreated?.Invoke(this, new GenericEventArgs<TimerInfo>(timer));
-                }
-
-                // Only update if not currently active - test both new timer and existing in case Id's are different
-                // Id's could be different if the timer was created manually prior to series timer creation
-                else if (!_activeRecordings.TryGetValue(timer.Id, out _) && !_activeRecordings.TryGetValue(existingTimer.Id, out _))
-                {
-                    UpdateExistingTimerWithNewMetadata(existingTimer, timer);
-
-                    // Needed by ShouldCancelTimerForSeriesTimer
-                    timer.IsManual = existingTimer.IsManual;
-
-                    if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
-                    {
-                        existingTimer.Status = RecordingStatus.Cancelled;
-                    }
-                    else if (!existingTimer.IsManual)
-                    {
-                        existingTimer.Status = RecordingStatus.New;
-                    }
-
-                    if (existingTimer.Status != RecordingStatus.Cancelled)
-                    {
-                        enabledTimersForSeries.Add(existingTimer);
-                    }
-
-                    if (updateTimerSettings)
-                    {
-                        existingTimer.KeepUntil = seriesTimer.KeepUntil;
-                        existingTimer.IsPostPaddingRequired = seriesTimer.IsPostPaddingRequired;
-                        existingTimer.IsPrePaddingRequired = seriesTimer.IsPrePaddingRequired;
-                        existingTimer.PostPaddingSeconds = seriesTimer.PostPaddingSeconds;
-                        existingTimer.PrePaddingSeconds = seriesTimer.PrePaddingSeconds;
-                        existingTimer.Priority = seriesTimer.Priority;
-                        existingTimer.SeriesTimerId = seriesTimer.Id;
-                    }
-
-                    existingTimer.SeriesTimerId = seriesTimer.Id;
-                    _timerProvider.Update(existingTimer);
-                }
-            }
-
-            SearchForDuplicateShowIds(enabledTimersForSeries);
-
-            if (deleteInvalidTimers)
-            {
-                var allTimerIds = allTimers
-                    .Select(i => i.Id)
-                    .ToList();
-
-                var deleteStatuses = new[]
-                {
-                    RecordingStatus.New
-                };
-
-                var deletes = _timerProvider.GetAll()
-                    .Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase))
-                    .Where(i => !allTimerIds.Contains(i.Id, StringComparison.OrdinalIgnoreCase) && i.StartDate > DateTime.UtcNow)
-                    .Where(i => deleteStatuses.Contains(i.Status))
-                    .ToList();
-
-                foreach (var timer in deletes)
-                {
-                    CancelTimerInternal(timer.Id, false, false);
-                }
-            }
-        }
-
-        private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer)
-        {
-            ArgumentNullException.ThrowIfNull(seriesTimer);
-
-            var query = new InternalItemsQuery
-            {
-                IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
-                ExternalSeriesId = seriesTimer.SeriesId,
-                DtoOptions = new DtoOptions(true)
-                {
-                    EnableImages = false
-                },
-                MinEndDate = DateTime.UtcNow
-            };
-
-            if (string.IsNullOrEmpty(seriesTimer.SeriesId))
-            {
-                query.Name = seriesTimer.Name;
-            }
-
-            if (!seriesTimer.RecordAnyChannel)
-            {
-                query.ChannelIds = new[] { _liveTvManager.GetInternalChannelId(Name, seriesTimer.ChannelId) };
-            }
-
-            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
-
-            return _libraryManager.GetItemList(query).Cast<LiveTvProgram>().Select(i => CreateTimer(i, seriesTimer, tempChannelCache));
-        }
-
-        private TimerInfo CreateTimer(LiveTvProgram parent, SeriesTimerInfo seriesTimer, Dictionary<Guid, LiveTvChannel> tempChannelCache)
-        {
-            string channelId = seriesTimer.RecordAnyChannel ? null : seriesTimer.ChannelId;
-
-            if (string.IsNullOrWhiteSpace(channelId) && !parent.ChannelId.IsEmpty())
-            {
-                if (!tempChannelCache.TryGetValue(parent.ChannelId, out LiveTvChannel channel))
-                {
-                    channel = _libraryManager.GetItemList(
-                        new InternalItemsQuery
-                        {
-                            IncludeItemTypes = new[] { BaseItemKind.LiveTvChannel },
-                            ItemIds = new[] { parent.ChannelId },
-                            DtoOptions = new DtoOptions()
-                        }).FirstOrDefault() as LiveTvChannel;
-
-                    if (channel is not null && !string.IsNullOrWhiteSpace(channel.ExternalId))
-                    {
-                        tempChannelCache[parent.ChannelId] = channel;
-                    }
-                }
-
-                if (channel is not null || tempChannelCache.TryGetValue(parent.ChannelId, out channel))
-                {
-                    channelId = channel.ExternalId;
-                }
-            }
-
-            var timer = new TimerInfo
-            {
-                ChannelId = channelId,
-                Id = (seriesTimer.Id + parent.ExternalId).GetMD5().ToString("N", CultureInfo.InvariantCulture),
-                StartDate = parent.StartDate,
-                EndDate = parent.EndDate.Value,
-                ProgramId = parent.ExternalId,
-                PrePaddingSeconds = seriesTimer.PrePaddingSeconds,
-                PostPaddingSeconds = seriesTimer.PostPaddingSeconds,
-                IsPostPaddingRequired = seriesTimer.IsPostPaddingRequired,
-                IsPrePaddingRequired = seriesTimer.IsPrePaddingRequired,
-                KeepUntil = seriesTimer.KeepUntil,
-                Priority = seriesTimer.Priority,
-                Name = parent.Name,
-                Overview = parent.Overview,
-                SeriesId = parent.ExternalSeriesId,
-                SeriesTimerId = seriesTimer.Id,
-                ShowId = parent.ShowId
-            };
-
-            CopyProgramInfoToTimerInfo(parent, timer, tempChannelCache);
-
-            return timer;
-        }
-
-        private void CopyProgramInfoToTimerInfo(LiveTvProgram programInfo, TimerInfo timerInfo)
-        {
-            var tempChannelCache = new Dictionary<Guid, LiveTvChannel>();
-            CopyProgramInfoToTimerInfo(programInfo, timerInfo, tempChannelCache);
-        }
-
-        private void CopyProgramInfoToTimerInfo(LiveTvProgram programInfo, TimerInfo timerInfo, Dictionary<Guid, LiveTvChannel> tempChannelCache)
-        {
-            string channelId = null;
-
-            if (!programInfo.ChannelId.IsEmpty())
-            {
-                if (!tempChannelCache.TryGetValue(programInfo.ChannelId, out LiveTvChannel channel))
-                {
-                    channel = _libraryManager.GetItemList(
-                        new InternalItemsQuery
-                        {
-                            IncludeItemTypes = new[] { BaseItemKind.LiveTvChannel },
-                            ItemIds = new[] { programInfo.ChannelId },
-                            DtoOptions = new DtoOptions()
-                        }).FirstOrDefault() as LiveTvChannel;
-
-                    if (channel is not null && !string.IsNullOrWhiteSpace(channel.ExternalId))
-                    {
-                        tempChannelCache[programInfo.ChannelId] = channel;
-                    }
-                }
-
-                if (channel is not null || tempChannelCache.TryGetValue(programInfo.ChannelId, out channel))
-                {
-                    channelId = channel.ExternalId;
-                }
-            }
-
-            timerInfo.Name = programInfo.Name;
-            timerInfo.StartDate = programInfo.StartDate;
-            timerInfo.EndDate = programInfo.EndDate.Value;
-
-            if (!string.IsNullOrWhiteSpace(channelId))
-            {
-                timerInfo.ChannelId = channelId;
-            }
-
-            timerInfo.SeasonNumber = programInfo.ParentIndexNumber;
-            timerInfo.EpisodeNumber = programInfo.IndexNumber;
-            timerInfo.IsMovie = programInfo.IsMovie;
-            timerInfo.ProductionYear = programInfo.ProductionYear;
-            timerInfo.EpisodeTitle = programInfo.EpisodeTitle;
-            timerInfo.OriginalAirDate = programInfo.PremiereDate;
-            timerInfo.IsProgramSeries = programInfo.IsSeries;
-
-            timerInfo.IsSeries = programInfo.IsSeries;
-
-            timerInfo.CommunityRating = programInfo.CommunityRating;
-            timerInfo.Overview = programInfo.Overview;
-            timerInfo.OfficialRating = programInfo.OfficialRating;
-            timerInfo.IsRepeat = programInfo.IsRepeat;
-            timerInfo.SeriesId = programInfo.ExternalSeriesId;
-            timerInfo.ProviderIds = programInfo.ProviderIds;
-            timerInfo.Tags = programInfo.Tags;
-
-            var seriesProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-
-            foreach (var providerId in timerInfo.ProviderIds)
-            {
-                const string Search = "Series";
-                if (providerId.Key.StartsWith(Search, StringComparison.OrdinalIgnoreCase))
-                {
-                    seriesProviderIds[providerId.Key.Substring(Search.Length)] = providerId.Value;
-                }
-            }
-
-            timerInfo.SeriesProviderIds = seriesProviderIds;
-        }
-
-        private bool IsProgramAlreadyInLibrary(TimerInfo program)
-        {
-            if ((program.EpisodeNumber.HasValue && program.SeasonNumber.HasValue) || !string.IsNullOrWhiteSpace(program.EpisodeTitle))
-            {
-                var seriesIds = _libraryManager.GetItemIds(
-                    new InternalItemsQuery
-                    {
-                        IncludeItemTypes = new[] { BaseItemKind.Series },
-                        Name = program.Name
-                    }).ToArray();
-
-                if (seriesIds.Length == 0)
-                {
-                    return false;
-                }
-
-                if (program.EpisodeNumber.HasValue && program.SeasonNumber.HasValue)
-                {
-                    var result = _libraryManager.GetItemIds(new InternalItemsQuery
-                    {
-                        IncludeItemTypes = new[] { BaseItemKind.Episode },
-                        ParentIndexNumber = program.SeasonNumber.Value,
-                        IndexNumber = program.EpisodeNumber.Value,
-                        AncestorIds = seriesIds,
-                        IsVirtualItem = false,
-                        Limit = 1
-                    });
-
-                    if (result.Count > 0)
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            _recordingDeleteSemaphore.Dispose();
-
-            foreach (var pair in _activeRecordings.ToList())
-            {
-                pair.Value.CancellationTokenSource.Cancel();
-            }
-
-            _disposed = true;
-        }
-
-        public IEnumerable<VirtualFolderInfo> GetRecordingFolders()
-        {
-            var defaultFolder = RecordingPath;
-            var defaultName = "Recordings";
-
-            if (Directory.Exists(defaultFolder))
-            {
-                yield return new VirtualFolderInfo
-                {
-                    Locations = new string[] { defaultFolder },
-                    Name = defaultName
-                };
-            }
-
-            var customPath = _config.GetLiveTvConfiguration().MovieRecordingPath;
-            if (!string.IsNullOrWhiteSpace(customPath) && !string.Equals(customPath, defaultFolder, StringComparison.OrdinalIgnoreCase) && Directory.Exists(customPath))
-            {
-                yield return new VirtualFolderInfo
-                {
-                    Locations = new string[] { customPath },
-                    Name = "Recorded Movies",
-                    CollectionType = CollectionTypeOptions.Movies
-                };
-            }
-
-            customPath = _config.GetLiveTvConfiguration().SeriesRecordingPath;
-            if (!string.IsNullOrWhiteSpace(customPath) && !string.Equals(customPath, defaultFolder, StringComparison.OrdinalIgnoreCase) && Directory.Exists(customPath))
-            {
-                yield return new VirtualFolderInfo
-                {
-                    Locations = new string[] { customPath },
-                    Name = "Recorded Shows",
-                    CollectionType = CollectionTypeOptions.TvShows
-                };
-            }
-        }
-    }
-}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/EntryPoint.cs b/src/Jellyfin.LiveTv/EmbyTV/EntryPoint.cs
deleted file mode 100644
index e750c05ac..000000000
--- a/src/Jellyfin.LiveTv/EmbyTV/EntryPoint.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma warning disable CS1591
-
-using System.Threading.Tasks;
-using MediaBrowser.Controller.Plugins;
-
-namespace Jellyfin.LiveTv.EmbyTV
-{
-    public sealed class EntryPoint : IServerEntryPoint
-    {
-        /// <inheritdoc />
-        public Task RunAsync()
-        {
-            return EmbyTV.Current.Start();
-        }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-        }
-    }
-}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/NfoConfigurationExtensions.cs b/src/Jellyfin.LiveTv/EmbyTV/NfoConfigurationExtensions.cs
deleted file mode 100644
index e8570f0e0..000000000
--- a/src/Jellyfin.LiveTv/EmbyTV/NfoConfigurationExtensions.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Model.Configuration;
-
-namespace Jellyfin.LiveTv.EmbyTV
-{
-    /// <summary>
-    /// Class containing extension methods for working with the nfo configuration.
-    /// </summary>
-    public static class NfoConfigurationExtensions
-    {
-        /// <summary>
-        /// Gets the nfo configuration.
-        /// </summary>
-        /// <param name="configurationManager">The configuration manager.</param>
-        /// <returns>The nfo configuration.</returns>
-        public static XbmcMetadataOptions GetNfoConfiguration(this IConfigurationManager configurationManager)
-         => configurationManager.GetConfiguration<XbmcMetadataOptions>("xbmcmetadata");
-    }
-}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/SeriesTimerManager.cs b/src/Jellyfin.LiveTv/EmbyTV/SeriesTimerManager.cs
deleted file mode 100644
index 2ebe60b29..000000000
--- a/src/Jellyfin.LiveTv/EmbyTV/SeriesTimerManager.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma warning disable CS1591
-
-using System;
-using MediaBrowser.Controller.LiveTv;
-using Microsoft.Extensions.Logging;
-
-namespace Jellyfin.LiveTv.EmbyTV
-{
-    public class SeriesTimerManager : ItemDataProvider<SeriesTimerInfo>
-    {
-        public SeriesTimerManager(ILogger logger, string dataPath)
-            : base(logger, dataPath, (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase))
-        {
-        }
-
-        /// <inheritdoc />
-        public override void Add(SeriesTimerInfo item)
-        {
-            ArgumentException.ThrowIfNullOrEmpty(item.Id);
-
-            base.Add(item);
-        }
-    }
-}
diff --git a/src/Jellyfin.LiveTv/Extensions/LiveTvServiceCollectionExtensions.cs b/src/Jellyfin.LiveTv/Extensions/LiveTvServiceCollectionExtensions.cs
index 5490547ec..73729c950 100644
--- a/src/Jellyfin.LiveTv/Extensions/LiveTvServiceCollectionExtensions.cs
+++ b/src/Jellyfin.LiveTv/Extensions/LiveTvServiceCollectionExtensions.cs
@@ -1,4 +1,9 @@
 using Jellyfin.LiveTv.Channels;
+using Jellyfin.LiveTv.Guide;
+using Jellyfin.LiveTv.IO;
+using Jellyfin.LiveTv.Listings;
+using Jellyfin.LiveTv.Recordings;
+using Jellyfin.LiveTv.Timers;
 using Jellyfin.LiveTv.TunerHosts;
 using Jellyfin.LiveTv.TunerHosts.HdHomerun;
 using MediaBrowser.Controller.Channels;
@@ -20,12 +25,22 @@ public static class LiveTvServiceCollectionExtensions
     public static void AddLiveTvServices(this IServiceCollection services)
     {
         services.AddSingleton<LiveTvDtoService>();
+        services.AddSingleton<TimerManager>();
+        services.AddSingleton<SeriesTimerManager>();
+        services.AddSingleton<RecordingsMetadataManager>();
+
         services.AddSingleton<ILiveTvManager, LiveTvManager>();
         services.AddSingleton<IChannelManager, ChannelManager>();
         services.AddSingleton<IStreamHelper, StreamHelper>();
         services.AddSingleton<ITunerHostManager, TunerHostManager>();
+        services.AddSingleton<IListingsManager, ListingsManager>();
+        services.AddSingleton<IGuideManager, GuideManager>();
+        services.AddSingleton<IRecordingsManager, RecordingsManager>();
 
+        services.AddSingleton<ILiveTvService, DefaultLiveTvService>();
         services.AddSingleton<ITunerHost, HdHomerunHost>();
         services.AddSingleton<ITunerHost, M3UTunerHost>();
+        services.AddSingleton<IListingsProvider, SchedulesDirect>();
+        services.AddSingleton<IListingsProvider, XmlTvListingsProvider>();
     }
 }
diff --git a/src/Jellyfin.LiveTv/Guide/GuideManager.cs b/src/Jellyfin.LiveTv/Guide/GuideManager.cs
new file mode 100644
index 000000000..39f174cc2
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Guide/GuideManager.cs
@@ -0,0 +1,711 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using Jellyfin.LiveTv.Configuration;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.LiveTv;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv.Guide;
+
+/// <inheritdoc />
+public class GuideManager : IGuideManager
+{
+    private const int MaxGuideDays = 14;
+    private const string EtagKey = "ProgramEtag";
+    private const string ExternalServiceTag = "ExternalServiceId";
+
+    private readonly ILogger<GuideManager> _logger;
+    private readonly IConfigurationManager _config;
+    private readonly IFileSystem _fileSystem;
+    private readonly IItemRepository _itemRepo;
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILiveTvManager _liveTvManager;
+    private readonly ITunerHostManager _tunerHostManager;
+    private readonly IRecordingsManager _recordingsManager;
+    private readonly LiveTvDtoService _tvDtoService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GuideManager"/> class.
+    /// </summary>
+    /// <param name="logger">The <see cref="ILogger{TCategoryName}"/>.</param>
+    /// <param name="config">The <see cref="IConfigurationManager"/>.</param>
+    /// <param name="fileSystem">The <see cref="IFileSystem"/>.</param>
+    /// <param name="itemRepo">The <see cref="IItemRepository"/>.</param>
+    /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param>
+    /// <param name="liveTvManager">The <see cref="ILiveTvManager"/>.</param>
+    /// <param name="tunerHostManager">The <see cref="ITunerHostManager"/>.</param>
+    /// <param name="recordingsManager">The <see cref="IRecordingsManager"/>.</param>
+    /// <param name="tvDtoService">The <see cref="LiveTvDtoService"/>.</param>
+    public GuideManager(
+        ILogger<GuideManager> logger,
+        IConfigurationManager config,
+        IFileSystem fileSystem,
+        IItemRepository itemRepo,
+        ILibraryManager libraryManager,
+        ILiveTvManager liveTvManager,
+        ITunerHostManager tunerHostManager,
+        IRecordingsManager recordingsManager,
+        LiveTvDtoService tvDtoService)
+    {
+        _logger = logger;
+        _config = config;
+        _fileSystem = fileSystem;
+        _itemRepo = itemRepo;
+        _libraryManager = libraryManager;
+        _liveTvManager = liveTvManager;
+        _tunerHostManager = tunerHostManager;
+        _recordingsManager = recordingsManager;
+        _tvDtoService = tvDtoService;
+    }
+
+    /// <inheritdoc />
+    public GuideInfo GetGuideInfo()
+    {
+        var startDate = DateTime.UtcNow;
+        var endDate = startDate.AddDays(GetGuideDays());
+
+        return new GuideInfo
+        {
+            StartDate = startDate,
+            EndDate = endDate
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task RefreshGuide(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(progress);
+
+        await _recordingsManager.CreateRecordingFolders().ConfigureAwait(false);
+
+        await _tunerHostManager.ScanForTunerDeviceChanges(cancellationToken).ConfigureAwait(false);
+
+        var numComplete = 0;
+        double progressPerService = _liveTvManager.Services.Count == 0
+            ? 0
+            : 1.0 / _liveTvManager.Services.Count;
+
+        var newChannelIdList = new List<Guid>();
+        var newProgramIdList = new List<Guid>();
+
+        var cleanDatabase = true;
+
+        foreach (var service in _liveTvManager.Services)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            _logger.LogDebug("Refreshing guide from {Name}", service.Name);
+
+            try
+            {
+                var innerProgress = new Progress<double>(p => progress.Report(p * progressPerService));
+
+                var idList = await RefreshChannelsInternal(service, innerProgress, cancellationToken).ConfigureAwait(false);
+
+                newChannelIdList.AddRange(idList.Item1);
+                newProgramIdList.AddRange(idList.Item2);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                cleanDatabase = false;
+                _logger.LogError(ex, "Error refreshing channels for service");
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= _liveTvManager.Services.Count;
+
+            progress.Report(100 * percent);
+        }
+
+        if (cleanDatabase)
+        {
+            CleanDatabase(newChannelIdList.ToArray(), [BaseItemKind.LiveTvChannel], progress, cancellationToken);
+            CleanDatabase(newProgramIdList.ToArray(), [BaseItemKind.LiveTvProgram], progress, cancellationToken);
+        }
+
+        var coreService = _liveTvManager.Services.OfType<DefaultLiveTvService>().FirstOrDefault();
+        if (coreService is not null)
+        {
+            await coreService.RefreshSeriesTimers(cancellationToken).ConfigureAwait(false);
+            await coreService.RefreshTimers(cancellationToken).ConfigureAwait(false);
+        }
+
+        progress.Report(100);
+    }
+
+    private double GetGuideDays()
+    {
+        var config = _config.GetLiveTvConfiguration();
+
+        return config.GuideDays.HasValue
+            ? Math.Clamp(config.GuideDays.Value, 1, MaxGuideDays)
+            : 7;
+    }
+
+    private async Task<Tuple<List<Guid>, List<Guid>>> RefreshChannelsInternal(ILiveTvService service, IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        progress.Report(10);
+
+        var allChannelsList = (await service.GetChannelsAsync(cancellationToken).ConfigureAwait(false))
+            .Select(i => new Tuple<string, ChannelInfo>(service.Name, i))
+            .ToList();
+
+        var list = new List<LiveTvChannel>();
+
+        var numComplete = 0;
+        var parentFolder = _liveTvManager.GetInternalLiveTvFolder(cancellationToken);
+
+        foreach (var channelInfo in allChannelsList)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var item = await GetChannel(channelInfo.Item2, channelInfo.Item1, parentFolder, cancellationToken).ConfigureAwait(false);
+
+                list.Add(item);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error getting channel information for {Name}", channelInfo.Item2.Name);
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= allChannelsList.Count;
+
+            progress.Report((5 * percent) + 10);
+        }
+
+        progress.Report(15);
+
+        numComplete = 0;
+        var programs = new List<Guid>();
+        var channels = new List<Guid>();
+
+        var guideDays = GetGuideDays();
+
+        _logger.LogInformation("Refreshing guide with {0} days of guide data", guideDays);
+
+        foreach (var currentChannel in list)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            channels.Add(currentChannel.Id);
+
+            try
+            {
+                var start = DateTime.UtcNow.AddHours(-1);
+                var end = start.AddDays(guideDays);
+
+                var isMovie = false;
+                var isSports = false;
+                var isNews = false;
+                var isKids = false;
+                var isSeries = false;
+
+                var channelPrograms = (await service.GetProgramsAsync(currentChannel.ExternalId, start, end, cancellationToken).ConfigureAwait(false)).ToList();
+
+                var existingPrograms = _libraryManager.GetItemList(new InternalItemsQuery
+                {
+                    IncludeItemTypes = [BaseItemKind.LiveTvProgram],
+                    ChannelIds = [currentChannel.Id],
+                    DtoOptions = new DtoOptions(true)
+                }).Cast<LiveTvProgram>().ToDictionary(i => i.Id);
+
+                var newPrograms = new List<LiveTvProgram>();
+                var updatedPrograms = new List<BaseItem>();
+
+                foreach (var program in channelPrograms)
+                {
+                    var (programItem, isNew, isUpdated) = GetProgram(program, existingPrograms, currentChannel);
+                    if (isNew)
+                    {
+                        newPrograms.Add(programItem);
+                    }
+                    else if (isUpdated)
+                    {
+                        updatedPrograms.Add(programItem);
+                    }
+
+                    programs.Add(programItem.Id);
+
+                    isMovie |= program.IsMovie;
+                    isSeries |= program.IsSeries;
+                    isSports |= program.IsSports;
+                    isNews |= program.IsNews;
+                    isKids |= program.IsKids;
+                }
+
+                _logger.LogDebug("Channel {0} has {1} new programs and {2} updated programs", currentChannel.Name, newPrograms.Count, updatedPrograms.Count);
+
+                if (newPrograms.Count > 0)
+                {
+                    _libraryManager.CreateItems(newPrograms, null, cancellationToken);
+                }
+
+                if (updatedPrograms.Count > 0)
+                {
+                    await _libraryManager.UpdateItemsAsync(
+                        updatedPrograms,
+                        currentChannel,
+                        ItemUpdateType.MetadataImport,
+                        cancellationToken).ConfigureAwait(false);
+                }
+
+                currentChannel.IsMovie = isMovie;
+                currentChannel.IsNews = isNews;
+                currentChannel.IsSports = isSports;
+                currentChannel.IsSeries = isSeries;
+
+                if (isKids)
+                {
+                    currentChannel.AddTag("Kids");
+                }
+
+                await currentChannel.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
+                await currentChannel.RefreshMetadata(
+                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                    {
+                        ForceSave = true
+                    },
+                    cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error getting programs for channel {Name}", currentChannel.Name);
+            }
+
+            numComplete++;
+            double percent = numComplete / (double)allChannelsList.Count;
+
+            progress.Report((85 * percent) + 15);
+        }
+
+        progress.Report(100);
+        return new Tuple<List<Guid>, List<Guid>>(channels, programs);
+    }
+
+    private void CleanDatabase(Guid[] currentIdList, BaseItemKind[] validTypes, IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var list = _itemRepo.GetItemIdsList(new InternalItemsQuery
+        {
+            IncludeItemTypes = validTypes,
+            DtoOptions = new DtoOptions(false)
+        });
+
+        var numComplete = 0;
+
+        foreach (var itemId in list)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (itemId.IsEmpty())
+            {
+                // Somehow some invalid data got into the db. It probably predates the boundary checking
+                continue;
+            }
+
+            if (!currentIdList.Contains(itemId))
+            {
+                var item = _libraryManager.GetItemById(itemId);
+
+                if (item is not null)
+                {
+                    _libraryManager.DeleteItem(
+                        item,
+                        new DeleteOptions
+                        {
+                            DeleteFileLocation = false,
+                            DeleteFromExternalProvider = false
+                        },
+                        false);
+                }
+            }
+
+            numComplete++;
+            double percent = numComplete / (double)list.Count;
+
+            progress.Report(100 * percent);
+        }
+    }
+
+    private async Task<LiveTvChannel> GetChannel(
+        ChannelInfo channelInfo,
+        string serviceName,
+        BaseItem parentFolder,
+        CancellationToken cancellationToken)
+    {
+        var parentFolderId = parentFolder.Id;
+        var isNew = false;
+        var forceUpdate = false;
+
+        var id = _tvDtoService.GetInternalChannelId(serviceName, channelInfo.Id);
+
+        if (_libraryManager.GetItemById(id) is not LiveTvChannel item)
+        {
+            item = new LiveTvChannel
+            {
+                Name = channelInfo.Name,
+                Id = id,
+                DateCreated = DateTime.UtcNow
+            };
+
+            isNew = true;
+        }
+
+        if (channelInfo.Tags is not null)
+        {
+            if (!channelInfo.Tags.SequenceEqual(item.Tags, StringComparer.OrdinalIgnoreCase))
+            {
+                isNew = true;
+            }
+
+            item.Tags = channelInfo.Tags;
+        }
+
+        if (!item.ParentId.Equals(parentFolderId))
+        {
+            isNew = true;
+        }
+
+        item.ParentId = parentFolderId;
+
+        item.ChannelType = channelInfo.ChannelType;
+        item.ServiceName = serviceName;
+
+        if (!string.Equals(item.GetProviderId(ExternalServiceTag), serviceName, StringComparison.OrdinalIgnoreCase))
+        {
+            forceUpdate = true;
+        }
+
+        item.SetProviderId(ExternalServiceTag, serviceName);
+
+        if (!string.Equals(channelInfo.Id, item.ExternalId, StringComparison.Ordinal))
+        {
+            forceUpdate = true;
+        }
+
+        item.ExternalId = channelInfo.Id;
+
+        if (!string.Equals(channelInfo.Number, item.Number, StringComparison.Ordinal))
+        {
+            forceUpdate = true;
+        }
+
+        item.Number = channelInfo.Number;
+
+        if (!string.Equals(channelInfo.Name, item.Name, StringComparison.Ordinal))
+        {
+            forceUpdate = true;
+        }
+
+        item.Name = channelInfo.Name;
+
+        if (!item.HasImage(ImageType.Primary))
+        {
+            if (!string.IsNullOrWhiteSpace(channelInfo.ImagePath))
+            {
+                item.SetImagePath(ImageType.Primary, channelInfo.ImagePath);
+                forceUpdate = true;
+            }
+            else if (!string.IsNullOrWhiteSpace(channelInfo.ImageUrl))
+            {
+                item.SetImagePath(ImageType.Primary, channelInfo.ImageUrl);
+                forceUpdate = true;
+            }
+        }
+
+        if (isNew)
+        {
+            _libraryManager.CreateItem(item, parentFolder);
+        }
+        else if (forceUpdate)
+        {
+            await _libraryManager.UpdateItemAsync(item, parentFolder, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
+        }
+
+        return item;
+    }
+
+    private (LiveTvProgram Item, bool IsNew, bool IsUpdated) GetProgram(
+        ProgramInfo info,
+        Dictionary<Guid, LiveTvProgram> allExistingPrograms,
+        LiveTvChannel channel)
+    {
+        var id = _tvDtoService.GetInternalProgramId(info.Id);
+
+        var isNew = false;
+        var forceUpdate = false;
+
+        if (!allExistingPrograms.TryGetValue(id, out var item))
+        {
+            isNew = true;
+            item = new LiveTvProgram
+            {
+                Name = info.Name,
+                Id = id,
+                DateCreated = DateTime.UtcNow,
+                DateModified = DateTime.UtcNow
+            };
+
+            if (!string.IsNullOrEmpty(info.Etag))
+            {
+                item.SetProviderId(EtagKey, info.Etag);
+            }
+        }
+
+        if (!string.Equals(info.ShowId, item.ShowId, StringComparison.OrdinalIgnoreCase))
+        {
+            item.ShowId = info.ShowId;
+            forceUpdate = true;
+        }
+
+        var seriesId = info.SeriesId;
+
+        if (!item.ParentId.Equals(channel.Id))
+        {
+            forceUpdate = true;
+        }
+
+        item.ParentId = channel.Id;
+
+        item.Audio = info.Audio;
+        item.ChannelId = channel.Id;
+        item.CommunityRating ??= info.CommunityRating;
+        if ((item.CommunityRating ?? 0).Equals(0))
+        {
+            item.CommunityRating = null;
+        }
+
+        item.EpisodeTitle = info.EpisodeTitle;
+        item.ExternalId = info.Id;
+
+        if (!string.IsNullOrWhiteSpace(seriesId) && !string.Equals(item.ExternalSeriesId, seriesId, StringComparison.Ordinal))
+        {
+            forceUpdate = true;
+        }
+
+        item.ExternalSeriesId = seriesId;
+
+        var isSeries = info.IsSeries || !string.IsNullOrEmpty(info.EpisodeTitle);
+
+        if (isSeries || !string.IsNullOrEmpty(info.EpisodeTitle))
+        {
+            item.SeriesName = info.Name;
+        }
+
+        var tags = new List<string>();
+        if (info.IsLive)
+        {
+            tags.Add("Live");
+        }
+
+        if (info.IsPremiere)
+        {
+            tags.Add("Premiere");
+        }
+
+        if (info.IsNews)
+        {
+            tags.Add("News");
+        }
+
+        if (info.IsSports)
+        {
+            tags.Add("Sports");
+        }
+
+        if (info.IsKids)
+        {
+            tags.Add("Kids");
+        }
+
+        if (info.IsRepeat)
+        {
+            tags.Add("Repeat");
+        }
+
+        if (info.IsMovie)
+        {
+            tags.Add("Movie");
+        }
+
+        if (isSeries)
+        {
+            tags.Add("Series");
+        }
+
+        item.Tags = tags.ToArray();
+
+        item.Genres = info.Genres.ToArray();
+
+        if (info.IsHD ?? false)
+        {
+            item.Width = 1280;
+            item.Height = 720;
+        }
+
+        item.IsMovie = info.IsMovie;
+        item.IsRepeat = info.IsRepeat;
+
+        if (item.IsSeries != isSeries)
+        {
+            forceUpdate = true;
+        }
+
+        item.IsSeries = isSeries;
+
+        item.Name = info.Name;
+        item.OfficialRating ??= info.OfficialRating;
+        item.Overview ??= info.Overview;
+        item.RunTimeTicks = (info.EndDate - info.StartDate).Ticks;
+        item.ProviderIds = info.ProviderIds;
+
+        foreach (var providerId in info.SeriesProviderIds)
+        {
+            info.ProviderIds["Series" + providerId.Key] = providerId.Value;
+        }
+
+        if (item.StartDate != info.StartDate)
+        {
+            forceUpdate = true;
+        }
+
+        item.StartDate = info.StartDate;
+
+        if (item.EndDate != info.EndDate)
+        {
+            forceUpdate = true;
+        }
+
+        item.EndDate = info.EndDate;
+
+        item.ProductionYear = info.ProductionYear;
+
+        if (!isSeries || info.IsRepeat)
+        {
+            item.PremiereDate = info.OriginalAirDate;
+        }
+
+        item.IndexNumber = info.EpisodeNumber;
+        item.ParentIndexNumber = info.SeasonNumber;
+
+        if (!item.HasImage(ImageType.Primary))
+        {
+            if (!string.IsNullOrWhiteSpace(info.ImagePath))
+            {
+                item.SetImage(
+                    new ItemImageInfo
+                    {
+                        Path = info.ImagePath,
+                        Type = ImageType.Primary
+                    },
+                    0);
+            }
+            else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
+            {
+                item.SetImage(
+                    new ItemImageInfo
+                    {
+                        Path = info.ImageUrl,
+                        Type = ImageType.Primary
+                    },
+                    0);
+            }
+        }
+
+        if (!item.HasImage(ImageType.Thumb))
+        {
+            if (!string.IsNullOrWhiteSpace(info.ThumbImageUrl))
+            {
+                item.SetImage(
+                    new ItemImageInfo
+                    {
+                        Path = info.ThumbImageUrl,
+                        Type = ImageType.Thumb
+                    },
+                    0);
+            }
+        }
+
+        if (!item.HasImage(ImageType.Logo))
+        {
+            if (!string.IsNullOrWhiteSpace(info.LogoImageUrl))
+            {
+                item.SetImage(
+                    new ItemImageInfo
+                    {
+                        Path = info.LogoImageUrl,
+                        Type = ImageType.Logo
+                    },
+                    0);
+            }
+        }
+
+        if (!item.HasImage(ImageType.Backdrop))
+        {
+            if (!string.IsNullOrWhiteSpace(info.BackdropImageUrl))
+            {
+                item.SetImage(
+                    new ItemImageInfo
+                    {
+                        Path = info.BackdropImageUrl,
+                        Type = ImageType.Backdrop
+                    },
+                    0);
+            }
+        }
+
+        var isUpdated = false;
+        if (isNew)
+        {
+        }
+        else if (forceUpdate || string.IsNullOrWhiteSpace(info.Etag))
+        {
+            isUpdated = true;
+        }
+        else
+        {
+            var etag = info.Etag;
+
+            if (!string.Equals(etag, item.GetProviderId(EtagKey), StringComparison.OrdinalIgnoreCase))
+            {
+                item.SetProviderId(EtagKey, etag);
+                isUpdated = true;
+            }
+        }
+
+        if (isNew || isUpdated)
+        {
+            item.OnMetadataChanged();
+        }
+
+        return (item, isNew, isUpdated);
+    }
+}
diff --git a/src/Jellyfin.LiveTv/Guide/RefreshGuideScheduledTask.cs b/src/Jellyfin.LiveTv/Guide/RefreshGuideScheduledTask.cs
new file mode 100644
index 000000000..a9fde0850
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Guide/RefreshGuideScheduledTask.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.LiveTv.Configuration;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Tasks;
+
+namespace Jellyfin.LiveTv.Guide;
+
+/// <summary>
+/// The "Refresh Guide" scheduled task.
+/// </summary>
+public class RefreshGuideScheduledTask : IScheduledTask, IConfigurableScheduledTask
+{
+    private readonly ILiveTvManager _liveTvManager;
+    private readonly IGuideManager _guideManager;
+    private readonly IConfigurationManager _config;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RefreshGuideScheduledTask"/> class.
+    /// </summary>
+    /// <param name="liveTvManager">The live tv manager.</param>
+    /// <param name="guideManager">The guide manager.</param>
+    /// <param name="config">The configuration manager.</param>
+    public RefreshGuideScheduledTask(
+        ILiveTvManager liveTvManager,
+        IGuideManager guideManager,
+        IConfigurationManager config)
+    {
+        _liveTvManager = liveTvManager;
+        _guideManager = guideManager;
+        _config = config;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Refresh Guide";
+
+    /// <inheritdoc />
+    public string Description => "Downloads channel information from live tv services.";
+
+    /// <inheritdoc />
+    public string Category => "Live TV";
+
+    /// <inheritdoc />
+    public bool IsHidden => _liveTvManager.Services.Count == 1 && _config.GetLiveTvConfiguration().TunerHosts.Length == 0;
+
+    /// <inheritdoc />
+    public bool IsEnabled => true;
+
+    /// <inheritdoc />
+    public bool IsLogged => true;
+
+    /// <inheritdoc />
+    public string Key => "RefreshGuide";
+
+    /// <inheritdoc />
+    public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+        => _guideManager.RefreshGuide(progress, cancellationToken);
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromHours(24).Ticks
+            }
+        };
+    }
+}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/DirectRecorder.cs b/src/Jellyfin.LiveTv/IO/DirectRecorder.cs
index 2a25218b6..c4ec6de40 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/DirectRecorder.cs
+++ b/src/Jellyfin.LiveTv/IO/DirectRecorder.cs
@@ -12,7 +12,7 @@ using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.IO
 {
     public sealed class DirectRecorder : IRecorder
     {
diff --git a/src/Jellyfin.LiveTv/EmbyTV/EncodedRecorder.cs b/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs
index 132a5fc51..ff00c8999 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/EncodedRecorder.cs
+++ b/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs
@@ -23,7 +23,7 @@ using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.IO
 {
     public class EncodedRecorder : IRecorder
     {
diff --git a/src/Jellyfin.LiveTv/ExclusiveLiveStream.cs b/src/Jellyfin.LiveTv/IO/ExclusiveLiveStream.cs
index 9d442e20c..394b9cf11 100644
--- a/src/Jellyfin.LiveTv/ExclusiveLiveStream.cs
+++ b/src/Jellyfin.LiveTv/IO/ExclusiveLiveStream.cs
@@ -11,7 +11,7 @@ using System.Threading.Tasks;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Dto;
 
-namespace Jellyfin.LiveTv
+namespace Jellyfin.LiveTv.IO
 {
     public sealed class ExclusiveLiveStream : ILiveStream
     {
diff --git a/src/Jellyfin.LiveTv/EmbyTV/IRecorder.cs b/src/Jellyfin.LiveTv/IO/IRecorder.cs
index 7ed42e263..ab4506414 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/IRecorder.cs
+++ b/src/Jellyfin.LiveTv/IO/IRecorder.cs
@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Dto;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.IO
 {
     public interface IRecorder : IDisposable
     {
diff --git a/src/Jellyfin.LiveTv/StreamHelper.cs b/src/Jellyfin.LiveTv/IO/StreamHelper.cs
index e9644e95e..7947807ba 100644
--- a/src/Jellyfin.LiveTv/StreamHelper.cs
+++ b/src/Jellyfin.LiveTv/IO/StreamHelper.cs
@@ -7,7 +7,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Model.IO;
 
-namespace Jellyfin.LiveTv
+namespace Jellyfin.LiveTv.IO
 {
     public class StreamHelper : IStreamHelper
     {
diff --git a/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj b/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
index 5a826a1da..c58889740 100644
--- a/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
+++ b/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -11,6 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="AsyncKeyedLock" />
     <PackageReference Include="Jellyfin.XmlTv" />
     <PackageReference Include="System.Linq.Async" />
   </ItemGroup>
diff --git a/src/Jellyfin.LiveTv/EmbyTV/EpgChannelData.cs b/src/Jellyfin.LiveTv/Listings/EpgChannelData.cs
index 43d308c43..81437f791 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/EpgChannelData.cs
+++ b/src/Jellyfin.LiveTv/Listings/EpgChannelData.cs
@@ -4,7 +4,7 @@ using System;
 using System.Collections.Generic;
 using MediaBrowser.Controller.LiveTv;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.Listings
 {
     internal class EpgChannelData
     {
diff --git a/src/Jellyfin.LiveTv/Listings/ListingsManager.cs b/src/Jellyfin.LiveTv/Listings/ListingsManager.cs
new file mode 100644
index 000000000..87f47611e
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Listings/ListingsManager.cs
@@ -0,0 +1,461 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.LiveTv.Configuration;
+using Jellyfin.LiveTv.Guide;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.LiveTv;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv.Listings;
+
+/// <inheritdoc />
+public class ListingsManager : IListingsManager
+{
+    private readonly ILogger<ListingsManager> _logger;
+    private readonly IConfigurationManager _config;
+    private readonly ITaskManager _taskManager;
+    private readonly ITunerHostManager _tunerHostManager;
+    private readonly IListingsProvider[] _listingsProviders;
+
+    private readonly ConcurrentDictionary<string, EpgChannelData> _epgChannels = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ListingsManager"/> class.
+    /// </summary>
+    /// <param name="logger">The <see cref="ILogger{TCategoryName}"/>.</param>
+    /// <param name="config">The <see cref="IConfigurationManager"/>.</param>
+    /// <param name="taskManager">The <see cref="ITaskManager"/>.</param>
+    /// <param name="tunerHostManager">The <see cref="ITunerHostManager"/>.</param>
+    /// <param name="listingsProviders">The <see cref="IListingsProvider"/>.</param>
+    public ListingsManager(
+        ILogger<ListingsManager> logger,
+        IConfigurationManager config,
+        ITaskManager taskManager,
+        ITunerHostManager tunerHostManager,
+        IEnumerable<IListingsProvider> listingsProviders)
+    {
+        _logger = logger;
+        _config = config;
+        _taskManager = taskManager;
+        _tunerHostManager = tunerHostManager;
+        _listingsProviders = listingsProviders.ToArray();
+    }
+
+    /// <inheritdoc />
+    public async Task<ListingsProviderInfo> SaveListingProvider(ListingsProviderInfo info, bool validateLogin, bool validateListings)
+    {
+        ArgumentNullException.ThrowIfNull(info);
+
+        var provider = GetProvider(info.Type);
+        await provider.Validate(info, validateLogin, validateListings).ConfigureAwait(false);
+
+        var config = _config.GetLiveTvConfiguration();
+
+        var list = config.ListingProviders.ToList();
+        int index = list.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
+
+        if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
+        {
+            info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
+            list.Add(info);
+            config.ListingProviders = list.ToArray();
+        }
+        else
+        {
+            config.ListingProviders[index] = info;
+        }
+
+        _config.SaveConfiguration("livetv", config);
+        _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
+
+        return info;
+    }
+
+    /// <inheritdoc />
+    public void DeleteListingsProvider(string? id)
+    {
+        var config = _config.GetLiveTvConfiguration();
+
+        config.ListingProviders = config.ListingProviders.Where(i => !string.Equals(id, i.Id, StringComparison.OrdinalIgnoreCase)).ToArray();
+
+        _config.SaveConfiguration("livetv", config);
+        _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
+    }
+
+    /// <inheritdoc />
+    public Task<List<NameIdPair>> GetLineups(string? providerType, string? providerId, string? country, string? location)
+    {
+        if (string.IsNullOrWhiteSpace(providerId))
+        {
+            return GetProvider(providerType).GetLineups(null, country, location);
+        }
+
+        var info = _config.GetLiveTvConfiguration().ListingProviders
+            .FirstOrDefault(i => string.Equals(i.Id, providerId, StringComparison.OrdinalIgnoreCase))
+            ?? throw new ResourceNotFoundException();
+
+        return GetProvider(info.Type).GetLineups(info, country, location);
+    }
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<ProgramInfo>> GetProgramsAsync(
+        ChannelInfo channel,
+        DateTime startDateUtc,
+        DateTime endDateUtc,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(channel);
+
+        foreach (var (provider, providerInfo) in GetListingProviders())
+        {
+            if (!IsListingProviderEnabledForTuner(providerInfo, channel.TunerHostId))
+            {
+                _logger.LogDebug(
+                    "Skipping getting programs for channel {0}-{1} from {2}-{3}, because it's not enabled for this tuner.",
+                    channel.Number,
+                    channel.Name,
+                    provider.Name,
+                    providerInfo.ListingsId ?? string.Empty);
+                continue;
+            }
+
+            _logger.LogDebug(
+                "Getting programs for channel {0}-{1} from {2}-{3}",
+                channel.Number,
+                channel.Name,
+                provider.Name,
+                providerInfo.ListingsId ?? string.Empty);
+
+            var epgChannels = await GetEpgChannels(provider, providerInfo, true, cancellationToken).ConfigureAwait(false);
+
+            var epgChannel = GetEpgChannelFromTunerChannel(providerInfo.ChannelMappings, channel, epgChannels);
+            if (epgChannel is null)
+            {
+                _logger.LogDebug("EPG channel not found for tuner channel {0}-{1} from {2}-{3}", channel.Number, channel.Name, provider.Name, providerInfo.ListingsId ?? string.Empty);
+                continue;
+            }
+
+            var programs = (await provider
+                .GetProgramsAsync(providerInfo, epgChannel.Id, startDateUtc, endDateUtc, cancellationToken).ConfigureAwait(false))
+                .ToList();
+
+            // Replace the value that came from the provider with a normalized value
+            foreach (var program in programs)
+            {
+                program.ChannelId = channel.Id;
+                program.Id += "_" + channel.Id;
+            }
+
+            if (programs.Count > 0)
+            {
+                return programs;
+            }
+        }
+
+        return Enumerable.Empty<ProgramInfo>();
+    }
+
+    /// <inheritdoc />
+    public async Task AddProviderMetadata(IList<ChannelInfo> channels, bool enableCache, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(channels);
+
+        foreach (var (provider, providerInfo) in GetListingProviders())
+        {
+            var enabledChannels = channels
+                .Where(i => IsListingProviderEnabledForTuner(providerInfo, i.TunerHostId))
+                .ToList();
+
+            if (enabledChannels.Count == 0)
+            {
+                continue;
+            }
+
+            try
+            {
+                await AddMetadata(provider, providerInfo, enabledChannels, enableCache, cancellationToken).ConfigureAwait(false);
+            }
+            catch (NotSupportedException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error adding metadata");
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<ChannelMappingOptionsDto> GetChannelMappingOptions(string? providerId)
+    {
+        var listingsProviderInfo = _config.GetLiveTvConfiguration().ListingProviders
+            .First(info => string.Equals(providerId, info.Id, StringComparison.OrdinalIgnoreCase));
+
+        var provider = GetProvider(listingsProviderInfo.Type);
+
+        var tunerChannels = await GetChannelsForListingsProvider(listingsProviderInfo, CancellationToken.None)
+            .ConfigureAwait(false);
+
+        var providerChannels = await provider.GetChannels(listingsProviderInfo, default)
+            .ConfigureAwait(false);
+
+        var mappings = listingsProviderInfo.ChannelMappings;
+
+        return new ChannelMappingOptionsDto
+        {
+            TunerChannels = tunerChannels.Select(i => GetTunerChannelMapping(i, mappings, providerChannels)).ToList(),
+            ProviderChannels = providerChannels.Select(i => new NameIdPair
+            {
+                Name = i.Name,
+                Id = i.Id
+            }).ToList(),
+            Mappings = mappings,
+            ProviderName = provider.Name
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<TunerChannelMapping> SetChannelMapping(string providerId, string tunerChannelNumber, string providerChannelNumber)
+    {
+        var config = _config.GetLiveTvConfiguration();
+
+        var listingsProviderInfo = config.ListingProviders
+            .First(info => string.Equals(providerId, info.Id, StringComparison.OrdinalIgnoreCase));
+
+        listingsProviderInfo.ChannelMappings = listingsProviderInfo.ChannelMappings
+            .Where(pair => !string.Equals(pair.Name, tunerChannelNumber, StringComparison.OrdinalIgnoreCase)).ToArray();
+
+        if (!string.Equals(tunerChannelNumber, providerChannelNumber, StringComparison.OrdinalIgnoreCase))
+        {
+            var list = listingsProviderInfo.ChannelMappings.ToList();
+            list.Add(new NameValuePair
+            {
+                Name = tunerChannelNumber,
+                Value = providerChannelNumber
+            });
+            listingsProviderInfo.ChannelMappings = list.ToArray();
+        }
+
+        _config.SaveConfiguration("livetv", config);
+
+        var tunerChannels = await GetChannelsForListingsProvider(listingsProviderInfo, CancellationToken.None)
+            .ConfigureAwait(false);
+
+        var providerChannels = await GetProvider(listingsProviderInfo.Type).GetChannels(listingsProviderInfo, default)
+            .ConfigureAwait(false);
+
+        var tunerChannelMappings = tunerChannels
+            .Select(i => GetTunerChannelMapping(i, listingsProviderInfo.ChannelMappings, providerChannels)).ToList();
+
+        _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
+
+        return tunerChannelMappings.First(i => string.Equals(i.Id, tunerChannelNumber, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private List<(IListingsProvider Provider, ListingsProviderInfo ProviderInfo)> GetListingProviders()
+        => _config.GetLiveTvConfiguration().ListingProviders
+            .Select(info => (
+                Provider: _listingsProviders.FirstOrDefault(l
+                    => string.Equals(l.Type, info.Type, StringComparison.OrdinalIgnoreCase)),
+                ProviderInfo: info))
+            .Where(i => i.Provider is not null)
+            .ToList()!; // Already filtered out null
+
+    private async Task AddMetadata(
+        IListingsProvider provider,
+        ListingsProviderInfo info,
+        IEnumerable<ChannelInfo> tunerChannels,
+        bool enableCache,
+        CancellationToken cancellationToken)
+    {
+        var epgChannels = await GetEpgChannels(provider, info, enableCache, cancellationToken).ConfigureAwait(false);
+
+        foreach (var tunerChannel in tunerChannels)
+        {
+            var epgChannel = GetEpgChannelFromTunerChannel(info.ChannelMappings, tunerChannel, epgChannels);
+            if (epgChannel is null)
+            {
+                continue;
+            }
+
+            if (!string.IsNullOrWhiteSpace(epgChannel.ImageUrl))
+            {
+                tunerChannel.ImageUrl = epgChannel.ImageUrl;
+            }
+        }
+    }
+
+    private static bool IsListingProviderEnabledForTuner(ListingsProviderInfo info, string tunerHostId)
+    {
+        if (info.EnableAllTuners)
+        {
+            return true;
+        }
+
+        ArgumentException.ThrowIfNullOrWhiteSpace(tunerHostId);
+
+        return info.EnabledTuners.Contains(tunerHostId, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private static string GetMappedChannel(string channelId, NameValuePair[] mappings)
+    {
+        foreach (NameValuePair mapping in mappings)
+        {
+            if (string.Equals(mapping.Name, channelId, StringComparison.OrdinalIgnoreCase))
+            {
+                return mapping.Value;
+            }
+        }
+
+        return channelId;
+    }
+
+    private async Task<EpgChannelData> GetEpgChannels(
+        IListingsProvider provider,
+        ListingsProviderInfo info,
+        bool enableCache,
+        CancellationToken cancellationToken)
+    {
+        if (enableCache && _epgChannels.TryGetValue(info.Id, out var result))
+        {
+            return result;
+        }
+
+        var channels = await provider.GetChannels(info, cancellationToken).ConfigureAwait(false);
+        foreach (var channel in channels)
+        {
+            _logger.LogInformation("Found epg channel in {0} {1} {2} {3}", provider.Name, info.ListingsId, channel.Name, channel.Id);
+        }
+
+        result = new EpgChannelData(channels);
+        _epgChannels.AddOrUpdate(info.Id, result, (_, _) => result);
+
+        return result;
+    }
+
+    private static ChannelInfo? GetEpgChannelFromTunerChannel(
+        NameValuePair[] mappings,
+        ChannelInfo tunerChannel,
+        EpgChannelData epgChannelData)
+    {
+        if (!string.IsNullOrWhiteSpace(tunerChannel.Id))
+        {
+            var mappedTunerChannelId = GetMappedChannel(tunerChannel.Id, mappings);
+            if (string.IsNullOrWhiteSpace(mappedTunerChannelId))
+            {
+                mappedTunerChannelId = tunerChannel.Id;
+            }
+
+            var channel = epgChannelData.GetChannelById(mappedTunerChannelId);
+            if (channel is not null)
+            {
+                return channel;
+            }
+        }
+
+        if (!string.IsNullOrWhiteSpace(tunerChannel.TunerChannelId))
+        {
+            var tunerChannelId = tunerChannel.TunerChannelId;
+            if (tunerChannelId.Contains(".json.schedulesdirect.org", StringComparison.OrdinalIgnoreCase))
+            {
+                tunerChannelId = tunerChannelId.Replace(".json.schedulesdirect.org", string.Empty, StringComparison.OrdinalIgnoreCase).TrimStart('I');
+            }
+
+            var mappedTunerChannelId = GetMappedChannel(tunerChannelId, mappings);
+            if (string.IsNullOrWhiteSpace(mappedTunerChannelId))
+            {
+                mappedTunerChannelId = tunerChannelId;
+            }
+
+            var channel = epgChannelData.GetChannelById(mappedTunerChannelId);
+            if (channel is not null)
+            {
+                return channel;
+            }
+        }
+
+        if (!string.IsNullOrWhiteSpace(tunerChannel.Number))
+        {
+            var tunerChannelNumber = GetMappedChannel(tunerChannel.Number, mappings);
+            if (string.IsNullOrWhiteSpace(tunerChannelNumber))
+            {
+                tunerChannelNumber = tunerChannel.Number;
+            }
+
+            var channel = epgChannelData.GetChannelByNumber(tunerChannelNumber);
+            if (channel is not null)
+            {
+                return channel;
+            }
+        }
+
+        if (!string.IsNullOrWhiteSpace(tunerChannel.Name))
+        {
+            var normalizedName = EpgChannelData.NormalizeName(tunerChannel.Name);
+
+            var channel = epgChannelData.GetChannelByName(normalizedName);
+            if (channel is not null)
+            {
+                return channel;
+            }
+        }
+
+        return null;
+    }
+
+    private static TunerChannelMapping GetTunerChannelMapping(ChannelInfo tunerChannel, NameValuePair[] mappings, IList<ChannelInfo> providerChannels)
+    {
+        var result = new TunerChannelMapping
+        {
+            Name = tunerChannel.Name,
+            Id = tunerChannel.Id
+        };
+
+        if (!string.IsNullOrWhiteSpace(tunerChannel.Number))
+        {
+            result.Name = tunerChannel.Number + " " + result.Name;
+        }
+
+        var providerChannel = GetEpgChannelFromTunerChannel(mappings, tunerChannel, new EpgChannelData(providerChannels));
+        if (providerChannel is not null)
+        {
+            result.ProviderChannelName = providerChannel.Name;
+            result.ProviderChannelId = providerChannel.Id;
+        }
+
+        return result;
+    }
+
+    private async Task<List<ChannelInfo>> GetChannelsForListingsProvider(ListingsProviderInfo info, CancellationToken cancellationToken)
+    {
+        var channels = new List<ChannelInfo>();
+        foreach (var hostInstance in _tunerHostManager.TunerHosts)
+        {
+            try
+            {
+                var tunerChannels = await hostInstance.GetChannels(false, cancellationToken).ConfigureAwait(false);
+
+                channels.AddRange(tunerChannels.Where(channel => IsListingProviderEnabledForTuner(info, channel.TunerHostId)));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error getting channels");
+            }
+        }
+
+        return channels;
+    }
+
+    private IListingsProvider GetProvider(string? providerType)
+        => _listingsProviders.FirstOrDefault(i => string.Equals(providerType, i.Type, StringComparison.OrdinalIgnoreCase))
+           ?? throw new ResourceNotFoundException($"Couldn't find provider of type {providerType}");
+}
diff --git a/src/Jellyfin.LiveTv/Listings/SchedulesDirect.cs b/src/Jellyfin.LiveTv/Listings/SchedulesDirect.cs
index 3b20cd160..c7a57859e 100644
--- a/src/Jellyfin.LiveTv/Listings/SchedulesDirect.cs
+++ b/src/Jellyfin.LiveTv/Listings/SchedulesDirect.cs
@@ -16,6 +16,7 @@ using System.Text;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using AsyncKeyedLock;
 using Jellyfin.Extensions;
 using Jellyfin.Extensions.Json;
 using Jellyfin.LiveTv.Listings.SchedulesDirectDtos;
@@ -35,7 +36,7 @@ namespace Jellyfin.LiveTv.Listings
 
         private readonly ILogger<SchedulesDirect> _logger;
         private readonly IHttpClientFactory _httpClientFactory;
-        private readonly SemaphoreSlim _tokenSemaphore = new SemaphoreSlim(1, 1);
+        private readonly AsyncNonKeyedLocker _tokenLock = new(1);
 
         private readonly ConcurrentDictionary<string, NameValuePair> _tokens = new ConcurrentDictionary<string, NameValuePair>();
         private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
@@ -105,8 +106,7 @@ namespace Jellyfin.LiveTv.Listings
             using var options = new HttpRequestMessage(HttpMethod.Post, ApiUrl + "/schedules");
             options.Content = JsonContent.Create(requestList, options: _jsonOptions);
             options.Headers.TryAddWithoutValidation("token", token);
-            using var response = await Send(options, true, info, cancellationToken).ConfigureAwait(false);
-            var dailySchedules = await response.Content.ReadFromJsonAsync<IReadOnlyList<DayDto>>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+            var dailySchedules = await Request<IReadOnlyList<DayDto>>(options, true, info, cancellationToken).ConfigureAwait(false);
             if (dailySchedules is null)
             {
                 return Array.Empty<ProgramInfo>();
@@ -120,8 +120,8 @@ namespace Jellyfin.LiveTv.Listings
             var programIds = dailySchedules.SelectMany(d => d.Programs.Select(s => s.ProgramId)).Distinct();
             programRequestOptions.Content = JsonContent.Create(programIds, options: _jsonOptions);
 
-            using var innerResponse = await Send(programRequestOptions, true, info, cancellationToken).ConfigureAwait(false);
-            var programDetails = await innerResponse.Content.ReadFromJsonAsync<IReadOnlyList<ProgramDetailsDto>>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+            var programDetails = await Request<IReadOnlyList<ProgramDetailsDto>>(programRequestOptions, true, info, cancellationToken)
+                    .ConfigureAwait(false);
             if (programDetails is null)
             {
                 return Array.Empty<ProgramInfo>();
@@ -471,16 +471,13 @@ namespace Jellyfin.LiveTv.Listings
             str.Length--;
             str.Append(']');
 
-            using var message = new HttpRequestMessage(HttpMethod.Post, ApiUrl + "/metadata/programs")
-            {
-                Content = new StringContent(str.ToString(), Encoding.UTF8, MediaTypeNames.Application.Json)
-            };
+            using var message = new HttpRequestMessage(HttpMethod.Post, ApiUrl + "/metadata/programs");
             message.Headers.TryAddWithoutValidation("token", token);
+            message.Content = new StringContent(str.ToString(), Encoding.UTF8, MediaTypeNames.Application.Json);
 
             try
             {
-                using var innerResponse2 = await Send(message, true, info, cancellationToken).ConfigureAwait(false);
-                return await innerResponse2.Content.ReadFromJsonAsync<IReadOnlyList<ShowImagesDto>>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+                return await Request<IReadOnlyList<ShowImagesDto>>(message, true, info, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -506,8 +503,7 @@ namespace Jellyfin.LiveTv.Listings
 
             try
             {
-                using var httpResponse = await Send(options, false, info, cancellationToken).ConfigureAwait(false);
-                var root = await httpResponse.Content.ReadFromJsonAsync<IReadOnlyList<HeadendsDto>>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+                var root = await Request<IReadOnlyList<HeadendsDto>>(options, false, info, cancellationToken).ConfigureAwait(false);
                 if (root is not null)
                 {
                     foreach (HeadendsDto headend in root)
@@ -573,60 +569,64 @@ namespace Jellyfin.LiveTv.Listings
                 }
             }
 
-            await _tokenSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
-            try
-            {
-                var result = await GetTokenInternal(username, password, cancellationToken).ConfigureAwait(false);
-                savedToken.Name = result;
-                savedToken.Value = DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
-                return result;
-            }
-            catch (HttpRequestException ex)
+            using (await _tokenLock.LockAsync(cancellationToken).ConfigureAwait(false))
             {
-                if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.BadRequest)
+                try
                 {
-                    _tokens.Clear();
-                    _lastErrorResponse = DateTime.UtcNow;
+                    var result = await GetTokenInternal(username, password, cancellationToken).ConfigureAwait(false);
+                    savedToken.Name = result;
+                    savedToken.Value = DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
+                    return result;
                 }
+                catch (HttpRequestException ex)
+                {
+                    if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.BadRequest)
+                    {
+                        _tokens.Clear();
+                        _lastErrorResponse = DateTime.UtcNow;
+                    }
 
-                throw;
-            }
-            finally
-            {
-                _tokenSemaphore.Release();
+                    throw;
+                }
             }
         }
 
-        private async Task<HttpResponseMessage> Send(
-            HttpRequestMessage options,
+        private async Task<T> Request<T>(
+            HttpRequestMessage message,
             bool enableRetry,
             ListingsProviderInfo providerInfo,
             CancellationToken cancellationToken,
             HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
         {
-            var response = await _httpClientFactory.CreateClient(NamedClient.Default)
-                .SendAsync(options, completionOption, cancellationToken).ConfigureAwait(false);
+            using var response = await _httpClientFactory.CreateClient(NamedClient.Default)
+                .SendAsync(message, completionOption, cancellationToken)
+                .ConfigureAwait(false);
             if (response.IsSuccessStatusCode)
             {
-                return response;
+                return await response.Content.ReadFromJsonAsync<T>(_jsonOptions, cancellationToken).ConfigureAwait(false);
             }
 
-            // Response is automatically disposed in the calling function,
-            // so dispose manually if not returning.
-#pragma warning disable IDISP016, IDISP017
-            response.Dispose();
             if (!enableRetry || (int)response.StatusCode >= 500)
             {
+                _logger.LogError(
+                    "Request to {Url} failed with response {Response}",
+                    message.RequestUri,
+                    await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false));
+
                 throw new HttpRequestException(
                     string.Format(CultureInfo.InvariantCulture, "Request failed: {0}", response.ReasonPhrase),
                     null,
                     response.StatusCode);
             }
-#pragma warning restore IDISP016, IDISP017
 
             _tokens.Clear();
-            options.Headers.TryAddWithoutValidation("token", await GetToken(providerInfo, cancellationToken).ConfigureAwait(false));
-            return await Send(options, false, providerInfo, cancellationToken).ConfigureAwait(false);
+            using var retryMessage = new HttpRequestMessage(message.Method, message.RequestUri);
+            retryMessage.Content = message.Content;
+            retryMessage.Headers.TryAddWithoutValidation(
+                "token",
+                await GetToken(providerInfo, cancellationToken).ConfigureAwait(false));
+
+            return await Request<T>(retryMessage, false, providerInfo, cancellationToken).ConfigureAwait(false);
         }
 
         private async Task<string> GetTokenInternal(
@@ -643,9 +643,7 @@ namespace Jellyfin.LiveTv.Listings
             string hashedPassword = Convert.ToHexString(hashedPasswordBytes).ToLowerInvariant();
             options.Content = new StringContent("{\"username\":\"" + username + "\",\"password\":\"" + hashedPassword + "\"}", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-            using var response = await Send(options, false, null, cancellationToken).ConfigureAwait(false);
-            response.EnsureSuccessStatusCode();
-            var root = await response.Content.ReadFromJsonAsync<TokenDto>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+            var root = await Request<TokenDto>(options, false, null, cancellationToken).ConfigureAwait(false);
             if (string.Equals(root?.Message, "OK", StringComparison.Ordinal))
             {
                 _logger.LogInformation("Authenticated with Schedules Direct token: {Token}", root.Token);
@@ -662,11 +660,21 @@ namespace Jellyfin.LiveTv.Listings
             ArgumentException.ThrowIfNullOrEmpty(token);
             ArgumentException.ThrowIfNullOrEmpty(info.ListingsId);
 
-            _logger.LogInformation("Adding new LineUp ");
+            _logger.LogInformation("Adding new lineup {Id}", info.ListingsId);
 
-            using var options = new HttpRequestMessage(HttpMethod.Put, ApiUrl + "/lineups/" + info.ListingsId);
-            options.Headers.TryAddWithoutValidation("token", token);
-            using var response = await _httpClientFactory.CreateClient(NamedClient.Default).SendAsync(options, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+            using var message = new HttpRequestMessage(HttpMethod.Put, ApiUrl + "/lineups/" + info.ListingsId);
+            message.Headers.TryAddWithoutValidation("token", token);
+
+            using var response = await _httpClientFactory.CreateClient(NamedClient.Default)
+                .SendAsync(message, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogError(
+                    "Error adding lineup to account: {Response}",
+                    await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false));
+            }
         }
 
         private async Task<bool> HasLineup(ListingsProviderInfo info, CancellationToken cancellationToken)
@@ -684,9 +692,7 @@ namespace Jellyfin.LiveTv.Listings
 
             try
             {
-                using var httpResponse = await Send(options, false, null, cancellationToken).ConfigureAwait(false);
-                httpResponse.EnsureSuccessStatusCode();
-                var root = await httpResponse.Content.ReadFromJsonAsync<LineupsDto>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+                var root = await Request<LineupsDto>(options, false, null, cancellationToken).ConfigureAwait(false);
                 return root?.Lineups.Any(i => string.Equals(info.ListingsId, i.Lineup, StringComparison.OrdinalIgnoreCase)) ?? false;
             }
             catch (HttpRequestException ex)
@@ -739,8 +745,7 @@ namespace Jellyfin.LiveTv.Listings
             using var options = new HttpRequestMessage(HttpMethod.Get, ApiUrl + "/lineups/" + listingsId);
             options.Headers.TryAddWithoutValidation("token", token);
 
-            using var httpResponse = await Send(options, true, info, cancellationToken).ConfigureAwait(false);
-            var root = await httpResponse.Content.ReadFromJsonAsync<ChannelDto>(_jsonOptions, cancellationToken).ConfigureAwait(false);
+            var root = await Request<ChannelDto>(options, true, info, cancellationToken).ConfigureAwait(false);
             if (root is null)
             {
                 return new List<ChannelInfo>();
@@ -801,7 +806,7 @@ namespace Jellyfin.LiveTv.Listings
 
             if (disposing)
             {
-                _tokenSemaphore?.Dispose();
+                _tokenLock?.Dispose();
             }
 
             _disposed = true;
diff --git a/src/Jellyfin.LiveTv/LiveTvManager.cs b/src/Jellyfin.LiveTv/LiveTvManager.cs
index bada4249a..c19d8195c 100644
--- a/src/Jellyfin.LiveTv/LiveTvManager.cs
+++ b/src/Jellyfin.LiveTv/LiveTvManager.cs
@@ -6,32 +6,25 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Entities;
 using Jellyfin.Data.Enums;
 using Jellyfin.Data.Events;
-using Jellyfin.Extensions;
 using Jellyfin.LiveTv.Configuration;
 using MediaBrowser.Common.Extensions;
-using MediaBrowser.Common.Progress;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Controller.Persistence;
-using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Sorting;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
-using MediaBrowser.Model.IO;
 using MediaBrowser.Model.LiveTv;
 using MediaBrowser.Model.Querying;
-using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.LiveTv
@@ -41,56 +34,46 @@ namespace Jellyfin.LiveTv
     /// </summary>
     public class LiveTvManager : ILiveTvManager
     {
-        private const int MaxGuideDays = 14;
-        private const string ExternalServiceTag = "ExternalServiceId";
-
-        private const string EtagKey = "ProgramEtag";
-
         private readonly IServerConfigurationManager _config;
         private readonly ILogger<LiveTvManager> _logger;
-        private readonly IItemRepository _itemRepo;
         private readonly IUserManager _userManager;
         private readonly IDtoService _dtoService;
         private readonly IUserDataManager _userDataManager;
         private readonly ILibraryManager _libraryManager;
-        private readonly ITaskManager _taskManager;
         private readonly ILocalizationManager _localization;
-        private readonly IFileSystem _fileSystem;
         private readonly IChannelManager _channelManager;
+        private readonly IRecordingsManager _recordingsManager;
         private readonly LiveTvDtoService _tvDtoService;
-        private readonly ITunerHostManager _tunerHostManager;
-
-        private ILiveTvService[] _services = Array.Empty<ILiveTvService>();
-        private IListingsProvider[] _listingProviders = Array.Empty<IListingsProvider>();
+        private readonly ILiveTvService[] _services;
 
         public LiveTvManager(
             IServerConfigurationManager config,
             ILogger<LiveTvManager> logger,
-            IItemRepository itemRepo,
             IUserDataManager userDataManager,
             IDtoService dtoService,
             IUserManager userManager,
             ILibraryManager libraryManager,
-            ITaskManager taskManager,
             ILocalizationManager localization,
-            IFileSystem fileSystem,
             IChannelManager channelManager,
+            IRecordingsManager recordingsManager,
             LiveTvDtoService liveTvDtoService,
-            ITunerHostManager tunerHostManager)
+            IEnumerable<ILiveTvService> services)
         {
             _config = config;
             _logger = logger;
-            _itemRepo = itemRepo;
             _userManager = userManager;
             _libraryManager = libraryManager;
-            _taskManager = taskManager;
             _localization = localization;
-            _fileSystem = fileSystem;
             _dtoService = dtoService;
             _userDataManager = userDataManager;
             _channelManager = channelManager;
             _tvDtoService = liveTvDtoService;
-            _tunerHostManager = tunerHostManager;
+            _recordingsManager = recordingsManager;
+            _services = services.ToArray();
+
+            var defaultService = _services.OfType<DefaultLiveTvService>().First();
+            defaultService.TimerCreated += OnEmbyTvTimerCreated;
+            defaultService.TimerCancelled += OnEmbyTvTimerCancelled;
         }
 
         public event EventHandler<GenericEventArgs<TimerEventInfo>> SeriesTimerCancelled;
@@ -107,30 +90,6 @@ namespace Jellyfin.LiveTv
         /// <value>The services.</value>
         public IReadOnlyList<ILiveTvService> Services => _services;
 
-        public IReadOnlyList<IListingsProvider> ListingProviders => _listingProviders;
-
-        public string GetEmbyTvActiveRecordingPath(string id)
-        {
-            return EmbyTV.EmbyTV.Current.GetActiveRecordingPath(id);
-        }
-
-        /// <inheritdoc />
-        public void AddParts(IEnumerable<ILiveTvService> services, IEnumerable<IListingsProvider> listingProviders)
-        {
-            _services = services.ToArray();
-
-            _listingProviders = listingProviders.ToArray();
-
-            foreach (var service in _services)
-            {
-                if (service is EmbyTV.EmbyTV embyTv)
-                {
-                    embyTv.TimerCreated += OnEmbyTvTimerCreated;
-                    embyTv.TimerCancelled += OnEmbyTvTimerCancelled;
-                }
-            }
-        }
-
         private void OnEmbyTvTimerCancelled(object sender, GenericEventArgs<string> e)
         {
             var timerId = e.Argument;
@@ -151,7 +110,7 @@ namespace Jellyfin.LiveTv
 
         public QueryResult<BaseItem> GetInternalChannels(LiveTvChannelQuery query, DtoOptions dtoOptions, CancellationToken cancellationToken)
         {
-            var user = query.UserId.IsEmpty()
+            var user = query.UserId.Equals(default)
                 ? null
                 : _userManager.GetUserById(query.UserId);
 
@@ -192,73 +151,6 @@ namespace Jellyfin.LiveTv
             return _libraryManager.GetItemsResult(internalQuery);
         }
 
-        public async Task<Tuple<MediaSourceInfo, ILiveStream>> GetChannelStream(string id, string mediaSourceId, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
-        {
-            if (string.Equals(id, mediaSourceId, StringComparison.OrdinalIgnoreCase))
-            {
-                mediaSourceId = null;
-            }
-
-            var channel = (LiveTvChannel)_libraryManager.GetItemById(id);
-
-            bool isVideo = channel.ChannelType == ChannelType.TV;
-            var service = GetService(channel);
-            _logger.LogInformation("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
-
-            MediaSourceInfo info;
-#pragma warning disable CA1859 // TODO: Analyzer bug?
-            ILiveStream liveStream;
-#pragma warning restore CA1859
-            if (service is ISupportsDirectStreamProvider supportsManagedStream)
-            {
-                liveStream = await supportsManagedStream.GetChannelStreamWithDirectStreamProvider(channel.ExternalId, mediaSourceId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
-                info = liveStream.MediaSource;
-            }
-            else
-            {
-                info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
-                var openedId = info.Id;
-                Func<Task> closeFn = () => service.CloseLiveStream(openedId, CancellationToken.None);
-
-                liveStream = new ExclusiveLiveStream(info, closeFn);
-
-                var startTime = DateTime.UtcNow;
-                await liveStream.Open(cancellationToken).ConfigureAwait(false);
-                var endTime = DateTime.UtcNow;
-                _logger.LogInformation("Live stream opened after {0}ms", (endTime - startTime).TotalMilliseconds);
-            }
-
-            info.RequiresClosing = true;
-
-            var idPrefix = service.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture) + "_";
-
-            info.LiveStreamId = idPrefix + info.Id;
-
-            Normalize(info, service, isVideo);
-
-            return new Tuple<MediaSourceInfo, ILiveStream>(info, liveStream);
-        }
-
-        public async Task<IEnumerable<MediaSourceInfo>> GetChannelMediaSources(BaseItem item, CancellationToken cancellationToken)
-        {
-            var baseItem = (LiveTvChannel)item;
-            var service = GetService(baseItem);
-
-            var sources = await service.GetChannelStreamMediaSources(baseItem.ExternalId, cancellationToken).ConfigureAwait(false);
-
-            if (sources.Count == 0)
-            {
-                throw new NotImplementedException();
-            }
-
-            foreach (var source in sources)
-            {
-                Normalize(source, service, baseItem.ChannelType == ChannelType.TV);
-            }
-
-            return sources;
-        }
-
         private ILiveTvService GetService(LiveTvChannel item)
         {
             var name = item.ServiceName;
@@ -280,476 +172,6 @@ namespace Jellyfin.LiveTv
                         "No service with the name '{0}' can be found.",
                         name));
 
-        private static void Normalize(MediaSourceInfo mediaSource, ILiveTvService service, bool isVideo)
-        {
-            // Not all of the plugins are setting this
-            mediaSource.IsInfiniteStream = true;
-
-            if (mediaSource.MediaStreams.Count == 0)
-            {
-                if (isVideo)
-                {
-                    mediaSource.MediaStreams = new MediaStream[]
-                    {
-                        new MediaStream
-                        {
-                            Type = MediaStreamType.Video,
-                            // Set the index to -1 because we don't know the exact index of the video stream within the container
-                            Index = -1,
-
-                            // Set to true if unknown to enable deinterlacing
-                            IsInterlaced = true
-                        },
-                        new MediaStream
-                        {
-                            Type = MediaStreamType.Audio,
-                            // Set the index to -1 because we don't know the exact index of the audio stream within the container
-                            Index = -1
-                        }
-                    };
-                }
-                else
-                {
-                    mediaSource.MediaStreams = new MediaStream[]
-                    {
-                        new MediaStream
-                        {
-                            Type = MediaStreamType.Audio,
-                            // Set the index to -1 because we don't know the exact index of the audio stream within the container
-                            Index = -1
-                        }
-                    };
-                }
-            }
-
-            // Clean some bad data coming from providers
-            foreach (var stream in mediaSource.MediaStreams)
-            {
-                if (stream.BitRate.HasValue && stream.BitRate <= 0)
-                {
-                    stream.BitRate = null;
-                }
-
-                if (stream.Channels.HasValue && stream.Channels <= 0)
-                {
-                    stream.Channels = null;
-                }
-
-                if (stream.AverageFrameRate.HasValue && stream.AverageFrameRate <= 0)
-                {
-                    stream.AverageFrameRate = null;
-                }
-
-                if (stream.RealFrameRate.HasValue && stream.RealFrameRate <= 0)
-                {
-                    stream.RealFrameRate = null;
-                }
-
-                if (stream.Width.HasValue && stream.Width <= 0)
-                {
-                    stream.Width = null;
-                }
-
-                if (stream.Height.HasValue && stream.Height <= 0)
-                {
-                    stream.Height = null;
-                }
-
-                if (stream.SampleRate.HasValue && stream.SampleRate <= 0)
-                {
-                    stream.SampleRate = null;
-                }
-
-                if (stream.Level.HasValue && stream.Level <= 0)
-                {
-                    stream.Level = null;
-                }
-            }
-
-            var indexes = mediaSource.MediaStreams.Select(i => i.Index).Distinct().ToList();
-
-            // If there are duplicate stream indexes, set them all to unknown
-            if (indexes.Count != mediaSource.MediaStreams.Count)
-            {
-                foreach (var stream in mediaSource.MediaStreams)
-                {
-                    stream.Index = -1;
-                }
-            }
-
-            // Set the total bitrate if not already supplied
-            mediaSource.InferTotalBitrate();
-
-            if (service is not EmbyTV.EmbyTV)
-            {
-                // We can't trust that we'll be able to direct stream it through emby server, no matter what the provider says
-                // mediaSource.SupportsDirectPlay = false;
-                // mediaSource.SupportsDirectStream = false;
-                mediaSource.SupportsTranscoding = true;
-                foreach (var stream in mediaSource.MediaStreams)
-                {
-                    if (stream.Type == MediaStreamType.Video && string.IsNullOrWhiteSpace(stream.NalLengthSize))
-                    {
-                        stream.NalLengthSize = "0";
-                    }
-
-                    if (stream.Type == MediaStreamType.Video)
-                    {
-                        stream.IsInterlaced = true;
-                    }
-                }
-            }
-        }
-
-        private async Task<LiveTvChannel> GetChannelAsync(ChannelInfo channelInfo, string serviceName, BaseItem parentFolder, CancellationToken cancellationToken)
-        {
-            var parentFolderId = parentFolder.Id;
-            var isNew = false;
-            var forceUpdate = false;
-
-            var id = _tvDtoService.GetInternalChannelId(serviceName, channelInfo.Id);
-
-            var item = _libraryManager.GetItemById(id) as LiveTvChannel;
-
-            if (item is null)
-            {
-                item = new LiveTvChannel
-                {
-                    Name = channelInfo.Name,
-                    Id = id,
-                    DateCreated = DateTime.UtcNow
-                };
-
-                isNew = true;
-            }
-
-            if (channelInfo.Tags is not null)
-            {
-                if (!channelInfo.Tags.SequenceEqual(item.Tags, StringComparer.OrdinalIgnoreCase))
-                {
-                    isNew = true;
-                }
-
-                item.Tags = channelInfo.Tags;
-            }
-
-            if (!item.ParentId.Equals(parentFolderId))
-            {
-                isNew = true;
-            }
-
-            item.ParentId = parentFolderId;
-
-            item.ChannelType = channelInfo.ChannelType;
-            item.ServiceName = serviceName;
-
-            if (!string.Equals(item.GetProviderId(ExternalServiceTag), serviceName, StringComparison.OrdinalIgnoreCase))
-            {
-                forceUpdate = true;
-            }
-
-            item.SetProviderId(ExternalServiceTag, serviceName);
-
-            if (!string.Equals(channelInfo.Id, item.ExternalId, StringComparison.Ordinal))
-            {
-                forceUpdate = true;
-            }
-
-            item.ExternalId = channelInfo.Id;
-
-            if (!string.Equals(channelInfo.Number, item.Number, StringComparison.Ordinal))
-            {
-                forceUpdate = true;
-            }
-
-            item.Number = channelInfo.Number;
-
-            if (!string.Equals(channelInfo.Name, item.Name, StringComparison.Ordinal))
-            {
-                forceUpdate = true;
-            }
-
-            item.Name = channelInfo.Name;
-
-            if (!item.HasImage(ImageType.Primary))
-            {
-                if (!string.IsNullOrWhiteSpace(channelInfo.ImagePath))
-                {
-                    item.SetImagePath(ImageType.Primary, channelInfo.ImagePath);
-                    forceUpdate = true;
-                }
-                else if (!string.IsNullOrWhiteSpace(channelInfo.ImageUrl))
-                {
-                    item.SetImagePath(ImageType.Primary, channelInfo.ImageUrl);
-                    forceUpdate = true;
-                }
-            }
-
-            if (isNew)
-            {
-                _libraryManager.CreateItem(item, parentFolder);
-            }
-            else if (forceUpdate)
-            {
-                await _libraryManager.UpdateItemAsync(item, parentFolder, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
-            }
-
-            return item;
-        }
-
-        private (LiveTvProgram Item, bool IsNew, bool IsUpdated) GetProgram(ProgramInfo info, Dictionary<Guid, LiveTvProgram> allExistingPrograms, LiveTvChannel channel)
-        {
-            var id = _tvDtoService.GetInternalProgramId(info.Id);
-
-            var isNew = false;
-            var forceUpdate = false;
-
-            if (!allExistingPrograms.TryGetValue(id, out LiveTvProgram item))
-            {
-                isNew = true;
-                item = new LiveTvProgram
-                {
-                    Name = info.Name,
-                    Id = id,
-                    DateCreated = DateTime.UtcNow,
-                    DateModified = DateTime.UtcNow
-                };
-
-                if (!string.IsNullOrEmpty(info.Etag))
-                {
-                    item.SetProviderId(EtagKey, info.Etag);
-                }
-            }
-
-            if (!string.Equals(info.ShowId, item.ShowId, StringComparison.OrdinalIgnoreCase))
-            {
-                item.ShowId = info.ShowId;
-                forceUpdate = true;
-            }
-
-            var seriesId = info.SeriesId;
-
-            if (!item.ParentId.Equals(channel.Id))
-            {
-                forceUpdate = true;
-            }
-
-            item.ParentId = channel.Id;
-
-            item.Audio = info.Audio;
-            item.ChannelId = channel.Id;
-            item.CommunityRating ??= info.CommunityRating;
-            if ((item.CommunityRating ?? 0).Equals(0))
-            {
-                item.CommunityRating = null;
-            }
-
-            item.EpisodeTitle = info.EpisodeTitle;
-            item.ExternalId = info.Id;
-
-            if (!string.IsNullOrWhiteSpace(seriesId) && !string.Equals(item.ExternalSeriesId, seriesId, StringComparison.Ordinal))
-            {
-                forceUpdate = true;
-            }
-
-            item.ExternalSeriesId = seriesId;
-
-            var isSeries = info.IsSeries || !string.IsNullOrEmpty(info.EpisodeTitle);
-
-            if (isSeries || !string.IsNullOrEmpty(info.EpisodeTitle))
-            {
-                item.SeriesName = info.Name;
-            }
-
-            var tags = new List<string>();
-            if (info.IsLive)
-            {
-                tags.Add("Live");
-            }
-
-            if (info.IsPremiere)
-            {
-                tags.Add("Premiere");
-            }
-
-            if (info.IsNews)
-            {
-                tags.Add("News");
-            }
-
-            if (info.IsSports)
-            {
-                tags.Add("Sports");
-            }
-
-            if (info.IsKids)
-            {
-                tags.Add("Kids");
-            }
-
-            if (info.IsRepeat)
-            {
-                tags.Add("Repeat");
-            }
-
-            if (info.IsMovie)
-            {
-                tags.Add("Movie");
-            }
-
-            if (isSeries)
-            {
-                tags.Add("Series");
-            }
-
-            item.Tags = tags.ToArray();
-
-            item.Genres = info.Genres.ToArray();
-
-            if (info.IsHD ?? false)
-            {
-                item.Width = 1280;
-                item.Height = 720;
-            }
-
-            item.IsMovie = info.IsMovie;
-            item.IsRepeat = info.IsRepeat;
-
-            if (item.IsSeries != isSeries)
-            {
-                forceUpdate = true;
-            }
-
-            item.IsSeries = isSeries;
-
-            item.Name = info.Name;
-            item.OfficialRating ??= info.OfficialRating;
-            item.Overview ??= info.Overview;
-            item.RunTimeTicks = (info.EndDate - info.StartDate).Ticks;
-            item.ProviderIds = info.ProviderIds;
-
-            foreach (var providerId in info.SeriesProviderIds)
-            {
-                info.ProviderIds["Series" + providerId.Key] = providerId.Value;
-            }
-
-            if (item.StartDate != info.StartDate)
-            {
-                forceUpdate = true;
-            }
-
-            item.StartDate = info.StartDate;
-
-            if (item.EndDate != info.EndDate)
-            {
-                forceUpdate = true;
-            }
-
-            item.EndDate = info.EndDate;
-
-            item.ProductionYear = info.ProductionYear;
-
-            if (!isSeries || info.IsRepeat)
-            {
-                item.PremiereDate = info.OriginalAirDate;
-            }
-
-            item.IndexNumber = info.EpisodeNumber;
-            item.ParentIndexNumber = info.SeasonNumber;
-
-            if (!item.HasImage(ImageType.Primary))
-            {
-                if (!string.IsNullOrWhiteSpace(info.ImagePath))
-                {
-                    item.SetImage(
-                        new ItemImageInfo
-                        {
-                            Path = info.ImagePath,
-                            Type = ImageType.Primary
-                        },
-                        0);
-                }
-                else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
-                {
-                    item.SetImage(
-                        new ItemImageInfo
-                        {
-                            Path = info.ImageUrl,
-                            Type = ImageType.Primary
-                        },
-                        0);
-                }
-            }
-
-            if (!item.HasImage(ImageType.Thumb))
-            {
-                if (!string.IsNullOrWhiteSpace(info.ThumbImageUrl))
-                {
-                    item.SetImage(
-                        new ItemImageInfo
-                        {
-                            Path = info.ThumbImageUrl,
-                            Type = ImageType.Thumb
-                        },
-                        0);
-                }
-            }
-
-            if (!item.HasImage(ImageType.Logo))
-            {
-                if (!string.IsNullOrWhiteSpace(info.LogoImageUrl))
-                {
-                    item.SetImage(
-                        new ItemImageInfo
-                        {
-                            Path = info.LogoImageUrl,
-                            Type = ImageType.Logo
-                        },
-                        0);
-                }
-            }
-
-            if (!item.HasImage(ImageType.Backdrop))
-            {
-                if (!string.IsNullOrWhiteSpace(info.BackdropImageUrl))
-                {
-                    item.SetImage(
-                        new ItemImageInfo
-                        {
-                            Path = info.BackdropImageUrl,
-                            Type = ImageType.Backdrop
-                        },
-                        0);
-                }
-            }
-
-            var isUpdated = false;
-            if (isNew)
-            {
-            }
-            else if (forceUpdate || string.IsNullOrWhiteSpace(info.Etag))
-            {
-                isUpdated = true;
-            }
-            else
-            {
-                var etag = info.Etag;
-
-                if (!string.Equals(etag, item.GetProviderId(EtagKey), StringComparison.OrdinalIgnoreCase))
-                {
-                    item.SetProviderId(EtagKey, etag);
-                    isUpdated = true;
-                }
-            }
-
-            if (isNew || isUpdated)
-            {
-                item.OnMetadataChanged();
-            }
-
-            return (item, isNew, isUpdated);
-        }
-
         public async Task<BaseItemDto> GetProgram(string id, CancellationToken cancellationToken, User user = null)
         {
             var program = _libraryManager.GetItemById(id);
@@ -1001,293 +423,6 @@ namespace Jellyfin.LiveTv
             }
         }
 
-        internal Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
-        {
-            return RefreshChannelsInternal(progress, cancellationToken);
-        }
-
-        private async Task RefreshChannelsInternal(IProgress<double> progress, CancellationToken cancellationToken)
-        {
-            await EmbyTV.EmbyTV.Current.CreateRecordingFolders().ConfigureAwait(false);
-
-            await _tunerHostManager.ScanForTunerDeviceChanges(cancellationToken).ConfigureAwait(false);
-
-            var numComplete = 0;
-            double progressPerService = _services.Length == 0
-                ? 0
-                : 1.0 / _services.Length;
-
-            var newChannelIdList = new List<Guid>();
-            var newProgramIdList = new List<Guid>();
-
-            var cleanDatabase = true;
-
-            foreach (var service in _services)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                _logger.LogDebug("Refreshing guide from {Name}", service.Name);
-
-                try
-                {
-                    var innerProgress = new ActionableProgress<double>();
-                    innerProgress.RegisterAction(p => progress.Report(p * progressPerService));
-
-                    var idList = await RefreshChannelsInternal(service, innerProgress, cancellationToken).ConfigureAwait(false);
-
-                    newChannelIdList.AddRange(idList.Item1);
-                    newProgramIdList.AddRange(idList.Item2);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    cleanDatabase = false;
-                    _logger.LogError(ex, "Error refreshing channels for service");
-                }
-
-                numComplete++;
-                double percent = numComplete;
-                percent /= _services.Length;
-
-                progress.Report(100 * percent);
-            }
-
-            if (cleanDatabase)
-            {
-                CleanDatabaseInternal(newChannelIdList.ToArray(), new[] { BaseItemKind.LiveTvChannel }, progress, cancellationToken);
-                CleanDatabaseInternal(newProgramIdList.ToArray(), new[] { BaseItemKind.LiveTvProgram }, progress, cancellationToken);
-            }
-
-            var coreService = _services.OfType<EmbyTV.EmbyTV>().FirstOrDefault();
-
-            if (coreService is not null)
-            {
-                await coreService.RefreshSeriesTimers(cancellationToken).ConfigureAwait(false);
-                await coreService.RefreshTimers(cancellationToken).ConfigureAwait(false);
-            }
-
-            // Load these now which will prefetch metadata
-            var dtoOptions = new DtoOptions();
-            var fields = dtoOptions.Fields.ToList();
-            dtoOptions.Fields = fields.ToArray();
-
-            progress.Report(100);
-        }
-
-        private async Task<Tuple<List<Guid>, List<Guid>>> RefreshChannelsInternal(ILiveTvService service, ActionableProgress<double> progress, CancellationToken cancellationToken)
-        {
-            progress.Report(10);
-
-            var allChannelsList = (await service.GetChannelsAsync(cancellationToken).ConfigureAwait(false))
-                .Select(i => new Tuple<string, ChannelInfo>(service.Name, i))
-                .ToList();
-
-            var list = new List<LiveTvChannel>();
-
-            var numComplete = 0;
-            var parentFolder = GetInternalLiveTvFolder(cancellationToken);
-
-            foreach (var channelInfo in allChannelsList)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                try
-                {
-                    var item = await GetChannelAsync(channelInfo.Item2, channelInfo.Item1, parentFolder, cancellationToken).ConfigureAwait(false);
-
-                    list.Add(item);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting channel information for {Name}", channelInfo.Item2.Name);
-                }
-
-                numComplete++;
-                double percent = numComplete;
-                percent /= allChannelsList.Count;
-
-                progress.Report((5 * percent) + 10);
-            }
-
-            progress.Report(15);
-
-            numComplete = 0;
-            var programs = new List<Guid>();
-            var channels = new List<Guid>();
-
-            var guideDays = GetGuideDays();
-
-            _logger.LogInformation("Refreshing guide with {0} days of guide data", guideDays);
-
-            cancellationToken.ThrowIfCancellationRequested();
-
-            foreach (var currentChannel in list)
-            {
-                channels.Add(currentChannel.Id);
-                cancellationToken.ThrowIfCancellationRequested();
-
-                try
-                {
-                    var start = DateTime.UtcNow.AddHours(-1);
-                    var end = start.AddDays(guideDays);
-
-                    var isMovie = false;
-                    var isSports = false;
-                    var isNews = false;
-                    var isKids = false;
-                    var iSSeries = false;
-
-                    var channelPrograms = (await service.GetProgramsAsync(currentChannel.ExternalId, start, end, cancellationToken).ConfigureAwait(false)).ToList();
-
-                    var existingPrograms = _libraryManager.GetItemList(new InternalItemsQuery
-                    {
-                        IncludeItemTypes = new[] { BaseItemKind.LiveTvProgram },
-                        ChannelIds = new Guid[] { currentChannel.Id },
-                        DtoOptions = new DtoOptions(true)
-                    }).Cast<LiveTvProgram>().ToDictionary(i => i.Id);
-
-                    var newPrograms = new List<LiveTvProgram>();
-                    var updatedPrograms = new List<BaseItem>();
-
-                    foreach (var program in channelPrograms)
-                    {
-                        var programTuple = GetProgram(program, existingPrograms, currentChannel);
-                        var programItem = programTuple.Item;
-
-                        if (programTuple.IsNew)
-                        {
-                            newPrograms.Add(programItem);
-                        }
-                        else if (programTuple.IsUpdated)
-                        {
-                            updatedPrograms.Add(programItem);
-                        }
-
-                        programs.Add(programItem.Id);
-
-                        isMovie |= program.IsMovie;
-                        iSSeries |= program.IsSeries;
-                        isSports |= program.IsSports;
-                        isNews |= program.IsNews;
-                        isKids |= program.IsKids;
-                    }
-
-                    _logger.LogDebug("Channel {0} has {1} new programs and {2} updated programs", currentChannel.Name, newPrograms.Count, updatedPrograms.Count);
-
-                    if (newPrograms.Count > 0)
-                    {
-                        _libraryManager.CreateItems(newPrograms, null, cancellationToken);
-                    }
-
-                    if (updatedPrograms.Count > 0)
-                    {
-                        await _libraryManager.UpdateItemsAsync(
-                            updatedPrograms,
-                            currentChannel,
-                            ItemUpdateType.MetadataImport,
-                            cancellationToken).ConfigureAwait(false);
-                    }
-
-                    currentChannel.IsMovie = isMovie;
-                    currentChannel.IsNews = isNews;
-                    currentChannel.IsSports = isSports;
-                    currentChannel.IsSeries = iSSeries;
-
-                    if (isKids)
-                    {
-                        currentChannel.AddTag("Kids");
-                    }
-
-                    await currentChannel.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
-                    await currentChannel.RefreshMetadata(
-                        new MetadataRefreshOptions(new DirectoryService(_fileSystem))
-                        {
-                            ForceSave = true
-                        },
-                        cancellationToken).ConfigureAwait(false);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting programs for channel {Name}", currentChannel.Name);
-                }
-
-                numComplete++;
-                double percent = numComplete / (double)allChannelsList.Count;
-
-                progress.Report((85 * percent) + 15);
-            }
-
-            progress.Report(100);
-            return new Tuple<List<Guid>, List<Guid>>(channels, programs);
-        }
-
-        private void CleanDatabaseInternal(Guid[] currentIdList, BaseItemKind[] validTypes, IProgress<double> progress, CancellationToken cancellationToken)
-        {
-            var list = _itemRepo.GetItemIdsList(new InternalItemsQuery
-            {
-                IncludeItemTypes = validTypes,
-                DtoOptions = new DtoOptions(false)
-            });
-
-            var numComplete = 0;
-
-            foreach (var itemId in list)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                if (itemId.IsEmpty())
-                {
-                    // Somehow some invalid data got into the db. It probably predates the boundary checking
-                    continue;
-                }
-
-                if (!currentIdList.Contains(itemId))
-                {
-                    var item = _libraryManager.GetItemById(itemId);
-
-                    if (item is not null)
-                    {
-                        _libraryManager.DeleteItem(
-                            item,
-                            new DeleteOptions
-                            {
-                                DeleteFileLocation = false,
-                                DeleteFromExternalProvider = false
-                            },
-                            false);
-                    }
-                }
-
-                numComplete++;
-                double percent = numComplete / (double)list.Count;
-
-                progress.Report(100 * percent);
-            }
-        }
-
-        private double GetGuideDays()
-        {
-            var config = _config.GetLiveTvConfiguration();
-
-            if (config.GuideDays.HasValue)
-            {
-                return Math.Max(1, Math.Min(config.GuideDays.Value, MaxGuideDays));
-            }
-
-            return 7;
-        }
-
         private async Task<QueryResult<BaseItem>> GetEmbyRecordingsAsync(RecordingQuery query, DtoOptions dtoOptions, User user)
         {
             if (user is null)
@@ -1439,18 +574,13 @@ namespace Jellyfin.LiveTv
             return AddRecordingInfo(programTuples, CancellationToken.None);
         }
 
-        public ActiveRecordingInfo GetActiveRecordingInfo(string path)
-        {
-            return EmbyTV.EmbyTV.Current.GetActiveRecordingInfo(path);
-        }
-
         public void AddInfoToRecordingDto(BaseItem item, BaseItemDto dto, ActiveRecordingInfo activeRecordingInfo, User user = null)
         {
-            var service = EmbyTV.EmbyTV.Current;
-
             var info = activeRecordingInfo.Timer;
 
-            var channel = string.IsNullOrWhiteSpace(info.ChannelId) ? null : _libraryManager.GetItemById(_tvDtoService.GetInternalChannelId(service.Name, info.ChannelId));
+            var channel = string.IsNullOrWhiteSpace(info.ChannelId)
+                ? null
+                : _libraryManager.GetItemById(_tvDtoService.GetInternalChannelId(DefaultLiveTvService.ServiceName, info.ChannelId));
 
             dto.SeriesTimerId = string.IsNullOrEmpty(info.SeriesTimerId)
                 ? null
@@ -1505,7 +635,7 @@ namespace Jellyfin.LiveTv
 
         public async Task<QueryResult<BaseItemDto>> GetRecordingsAsync(RecordingQuery query, DtoOptions options)
         {
-            var user = query.UserId.IsEmpty()
+            var user = query.UserId.Equals(default)
                 ? null
                 : _userManager.GetUserById(query.UserId);
 
@@ -1686,7 +816,7 @@ namespace Jellyfin.LiveTv
 
             await service.CancelTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
 
-            if (service is not EmbyTV.EmbyTV)
+            if (service is not DefaultLiveTvService)
             {
                 TimerCancelled?.Invoke(this, new GenericEventArgs<TimerEventInfo>(new TimerEventInfo(id)));
             }
@@ -1819,12 +949,6 @@ namespace Jellyfin.LiveTv
             return new QueryResult<SeriesTimerInfoDto>(returnArray);
         }
 
-        public BaseItem GetLiveTvChannel(TimerInfo timer, ILiveTvService service)
-        {
-            var internalChannelId = _tvDtoService.GetInternalChannelId(service.Name, timer.ChannelId);
-            return _libraryManager.GetItemById(internalChannelId);
-        }
-
         public void AddChannelInfo(IReadOnlyCollection<(BaseItemDto ItemDto, LiveTvChannel Channel)> items, DtoOptions options, User user)
         {
             var now = DateTime.UtcNow;
@@ -2001,7 +1125,7 @@ namespace Jellyfin.LiveTv
 
             _logger.LogInformation("New recording scheduled");
 
-            if (service is not EmbyTV.EmbyTV)
+            if (service is not DefaultLiveTvService)
             {
                 TimerCreated?.Invoke(this, new GenericEventArgs<TimerEventInfo>(
                     new TimerEventInfo(newTimerId)
@@ -2057,18 +1181,6 @@ namespace Jellyfin.LiveTv
             await service.UpdateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
         }
 
-        public GuideInfo GetGuideInfo()
-        {
-            var startDate = DateTime.UtcNow;
-            var endDate = startDate.AddDays(GetGuideDays());
-
-            return new GuideInfo
-            {
-                StartDate = startDate,
-                EndDate = endDate
-            };
-        }
-
         private LiveTvServiceInfo[] GetServiceInfos()
         {
             return Services.Select(GetServiceInfo).ToArray();
@@ -2147,178 +1259,13 @@ namespace Jellyfin.LiveTv
             return _libraryManager.GetNamedView(name, CollectionType.livetv, name);
         }
 
-        public async Task<ListingsProviderInfo> SaveListingProvider(ListingsProviderInfo info, bool validateLogin, bool validateListings)
-        {
-            // Hack to make the object a pure ListingsProviderInfo instead of an AddListingProvider
-            // ServerConfiguration.SaveConfiguration crashes during xml serialization for AddListingProvider
-            info = JsonSerializer.Deserialize<ListingsProviderInfo>(JsonSerializer.SerializeToUtf8Bytes(info));
-
-            var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
-
-            if (provider is null)
-            {
-                throw new ResourceNotFoundException(
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        "Couldn't find provider of type: '{0}'",
-                        info.Type));
-            }
-
-            await provider.Validate(info, validateLogin, validateListings).ConfigureAwait(false);
-
-            var config = _config.GetLiveTvConfiguration();
-
-            var list = config.ListingProviders.ToList();
-            int index = list.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
-
-            if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
-            {
-                info.Id = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
-                list.Add(info);
-                config.ListingProviders = list.ToArray();
-            }
-            else
-            {
-                config.ListingProviders[index] = info;
-            }
-
-            _config.SaveConfiguration("livetv", config);
-
-            _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
-
-            return info;
-        }
-
-        public void DeleteListingsProvider(string id)
-        {
-            var config = _config.GetLiveTvConfiguration();
-
-            config.ListingProviders = config.ListingProviders.Where(i => !string.Equals(id, i.Id, StringComparison.OrdinalIgnoreCase)).ToArray();
-
-            _config.SaveConfiguration("livetv", config);
-            _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
-        }
-
-        public async Task<TunerChannelMapping> SetChannelMapping(string providerId, string tunerChannelNumber, string providerChannelNumber)
-        {
-            var config = _config.GetLiveTvConfiguration();
-
-            var listingsProviderInfo = config.ListingProviders.First(i => string.Equals(providerId, i.Id, StringComparison.OrdinalIgnoreCase));
-            listingsProviderInfo.ChannelMappings = listingsProviderInfo.ChannelMappings.Where(i => !string.Equals(i.Name, tunerChannelNumber, StringComparison.OrdinalIgnoreCase)).ToArray();
-
-            if (!string.Equals(tunerChannelNumber, providerChannelNumber, StringComparison.OrdinalIgnoreCase))
-            {
-                var list = listingsProviderInfo.ChannelMappings.ToList();
-                list.Add(new NameValuePair
-                {
-                    Name = tunerChannelNumber,
-                    Value = providerChannelNumber
-                });
-                listingsProviderInfo.ChannelMappings = list.ToArray();
-            }
-
-            _config.SaveConfiguration("livetv", config);
-
-            var tunerChannels = await GetChannelsForListingsProvider(providerId, CancellationToken.None)
-                        .ConfigureAwait(false);
-
-            var providerChannels = await GetChannelsFromListingsProviderData(providerId, CancellationToken.None)
-                     .ConfigureAwait(false);
-
-            var mappings = listingsProviderInfo.ChannelMappings;
-
-            var tunerChannelMappings =
-                tunerChannels.Select(i => GetTunerChannelMapping(i, mappings, providerChannels)).ToList();
-
-            _taskManager.CancelIfRunningAndQueue<RefreshGuideScheduledTask>();
-
-            return tunerChannelMappings.First(i => string.Equals(i.Id, tunerChannelNumber, StringComparison.OrdinalIgnoreCase));
-        }
-
-        public TunerChannelMapping GetTunerChannelMapping(ChannelInfo tunerChannel, NameValuePair[] mappings, List<ChannelInfo> providerChannels)
-        {
-            var result = new TunerChannelMapping
-            {
-                Name = tunerChannel.Name,
-                Id = tunerChannel.Id
-            };
-
-            if (!string.IsNullOrWhiteSpace(tunerChannel.Number))
-            {
-                result.Name = tunerChannel.Number + " " + result.Name;
-            }
-
-            var providerChannel = EmbyTV.EmbyTV.Current.GetEpgChannelFromTunerChannel(mappings, tunerChannel, providerChannels);
-
-            if (providerChannel is not null)
-            {
-                result.ProviderChannelName = providerChannel.Name;
-                result.ProviderChannelId = providerChannel.Id;
-            }
-
-            return result;
-        }
-
-        public Task<List<NameIdPair>> GetLineups(string providerType, string providerId, string country, string location)
-        {
-            var config = _config.GetLiveTvConfiguration();
-
-            if (string.IsNullOrWhiteSpace(providerId))
-            {
-                var provider = _listingProviders.FirstOrDefault(i => string.Equals(providerType, i.Type, StringComparison.OrdinalIgnoreCase));
-
-                if (provider is null)
-                {
-                    throw new ResourceNotFoundException();
-                }
-
-                return provider.GetLineups(null, country, location);
-            }
-            else
-            {
-                var info = config.ListingProviders.FirstOrDefault(i => string.Equals(i.Id, providerId, StringComparison.OrdinalIgnoreCase));
-
-                var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
-
-                if (provider is null)
-                {
-                    throw new ResourceNotFoundException();
-                }
-
-                return provider.GetLineups(info, country, location);
-            }
-        }
-
-        public Task<List<ChannelInfo>> GetChannelsForListingsProvider(string id, CancellationToken cancellationToken)
-        {
-            var info = _config.GetLiveTvConfiguration().ListingProviders.First(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
-            return EmbyTV.EmbyTV.Current.GetChannelsForListingsProvider(info, cancellationToken);
-        }
-
-        public Task<List<ChannelInfo>> GetChannelsFromListingsProviderData(string id, CancellationToken cancellationToken)
-        {
-            var info = _config.GetLiveTvConfiguration().ListingProviders.First(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
-            var provider = _listingProviders.First(i => string.Equals(i.Type, info.Type, StringComparison.OrdinalIgnoreCase));
-            return provider.GetChannels(info, cancellationToken);
-        }
-
-        public Guid GetInternalChannelId(string serviceName, string externalId)
-        {
-            return _tvDtoService.GetInternalChannelId(serviceName, externalId);
-        }
-
-        public Guid GetInternalProgramId(string externalId)
-        {
-            return _tvDtoService.GetInternalProgramId(externalId);
-        }
-
         /// <inheritdoc />
         public Task<BaseItem[]> GetRecordingFoldersAsync(User user)
             => GetRecordingFoldersAsync(user, false);
 
         private async Task<BaseItem[]> GetRecordingFoldersAsync(User user, bool refreshChannels)
         {
-            var folders = EmbyTV.EmbyTV.Current.GetRecordingFolders()
+            var folders = _recordingsManager.GetRecordingFolders()
                 .SelectMany(i => i.Locations)
                 .Distinct(StringComparer.OrdinalIgnoreCase)
                 .Select(i => _libraryManager.FindByPath(i, true))
diff --git a/src/Jellyfin.LiveTv/LiveTvMediaSourceProvider.cs b/src/Jellyfin.LiveTv/LiveTvMediaSourceProvider.cs
index ce9361089..40ac5ce0f 100644
--- a/src/Jellyfin.LiveTv/LiveTvMediaSourceProvider.cs
+++ b/src/Jellyfin.LiveTv/LiveTvMediaSourceProvider.cs
@@ -8,11 +8,15 @@ using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.LiveTv.IO;
+using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.LiveTv;
 using MediaBrowser.Model.MediaInfo;
 using Microsoft.Extensions.Logging;
 
@@ -23,24 +27,34 @@ namespace Jellyfin.LiveTv
         // Do not use a pipe here because Roku http requests to the server will fail, without any explicit error message.
         private const char StreamIdDelimiter = '_';
 
-        private readonly ILiveTvManager _liveTvManager;
         private readonly ILogger<LiveTvMediaSourceProvider> _logger;
-        private readonly IMediaSourceManager _mediaSourceManager;
         private readonly IServerApplicationHost _appHost;
+        private readonly IRecordingsManager _recordingsManager;
+        private readonly IMediaSourceManager _mediaSourceManager;
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILiveTvService[] _services;
 
-        public LiveTvMediaSourceProvider(ILiveTvManager liveTvManager, ILogger<LiveTvMediaSourceProvider> logger, IMediaSourceManager mediaSourceManager, IServerApplicationHost appHost)
+        public LiveTvMediaSourceProvider(
+            ILogger<LiveTvMediaSourceProvider> logger,
+            IServerApplicationHost appHost,
+            IRecordingsManager recordingsManager,
+            IMediaSourceManager mediaSourceManager,
+            ILibraryManager libraryManager,
+            IEnumerable<ILiveTvService> services)
         {
-            _liveTvManager = liveTvManager;
             _logger = logger;
-            _mediaSourceManager = mediaSourceManager;
             _appHost = appHost;
+            _recordingsManager = recordingsManager;
+            _mediaSourceManager = mediaSourceManager;
+            _libraryManager = libraryManager;
+            _services = services.ToArray();
         }
 
         public Task<IEnumerable<MediaSourceInfo>> GetMediaSources(BaseItem item, CancellationToken cancellationToken)
         {
             if (item.SourceType == SourceType.LiveTV)
             {
-                var activeRecordingInfo = _liveTvManager.GetActiveRecordingInfo(item.Path);
+                var activeRecordingInfo = _recordingsManager.GetActiveRecordingInfo(item.Path);
 
                 if (string.IsNullOrEmpty(item.Path) || activeRecordingInfo is not null)
                 {
@@ -66,7 +80,7 @@ namespace Jellyfin.LiveTv
                 }
                 else
                 {
-                    sources = await _liveTvManager.GetChannelMediaSources(item, cancellationToken)
+                    sources = await GetChannelMediaSources(item, cancellationToken)
                         .ConfigureAwait(false);
                 }
             }
@@ -119,10 +133,200 @@ namespace Jellyfin.LiveTv
             var keys = openToken.Split(StreamIdDelimiter, 3);
             var mediaSourceId = keys.Length >= 3 ? keys[2] : null;
 
-            var info = await _liveTvManager.GetChannelStream(keys[1], mediaSourceId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
+            var info = await GetChannelStream(keys[1], mediaSourceId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
             var liveStream = info.Item2;
 
             return liveStream;
         }
+
+        private static void Normalize(MediaSourceInfo mediaSource, ILiveTvService service, bool isVideo)
+        {
+            // Not all of the plugins are setting this
+            mediaSource.IsInfiniteStream = true;
+
+            if (mediaSource.MediaStreams.Count == 0)
+            {
+                if (isVideo)
+                {
+                    mediaSource.MediaStreams = new[]
+                    {
+                        new MediaStream
+                        {
+                            Type = MediaStreamType.Video,
+                            // Set the index to -1 because we don't know the exact index of the video stream within the container
+                            Index = -1,
+                            // Set to true if unknown to enable deinterlacing
+                            IsInterlaced = true
+                        },
+                        new MediaStream
+                        {
+                            Type = MediaStreamType.Audio,
+                            // Set the index to -1 because we don't know the exact index of the audio stream within the container
+                            Index = -1
+                        }
+                    };
+                }
+                else
+                {
+                    mediaSource.MediaStreams = new[]
+                    {
+                        new MediaStream
+                        {
+                            Type = MediaStreamType.Audio,
+                            // Set the index to -1 because we don't know the exact index of the audio stream within the container
+                            Index = -1
+                        }
+                    };
+                }
+            }
+
+            // Clean some bad data coming from providers
+            foreach (var stream in mediaSource.MediaStreams)
+            {
+                if (stream.BitRate is <= 0)
+                {
+                    stream.BitRate = null;
+                }
+
+                if (stream.Channels is <= 0)
+                {
+                    stream.Channels = null;
+                }
+
+                if (stream.AverageFrameRate is <= 0)
+                {
+                    stream.AverageFrameRate = null;
+                }
+
+                if (stream.RealFrameRate is <= 0)
+                {
+                    stream.RealFrameRate = null;
+                }
+
+                if (stream.Width is <= 0)
+                {
+                    stream.Width = null;
+                }
+
+                if (stream.Height is <= 0)
+                {
+                    stream.Height = null;
+                }
+
+                if (stream.SampleRate is <= 0)
+                {
+                    stream.SampleRate = null;
+                }
+
+                if (stream.Level is <= 0)
+                {
+                    stream.Level = null;
+                }
+            }
+
+            var indexCount = mediaSource.MediaStreams.Select(i => i.Index).Distinct().Count();
+
+            // If there are duplicate stream indexes, set them all to unknown
+            if (indexCount != mediaSource.MediaStreams.Count)
+            {
+                foreach (var stream in mediaSource.MediaStreams)
+                {
+                    stream.Index = -1;
+                }
+            }
+
+            // Set the total bitrate if not already supplied
+            mediaSource.InferTotalBitrate();
+
+            if (service is not DefaultLiveTvService)
+            {
+                mediaSource.SupportsTranscoding = true;
+                foreach (var stream in mediaSource.MediaStreams)
+                {
+                    if (stream.Type == MediaStreamType.Video && string.IsNullOrWhiteSpace(stream.NalLengthSize))
+                    {
+                        stream.NalLengthSize = "0";
+                    }
+
+                    if (stream.Type == MediaStreamType.Video)
+                    {
+                        stream.IsInterlaced = true;
+                    }
+                }
+            }
+        }
+
+        private async Task<Tuple<MediaSourceInfo, ILiveStream>> GetChannelStream(
+            string id,
+            string mediaSourceId,
+            List<ILiveStream> currentLiveStreams,
+            CancellationToken cancellationToken)
+        {
+            if (string.Equals(id, mediaSourceId, StringComparison.OrdinalIgnoreCase))
+            {
+                mediaSourceId = null;
+            }
+
+            var channel = (LiveTvChannel)_libraryManager.GetItemById(id);
+
+            bool isVideo = channel.ChannelType == ChannelType.TV;
+            var service = GetService(channel.ServiceName);
+            _logger.LogInformation("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
+
+            MediaSourceInfo info;
+#pragma warning disable CA1859 // TODO: Analyzer bug?
+            ILiveStream liveStream;
+#pragma warning restore CA1859
+            if (service is ISupportsDirectStreamProvider supportsManagedStream)
+            {
+                liveStream = await supportsManagedStream.GetChannelStreamWithDirectStreamProvider(channel.ExternalId, mediaSourceId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
+                info = liveStream.MediaSource;
+            }
+            else
+            {
+                info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
+                var openedId = info.Id;
+                Func<Task> closeFn = () => service.CloseLiveStream(openedId, CancellationToken.None);
+
+                liveStream = new ExclusiveLiveStream(info, closeFn);
+
+                var startTime = DateTime.UtcNow;
+                await liveStream.Open(cancellationToken).ConfigureAwait(false);
+                var endTime = DateTime.UtcNow;
+                _logger.LogInformation("Live stream opened after {0}ms", (endTime - startTime).TotalMilliseconds);
+            }
+
+            info.RequiresClosing = true;
+
+            var idPrefix = service.GetType().FullName!.GetMD5().ToString("N", CultureInfo.InvariantCulture) + "_";
+
+            info.LiveStreamId = idPrefix + info.Id;
+
+            Normalize(info, service, isVideo);
+
+            return new Tuple<MediaSourceInfo, ILiveStream>(info, liveStream);
+        }
+
+        private async Task<List<MediaSourceInfo>> GetChannelMediaSources(BaseItem item, CancellationToken cancellationToken)
+        {
+            var baseItem = (LiveTvChannel)item;
+            var service = GetService(baseItem.ServiceName);
+
+            var sources = await service.GetChannelStreamMediaSources(baseItem.ExternalId, cancellationToken).ConfigureAwait(false);
+            if (sources.Count == 0)
+            {
+                throw new NotImplementedException();
+            }
+
+            foreach (var source in sources)
+            {
+                Normalize(source, service, baseItem.ChannelType == ChannelType.TV);
+            }
+
+            return sources;
+        }
+
+        private ILiveTvService GetService(string name)
+            => _services.First(service => string.Equals(service.Name, name, StringComparison.OrdinalIgnoreCase));
     }
 }
diff --git a/src/Jellyfin.LiveTv/EmbyTV/RecordingHelper.cs b/src/Jellyfin.LiveTv/Recordings/RecordingHelper.cs
index 6bda231b2..2b7564045 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/RecordingHelper.cs
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingHelper.cs
@@ -1,19 +1,12 @@
-#pragma warning disable CS1591
-
 using System;
 using System.Globalization;
 using System.Text;
 using MediaBrowser.Controller.LiveTv;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.Recordings
 {
     internal static class RecordingHelper
     {
-        public static DateTime GetStartTime(TimerInfo timer)
-        {
-            return timer.StartDate.AddSeconds(-timer.PrePaddingSeconds);
-        }
-
         public static string GetRecordingName(TimerInfo info)
         {
             var name = info.Name;
diff --git a/src/Jellyfin.LiveTv/RecordingNotifier.cs b/src/Jellyfin.LiveTv/Recordings/RecordingNotifier.cs
index 2923948eb..e63afa626 100644
--- a/src/Jellyfin.LiveTv/RecordingNotifier.cs
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingNotifier.cs
@@ -1,7 +1,3 @@
-#nullable disable
-
-#pragma warning disable CS1591
-
 using System;
 using System.Linq;
 using System.Threading;
@@ -10,34 +6,44 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Data.Events;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Controller.Plugins;
 using MediaBrowser.Controller.Session;
 using MediaBrowser.Model.Session;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.LiveTv
+namespace Jellyfin.LiveTv.Recordings
 {
-    public sealed class RecordingNotifier : IServerEntryPoint
+    /// <summary>
+    /// <see cref="IHostedService"/> responsible for notifying users when a LiveTV recording is completed.
+    /// </summary>
+    public sealed class RecordingNotifier : IHostedService
     {
-        private readonly ILiveTvManager _liveTvManager;
+        private readonly ILogger<RecordingNotifier> _logger;
         private readonly ISessionManager _sessionManager;
         private readonly IUserManager _userManager;
-        private readonly ILogger<RecordingNotifier> _logger;
+        private readonly ILiveTvManager _liveTvManager;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RecordingNotifier"/> class.
+        /// </summary>
+        /// <param name="logger">The <see cref="ILogger"/>.</param>
+        /// <param name="sessionManager">The <see cref="ISessionManager"/>.</param>
+        /// <param name="userManager">The <see cref="IUserManager"/>.</param>
+        /// <param name="liveTvManager">The <see cref="ILiveTvManager"/>.</param>
         public RecordingNotifier(
+            ILogger<RecordingNotifier> logger,
             ISessionManager sessionManager,
             IUserManager userManager,
-            ILogger<RecordingNotifier> logger,
             ILiveTvManager liveTvManager)
         {
+            _logger = logger;
             _sessionManager = sessionManager;
             _userManager = userManager;
-            _logger = logger;
             _liveTvManager = liveTvManager;
         }
 
         /// <inheritdoc />
-        public Task RunAsync()
+        public Task StartAsync(CancellationToken cancellationToken)
         {
             _liveTvManager.TimerCancelled += OnLiveTvManagerTimerCancelled;
             _liveTvManager.SeriesTimerCancelled += OnLiveTvManagerSeriesTimerCancelled;
@@ -47,29 +53,35 @@ namespace Jellyfin.LiveTv
             return Task.CompletedTask;
         }
 
-        private async void OnLiveTvManagerSeriesTimerCreated(object sender, GenericEventArgs<TimerEventInfo> e)
+        /// <inheritdoc />
+        public Task StopAsync(CancellationToken cancellationToken)
         {
-            await SendMessage(SessionMessageType.SeriesTimerCreated, e.Argument).ConfigureAwait(false);
-        }
+            _liveTvManager.TimerCancelled -= OnLiveTvManagerTimerCancelled;
+            _liveTvManager.SeriesTimerCancelled -= OnLiveTvManagerSeriesTimerCancelled;
+            _liveTvManager.TimerCreated -= OnLiveTvManagerTimerCreated;
+            _liveTvManager.SeriesTimerCreated -= OnLiveTvManagerSeriesTimerCreated;
 
-        private async void OnLiveTvManagerTimerCreated(object sender, GenericEventArgs<TimerEventInfo> e)
-        {
-            await SendMessage(SessionMessageType.TimerCreated, e.Argument).ConfigureAwait(false);
+            return Task.CompletedTask;
         }
 
-        private async void OnLiveTvManagerSeriesTimerCancelled(object sender, GenericEventArgs<TimerEventInfo> e)
-        {
-            await SendMessage(SessionMessageType.SeriesTimerCancelled, e.Argument).ConfigureAwait(false);
-        }
+        private async void OnLiveTvManagerSeriesTimerCreated(object? sender, GenericEventArgs<TimerEventInfo> e)
+            => await SendMessage(SessionMessageType.SeriesTimerCreated, e.Argument).ConfigureAwait(false);
 
-        private async void OnLiveTvManagerTimerCancelled(object sender, GenericEventArgs<TimerEventInfo> e)
-        {
-            await SendMessage(SessionMessageType.TimerCancelled, e.Argument).ConfigureAwait(false);
-        }
+        private async void OnLiveTvManagerTimerCreated(object? sender, GenericEventArgs<TimerEventInfo> e)
+            => await SendMessage(SessionMessageType.TimerCreated, e.Argument).ConfigureAwait(false);
+
+        private async void OnLiveTvManagerSeriesTimerCancelled(object? sender, GenericEventArgs<TimerEventInfo> e)
+            => await SendMessage(SessionMessageType.SeriesTimerCancelled, e.Argument).ConfigureAwait(false);
+
+        private async void OnLiveTvManagerTimerCancelled(object? sender, GenericEventArgs<TimerEventInfo> e)
+            => await SendMessage(SessionMessageType.TimerCancelled, e.Argument).ConfigureAwait(false);
 
         private async Task SendMessage(SessionMessageType name, TimerEventInfo info)
         {
-            var users = _userManager.Users.Where(i => i.HasPermission(PermissionKind.EnableLiveTvAccess)).Select(i => i.Id).ToList();
+            var users = _userManager.Users
+                .Where(i => i.HasPermission(PermissionKind.EnableLiveTvAccess))
+                .Select(i => i.Id)
+                .ToList();
 
             try
             {
@@ -80,14 +92,5 @@ namespace Jellyfin.LiveTv
                 _logger.LogError(ex, "Error sending message");
             }
         }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _liveTvManager.TimerCancelled -= OnLiveTvManagerTimerCancelled;
-            _liveTvManager.SeriesTimerCancelled -= OnLiveTvManagerSeriesTimerCancelled;
-            _liveTvManager.TimerCreated -= OnLiveTvManagerTimerCreated;
-            _liveTvManager.SeriesTimerCreated -= OnLiveTvManagerSeriesTimerCreated;
-        }
     }
 }
diff --git a/src/Jellyfin.LiveTv/Recordings/RecordingsHost.cs b/src/Jellyfin.LiveTv/Recordings/RecordingsHost.cs
new file mode 100644
index 000000000..f4daa0975
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingsHost.cs
@@ -0,0 +1,37 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.LiveTv.Timers;
+using MediaBrowser.Controller.LiveTv;
+using Microsoft.Extensions.Hosting;
+
+namespace Jellyfin.LiveTv.Recordings;
+
+/// <summary>
+/// <see cref="IHostedService"/> responsible for Live TV recordings.
+/// </summary>
+public sealed class RecordingsHost : IHostedService
+{
+    private readonly IRecordingsManager _recordingsManager;
+    private readonly TimerManager _timerManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingsHost"/> class.
+    /// </summary>
+    /// <param name="recordingsManager">The <see cref="IRecordingsManager"/>.</param>
+    /// <param name="timerManager">The <see cref="TimerManager"/>.</param>
+    public RecordingsHost(IRecordingsManager recordingsManager, TimerManager timerManager)
+    {
+        _recordingsManager = recordingsManager;
+        _timerManager = timerManager;
+    }
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _timerManager.RestartTimers();
+        return _recordingsManager.CreateRecordingFolders();
+    }
+
+    /// <inheritdoc />
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
diff --git a/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs b/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs
new file mode 100644
index 000000000..92605a1eb
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs
@@ -0,0 +1,837 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using AsyncKeyedLock;
+using Jellyfin.Data.Enums;
+using Jellyfin.LiveTv.Configuration;
+using Jellyfin.LiveTv.IO;
+using Jellyfin.LiveTv.Timers;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.LiveTv;
+using MediaBrowser.Model.MediaInfo;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv.Recordings;
+
+/// <inheritdoc cref="IRecordingsManager" />
+public sealed class RecordingsManager : IRecordingsManager, IDisposable
+{
+    private readonly ILogger<RecordingsManager> _logger;
+    private readonly IServerConfigurationManager _config;
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly IFileSystem _fileSystem;
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILibraryMonitor _libraryMonitor;
+    private readonly IProviderManager _providerManager;
+    private readonly IMediaEncoder _mediaEncoder;
+    private readonly IMediaSourceManager _mediaSourceManager;
+    private readonly IStreamHelper _streamHelper;
+    private readonly TimerManager _timerManager;
+    private readonly SeriesTimerManager _seriesTimerManager;
+    private readonly RecordingsMetadataManager _recordingsMetadataManager;
+
+    private readonly ConcurrentDictionary<string, ActiveRecordingInfo> _activeRecordings = new(StringComparer.OrdinalIgnoreCase);
+    private readonly AsyncNonKeyedLocker _recordingDeleteSemaphore = new();
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingsManager"/> class.
+    /// </summary>
+    /// <param name="logger">The <see cref="ILogger"/>.</param>
+    /// <param name="config">The <see cref="IServerConfigurationManager"/>.</param>
+    /// <param name="httpClientFactory">The <see cref="IHttpClientFactory"/>.</param>
+    /// <param name="fileSystem">The <see cref="IFileSystem"/>.</param>
+    /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param>
+    /// <param name="libraryMonitor">The <see cref="ILibraryMonitor"/>.</param>
+    /// <param name="providerManager">The <see cref="IProviderManager"/>.</param>
+    /// <param name="mediaEncoder">The <see cref="IMediaEncoder"/>.</param>
+    /// <param name="mediaSourceManager">The <see cref="IMediaSourceManager"/>.</param>
+    /// <param name="streamHelper">The <see cref="IStreamHelper"/>.</param>
+    /// <param name="timerManager">The <see cref="TimerManager"/>.</param>
+    /// <param name="seriesTimerManager">The <see cref="SeriesTimerManager"/>.</param>
+    /// <param name="recordingsMetadataManager">The <see cref="RecordingsMetadataManager"/>.</param>
+    public RecordingsManager(
+        ILogger<RecordingsManager> logger,
+        IServerConfigurationManager config,
+        IHttpClientFactory httpClientFactory,
+        IFileSystem fileSystem,
+        ILibraryManager libraryManager,
+        ILibraryMonitor libraryMonitor,
+        IProviderManager providerManager,
+        IMediaEncoder mediaEncoder,
+        IMediaSourceManager mediaSourceManager,
+        IStreamHelper streamHelper,
+        TimerManager timerManager,
+        SeriesTimerManager seriesTimerManager,
+        RecordingsMetadataManager recordingsMetadataManager)
+    {
+        _logger = logger;
+        _config = config;
+        _httpClientFactory = httpClientFactory;
+        _fileSystem = fileSystem;
+        _libraryManager = libraryManager;
+        _libraryMonitor = libraryMonitor;
+        _providerManager = providerManager;
+        _mediaEncoder = mediaEncoder;
+        _mediaSourceManager = mediaSourceManager;
+        _streamHelper = streamHelper;
+        _timerManager = timerManager;
+        _seriesTimerManager = seriesTimerManager;
+        _recordingsMetadataManager = recordingsMetadataManager;
+
+        _config.NamedConfigurationUpdated += OnNamedConfigurationUpdated;
+    }
+
+    private string DefaultRecordingPath
+    {
+        get
+        {
+            var path = _config.GetLiveTvConfiguration().RecordingPath;
+
+            return string.IsNullOrWhiteSpace(path)
+                ? Path.Combine(_config.CommonApplicationPaths.DataPath, "livetv", "recordings")
+                : path;
+        }
+    }
+
+    /// <inheritdoc />
+    public string? GetActiveRecordingPath(string id)
+        => _activeRecordings.GetValueOrDefault(id)?.Path;
+
+    /// <inheritdoc />
+    public ActiveRecordingInfo? GetActiveRecordingInfo(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path) || _activeRecordings.IsEmpty)
+        {
+            return null;
+        }
+
+        foreach (var (_, recordingInfo) in _activeRecordings)
+        {
+            if (string.Equals(recordingInfo.Path, path, StringComparison.Ordinal)
+                && !recordingInfo.CancellationTokenSource.IsCancellationRequested)
+            {
+                return recordingInfo.Timer.Status == RecordingStatus.InProgress ? recordingInfo : null;
+            }
+        }
+
+        return null;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<VirtualFolderInfo> GetRecordingFolders()
+    {
+        if (Directory.Exists(DefaultRecordingPath))
+        {
+            yield return new VirtualFolderInfo
+            {
+                Locations = [DefaultRecordingPath],
+                Name = "Recordings"
+            };
+        }
+
+        var customPath = _config.GetLiveTvConfiguration().MovieRecordingPath;
+        if (!string.IsNullOrWhiteSpace(customPath)
+            && !string.Equals(customPath, DefaultRecordingPath, StringComparison.OrdinalIgnoreCase)
+            && Directory.Exists(customPath))
+        {
+            yield return new VirtualFolderInfo
+            {
+                Locations = [customPath],
+                Name = "Recorded Movies",
+                CollectionType = CollectionTypeOptions.Movies
+            };
+        }
+
+        customPath = _config.GetLiveTvConfiguration().SeriesRecordingPath;
+        if (!string.IsNullOrWhiteSpace(customPath)
+            && !string.Equals(customPath, DefaultRecordingPath, StringComparison.OrdinalIgnoreCase)
+            && Directory.Exists(customPath))
+        {
+            yield return new VirtualFolderInfo
+            {
+                Locations = [customPath],
+                Name = "Recorded Shows",
+                CollectionType = CollectionTypeOptions.TvShows
+            };
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task CreateRecordingFolders()
+    {
+        try
+        {
+            var recordingFolders = GetRecordingFolders().ToArray();
+            var virtualFolders = _libraryManager.GetVirtualFolders();
+
+            var allExistingPaths = virtualFolders.SelectMany(i => i.Locations).ToList();
+
+            var pathsAdded = new List<string>();
+
+            foreach (var recordingFolder in recordingFolders)
+            {
+                var pathsToCreate = recordingFolder.Locations
+                    .Where(i => !allExistingPaths.Any(p => _fileSystem.AreEqual(p, i)))
+                    .ToList();
+
+                if (pathsToCreate.Count == 0)
+                {
+                    continue;
+                }
+
+                var mediaPathInfos = pathsToCreate.Select(i => new MediaPathInfo(i)).ToArray();
+                var libraryOptions = new LibraryOptions
+                {
+                    PathInfos = mediaPathInfos
+                };
+
+                try
+                {
+                    await _libraryManager
+                        .AddVirtualFolder(recordingFolder.Name, recordingFolder.CollectionType, libraryOptions, true)
+                        .ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error creating virtual folder");
+                }
+
+                pathsAdded.AddRange(pathsToCreate);
+            }
+
+            var config = _config.GetLiveTvConfiguration();
+
+            var pathsToRemove = config.MediaLocationsCreated
+                .Except(recordingFolders.SelectMany(i => i.Locations))
+                .ToList();
+
+            if (pathsAdded.Count > 0 || pathsToRemove.Count > 0)
+            {
+                pathsAdded.InsertRange(0, config.MediaLocationsCreated);
+                config.MediaLocationsCreated = pathsAdded.Except(pathsToRemove).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
+                _config.SaveConfiguration("livetv", config);
+            }
+
+            foreach (var path in pathsToRemove)
+            {
+                await RemovePathFromLibraryAsync(path).ConfigureAwait(false);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error creating recording folders");
+        }
+    }
+
+    private async Task RemovePathFromLibraryAsync(string path)
+    {
+        _logger.LogDebug("Removing path from library: {0}", path);
+
+        var requiresRefresh = false;
+        var virtualFolders = _libraryManager.GetVirtualFolders();
+
+        foreach (var virtualFolder in virtualFolders)
+        {
+            if (!virtualFolder.Locations.Contains(path, StringComparer.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            if (virtualFolder.Locations.Length == 1)
+            {
+                try
+                {
+                    await _libraryManager.RemoveVirtualFolder(virtualFolder.Name, true).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error removing virtual folder");
+                }
+            }
+            else
+            {
+                try
+                {
+                    _libraryManager.RemoveMediaPath(virtualFolder.Name, path);
+                    requiresRefresh = true;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error removing media path");
+                }
+            }
+        }
+
+        if (requiresRefresh)
+        {
+            await _libraryManager.ValidateMediaLibrary(new Progress<double>(), CancellationToken.None).ConfigureAwait(false);
+        }
+    }
+
+    /// <inheritdoc />
+    public void CancelRecording(string timerId, TimerInfo? timer)
+    {
+        if (_activeRecordings.TryGetValue(timerId, out var activeRecordingInfo))
+        {
+            activeRecordingInfo.Timer = timer;
+            activeRecordingInfo.CancellationTokenSource.Cancel();
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task RecordStream(ActiveRecordingInfo recordingInfo, BaseItem channel, DateTime recordingEndDate)
+    {
+        ArgumentNullException.ThrowIfNull(recordingInfo);
+        ArgumentNullException.ThrowIfNull(channel);
+
+        var timer = recordingInfo.Timer;
+        var remoteMetadata = await FetchInternetMetadata(timer, CancellationToken.None).ConfigureAwait(false);
+        var recordingPath = GetRecordingPath(timer, remoteMetadata, out var seriesPath);
+
+        string? liveStreamId = null;
+        RecordingStatus recordingStatus;
+        try
+        {
+            var allMediaSources = await _mediaSourceManager
+                .GetPlaybackMediaSources(channel, null, true, false, CancellationToken.None).ConfigureAwait(false);
+
+            var mediaStreamInfo = allMediaSources[0];
+            IDirectStreamProvider? directStreamProvider = null;
+            if (mediaStreamInfo.RequiresOpening)
+            {
+                var liveStreamResponse = await _mediaSourceManager.OpenLiveStreamInternal(
+                    new LiveStreamRequest
+                    {
+                        ItemId = channel.Id,
+                        OpenToken = mediaStreamInfo.OpenToken
+                    },
+                    CancellationToken.None).ConfigureAwait(false);
+
+                mediaStreamInfo = liveStreamResponse.Item1.MediaSource;
+                liveStreamId = mediaStreamInfo.LiveStreamId;
+                directStreamProvider = liveStreamResponse.Item2;
+            }
+
+            using var recorder = GetRecorder(mediaStreamInfo);
+
+            recordingPath = recorder.GetOutputPath(mediaStreamInfo, recordingPath);
+            recordingPath = EnsureFileUnique(recordingPath, timer.Id);
+
+            _libraryMonitor.ReportFileSystemChangeBeginning(recordingPath);
+
+            var duration = recordingEndDate - DateTime.UtcNow;
+
+            _logger.LogInformation("Beginning recording. Will record for {Duration} minutes.", duration.TotalMinutes);
+            _logger.LogInformation("Writing file to: {Path}", recordingPath);
+
+            async void OnStarted()
+            {
+                recordingInfo.Path = recordingPath;
+                _activeRecordings.TryAdd(timer.Id, recordingInfo);
+
+                timer.Status = RecordingStatus.InProgress;
+                _timerManager.AddOrUpdate(timer, false);
+
+                await _recordingsMetadataManager.SaveRecordingMetadata(timer, recordingPath, seriesPath).ConfigureAwait(false);
+                await CreateRecordingFolders().ConfigureAwait(false);
+
+                TriggerRefresh(recordingPath);
+                await EnforceKeepUpTo(timer, seriesPath).ConfigureAwait(false);
+            }
+
+            await recorder.Record(
+                directStreamProvider,
+                mediaStreamInfo,
+                recordingPath,
+                duration,
+                OnStarted,
+                recordingInfo.CancellationTokenSource.Token).ConfigureAwait(false);
+
+            recordingStatus = RecordingStatus.Completed;
+            _logger.LogInformation("Recording completed: {RecordPath}", recordingPath);
+        }
+        catch (OperationCanceledException)
+        {
+            _logger.LogInformation("Recording stopped: {RecordPath}", recordingPath);
+            recordingStatus = RecordingStatus.Completed;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error recording to {RecordPath}", recordingPath);
+            recordingStatus = RecordingStatus.Error;
+        }
+
+        if (!string.IsNullOrWhiteSpace(liveStreamId))
+        {
+            try
+            {
+                await _mediaSourceManager.CloseLiveStream(liveStreamId).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error closing live stream");
+            }
+        }
+
+        DeleteFileIfEmpty(recordingPath);
+        TriggerRefresh(recordingPath);
+        _libraryMonitor.ReportFileSystemChangeComplete(recordingPath, false);
+        _activeRecordings.TryRemove(timer.Id, out _);
+
+        if (recordingStatus != RecordingStatus.Completed && DateTime.UtcNow < timer.EndDate && timer.RetryCount < 10)
+        {
+            const int RetryIntervalSeconds = 60;
+            _logger.LogInformation("Retrying recording in {0} seconds.", RetryIntervalSeconds);
+
+            timer.Status = RecordingStatus.New;
+            timer.PrePaddingSeconds = 0;
+            timer.StartDate = DateTime.UtcNow.AddSeconds(RetryIntervalSeconds);
+            timer.RetryCount++;
+            _timerManager.AddOrUpdate(timer);
+        }
+        else if (File.Exists(recordingPath))
+        {
+            timer.RecordingPath = recordingPath;
+            timer.Status = RecordingStatus.Completed;
+            _timerManager.AddOrUpdate(timer, false);
+            await PostProcessRecording(recordingPath).ConfigureAwait(false);
+        }
+        else
+        {
+            _timerManager.Delete(timer);
+        }
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _recordingDeleteSemaphore.Dispose();
+
+        foreach (var pair in _activeRecordings.ToList())
+        {
+            pair.Value.CancellationTokenSource.Cancel();
+        }
+
+        _disposed = true;
+    }
+
+    private async void OnNamedConfigurationUpdated(object? sender, ConfigurationUpdateEventArgs e)
+    {
+        if (string.Equals(e.Key, "livetv", StringComparison.OrdinalIgnoreCase))
+        {
+            await CreateRecordingFolders().ConfigureAwait(false);
+        }
+    }
+
+    private async Task<RemoteSearchResult?> FetchInternetMetadata(TimerInfo timer, CancellationToken cancellationToken)
+    {
+        if (!timer.IsSeries || timer.SeriesProviderIds.Count == 0)
+        {
+            return null;
+        }
+
+        var query = new RemoteSearchQuery<SeriesInfo>
+        {
+            SearchInfo = new SeriesInfo
+            {
+                ProviderIds = timer.SeriesProviderIds,
+                Name = timer.Name,
+                MetadataCountryCode = _config.Configuration.MetadataCountryCode,
+                MetadataLanguage = _config.Configuration.PreferredMetadataLanguage
+            }
+        };
+
+        var results = await _providerManager.GetRemoteSearchResults<Series, SeriesInfo>(query, cancellationToken).ConfigureAwait(false);
+
+        return results.FirstOrDefault();
+    }
+
+    private string GetRecordingPath(TimerInfo timer, RemoteSearchResult? metadata, out string? seriesPath)
+    {
+        var recordingPath = DefaultRecordingPath;
+        var config = _config.GetLiveTvConfiguration();
+        seriesPath = null;
+
+        if (timer.IsProgramSeries)
+        {
+            var customRecordingPath = config.SeriesRecordingPath;
+            var allowSubfolder = true;
+            if (!string.IsNullOrWhiteSpace(customRecordingPath))
+            {
+                allowSubfolder = string.Equals(customRecordingPath, recordingPath, StringComparison.OrdinalIgnoreCase);
+                recordingPath = customRecordingPath;
+            }
+
+            if (allowSubfolder && config.EnableRecordingSubfolders)
+            {
+                recordingPath = Path.Combine(recordingPath, "Series");
+            }
+
+            // trim trailing period from the folder name
+            var folderName = _fileSystem.GetValidFilename(timer.Name).Trim().TrimEnd('.').Trim();
+
+            if (metadata is not null && metadata.ProductionYear.HasValue)
+            {
+                folderName += " (" + metadata.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
+            }
+
+            // Can't use the year here in the folder name because it is the year of the episode, not the series.
+            recordingPath = Path.Combine(recordingPath, folderName);
+
+            seriesPath = recordingPath;
+
+            if (timer.SeasonNumber.HasValue)
+            {
+                folderName = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "Season {0}",
+                    timer.SeasonNumber.Value);
+                recordingPath = Path.Combine(recordingPath, folderName);
+            }
+        }
+        else if (timer.IsMovie)
+        {
+            var customRecordingPath = config.MovieRecordingPath;
+            var allowSubfolder = true;
+            if (!string.IsNullOrWhiteSpace(customRecordingPath))
+            {
+                allowSubfolder = string.Equals(customRecordingPath, recordingPath, StringComparison.OrdinalIgnoreCase);
+                recordingPath = customRecordingPath;
+            }
+
+            if (allowSubfolder && config.EnableRecordingSubfolders)
+            {
+                recordingPath = Path.Combine(recordingPath, "Movies");
+            }
+
+            var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
+            if (timer.ProductionYear.HasValue)
+            {
+                folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
+            }
+
+            // trim trailing period from the folder name
+            folderName = folderName.TrimEnd('.').Trim();
+
+            recordingPath = Path.Combine(recordingPath, folderName);
+        }
+        else if (timer.IsKids)
+        {
+            if (config.EnableRecordingSubfolders)
+            {
+                recordingPath = Path.Combine(recordingPath, "Kids");
+            }
+
+            var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
+            if (timer.ProductionYear.HasValue)
+            {
+                folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
+            }
+
+            // trim trailing period from the folder name
+            folderName = folderName.TrimEnd('.').Trim();
+
+            recordingPath = Path.Combine(recordingPath, folderName);
+        }
+        else if (timer.IsSports)
+        {
+            if (config.EnableRecordingSubfolders)
+            {
+                recordingPath = Path.Combine(recordingPath, "Sports");
+            }
+
+            recordingPath = Path.Combine(recordingPath, _fileSystem.GetValidFilename(timer.Name).Trim());
+        }
+        else
+        {
+            if (config.EnableRecordingSubfolders)
+            {
+                recordingPath = Path.Combine(recordingPath, "Other");
+            }
+
+            recordingPath = Path.Combine(recordingPath, _fileSystem.GetValidFilename(timer.Name).Trim());
+        }
+
+        var recordingFileName = _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer)).Trim() + ".ts";
+
+        return Path.Combine(recordingPath, recordingFileName);
+    }
+
+    private void DeleteFileIfEmpty(string path)
+    {
+        var file = _fileSystem.GetFileInfo(path);
+
+        if (file.Exists && file.Length == 0)
+        {
+            try
+            {
+                _fileSystem.DeleteFile(path);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error deleting 0-byte failed recording file {Path}", path);
+            }
+        }
+    }
+
+    private void TriggerRefresh(string path)
+    {
+        _logger.LogInformation("Triggering refresh on {Path}", path);
+
+        var item = GetAffectedBaseItem(Path.GetDirectoryName(path));
+        if (item is null)
+        {
+            return;
+        }
+
+        _logger.LogInformation("Refreshing recording parent {Path}", item.Path);
+        _providerManager.QueueRefresh(
+            item.Id,
+            new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+            {
+                RefreshPaths =
+                [
+                    path,
+                    Path.GetDirectoryName(path),
+                    Path.GetDirectoryName(Path.GetDirectoryName(path))
+                ]
+            },
+            RefreshPriority.High);
+    }
+
+    private BaseItem? GetAffectedBaseItem(string? path)
+    {
+        BaseItem? item = null;
+        var parentPath = Path.GetDirectoryName(path);
+        while (item is null && !string.IsNullOrEmpty(path))
+        {
+            item = _libraryManager.FindByPath(path, null);
+            path = Path.GetDirectoryName(path);
+        }
+
+        if (item is not null
+            && item.GetType() == typeof(Folder)
+            && string.Equals(item.Path, parentPath, StringComparison.OrdinalIgnoreCase))
+        {
+            var parentItem = item.GetParent();
+            if (parentItem is not null && parentItem is not AggregateFolder)
+            {
+                item = parentItem;
+            }
+        }
+
+        return item;
+    }
+
+    private async Task EnforceKeepUpTo(TimerInfo timer, string? seriesPath)
+    {
+        if (string.IsNullOrWhiteSpace(timer.SeriesTimerId)
+            || string.IsNullOrWhiteSpace(seriesPath))
+        {
+            return;
+        }
+
+        var seriesTimerId = timer.SeriesTimerId;
+        var seriesTimer = _seriesTimerManager.GetAll()
+            .FirstOrDefault(i => string.Equals(i.Id, seriesTimerId, StringComparison.OrdinalIgnoreCase));
+
+        if (seriesTimer is null || seriesTimer.KeepUpTo <= 0)
+        {
+            return;
+        }
+
+        if (_disposed)
+        {
+            return;
+        }
+
+        using (await _recordingDeleteSemaphore.LockAsync().ConfigureAwait(false))
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            var timersToDelete = _timerManager.GetAll()
+                .Where(timerInfo => timerInfo.Status == RecordingStatus.Completed
+                    && !string.IsNullOrWhiteSpace(timerInfo.RecordingPath)
+                    && string.Equals(timerInfo.SeriesTimerId, seriesTimerId, StringComparison.OrdinalIgnoreCase)
+                    && File.Exists(timerInfo.RecordingPath))
+                .OrderByDescending(i => i.EndDate)
+                .Skip(seriesTimer.KeepUpTo - 1)
+                .ToList();
+
+            DeleteLibraryItemsForTimers(timersToDelete);
+
+            if (_libraryManager.FindByPath(seriesPath, true) is not Folder librarySeries)
+            {
+                return;
+            }
+
+            var episodesToDelete = librarySeries.GetItemList(
+                    new InternalItemsQuery
+                    {
+                        OrderBy = [(ItemSortBy.DateCreated, SortOrder.Descending)],
+                        IsVirtualItem = false,
+                        IsFolder = false,
+                        Recursive = true,
+                        DtoOptions = new DtoOptions(true)
+                    })
+                .Where(i => i.IsFileProtocol && File.Exists(i.Path))
+                .Skip(seriesTimer.KeepUpTo - 1);
+
+            foreach (var item in episodesToDelete)
+            {
+                try
+                {
+                    _libraryManager.DeleteItem(
+                        item,
+                        new DeleteOptions
+                        {
+                            DeleteFileLocation = true
+                        },
+                        true);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error deleting item");
+                }
+            }
+        }
+    }
+
+    private void DeleteLibraryItemsForTimers(List<TimerInfo> timers)
+    {
+        foreach (var timer in timers)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            try
+            {
+                DeleteLibraryItemForTimer(timer);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error deleting recording");
+            }
+        }
+    }
+
+    private void DeleteLibraryItemForTimer(TimerInfo timer)
+    {
+        var libraryItem = _libraryManager.FindByPath(timer.RecordingPath, false);
+        if (libraryItem is not null)
+        {
+            _libraryManager.DeleteItem(
+                libraryItem,
+                new DeleteOptions
+                {
+                    DeleteFileLocation = true
+                },
+                true);
+        }
+        else if (File.Exists(timer.RecordingPath))
+        {
+            _fileSystem.DeleteFile(timer.RecordingPath);
+        }
+
+        _timerManager.Delete(timer);
+    }
+
+    private string EnsureFileUnique(string path, string timerId)
+    {
+        var parent = Path.GetDirectoryName(path)!;
+        var name = Path.GetFileNameWithoutExtension(path);
+        var extension = Path.GetExtension(path);
+
+        var index = 1;
+        while (File.Exists(path) || _activeRecordings.Any(i
+                   => string.Equals(i.Value.Path, path, StringComparison.OrdinalIgnoreCase)
+                      && !string.Equals(i.Value.Timer.Id, timerId, StringComparison.OrdinalIgnoreCase)))
+        {
+            name += " - " + index.ToString(CultureInfo.InvariantCulture);
+
+            path = Path.ChangeExtension(Path.Combine(parent, name), extension);
+            index++;
+        }
+
+        return path;
+    }
+
+    private IRecorder GetRecorder(MediaSourceInfo mediaSource)
+    {
+        if (mediaSource.RequiresLooping
+            || !(mediaSource.Container ?? string.Empty).EndsWith("ts", StringComparison.OrdinalIgnoreCase)
+            || (mediaSource.Protocol != MediaProtocol.File && mediaSource.Protocol != MediaProtocol.Http))
+        {
+            return new EncodedRecorder(_logger, _mediaEncoder, _config.ApplicationPaths, _config);
+        }
+
+        return new DirectRecorder(_logger, _httpClientFactory, _streamHelper);
+    }
+
+    private async Task PostProcessRecording(string path)
+    {
+        var options = _config.GetLiveTvConfiguration();
+        if (string.IsNullOrWhiteSpace(options.RecordingPostProcessor))
+        {
+            return;
+        }
+
+        try
+        {
+            using var process = new Process();
+            process.StartInfo = new ProcessStartInfo
+            {
+                Arguments = options.RecordingPostProcessorArguments
+                    .Replace("{path}", path, StringComparison.OrdinalIgnoreCase),
+                CreateNoWindow = true,
+                ErrorDialog = false,
+                FileName = options.RecordingPostProcessor,
+                WindowStyle = ProcessWindowStyle.Hidden,
+                UseShellExecute = false
+            };
+            process.EnableRaisingEvents = true;
+
+            _logger.LogInformation("Running recording post processor {0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
+
+            process.Start();
+            await process.WaitForExitAsync(CancellationToken.None).ConfigureAwait(false);
+
+            _logger.LogInformation("Recording post-processing script completed with exit code {ExitCode}", process.ExitCode);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error running recording post processor");
+        }
+    }
+}
diff --git a/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs b/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs
new file mode 100644
index 000000000..b2b82332d
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs
@@ -0,0 +1,501 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using Jellyfin.LiveTv.Configuration;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv.Recordings;
+
+/// <summary>
+/// A service responsible for saving recording metadata.
+/// </summary>
+public class RecordingsMetadataManager
+{
+    private const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
+
+    private readonly ILogger<RecordingsMetadataManager> _logger;
+    private readonly IConfigurationManager _config;
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingsMetadataManager"/> class.
+    /// </summary>
+    /// <param name="logger">The <see cref="ILogger"/>.</param>
+    /// <param name="config">The <see cref="IConfigurationManager"/>.</param>
+    /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param>
+    public RecordingsMetadataManager(
+        ILogger<RecordingsMetadataManager> logger,
+        IConfigurationManager config,
+        ILibraryManager libraryManager)
+    {
+        _logger = logger;
+        _config = config;
+        _libraryManager = libraryManager;
+    }
+
+    /// <summary>
+    /// Saves the metadata for a provided recording.
+    /// </summary>
+    /// <param name="timer">The recording timer.</param>
+    /// <param name="recordingPath">The recording path.</param>
+    /// <param name="seriesPath">The series path.</param>
+    /// <returns>A task representing the metadata saving.</returns>
+    public async Task SaveRecordingMetadata(TimerInfo timer, string recordingPath, string? seriesPath)
+    {
+        try
+        {
+            var program = string.IsNullOrWhiteSpace(timer.ProgramId) ? null : _libraryManager.GetItemList(new InternalItemsQuery
+            {
+                IncludeItemTypes = [BaseItemKind.LiveTvProgram],
+                Limit = 1,
+                ExternalId = timer.ProgramId,
+                DtoOptions = new DtoOptions(true)
+            }).FirstOrDefault() as LiveTvProgram;
+
+            // dummy this up
+            program ??= new LiveTvProgram
+            {
+                Name = timer.Name,
+                Overview = timer.Overview,
+                Genres = timer.Genres,
+                CommunityRating = timer.CommunityRating,
+                OfficialRating = timer.OfficialRating,
+                ProductionYear = timer.ProductionYear,
+                PremiereDate = timer.OriginalAirDate,
+                IndexNumber = timer.EpisodeNumber,
+                ParentIndexNumber = timer.SeasonNumber
+            };
+
+            if (timer.IsSports)
+            {
+                program.AddGenre("Sports");
+            }
+
+            if (timer.IsKids)
+            {
+                program.AddGenre("Kids");
+                program.AddGenre("Children");
+            }
+
+            if (timer.IsNews)
+            {
+                program.AddGenre("News");
+            }
+
+            var config = _config.GetLiveTvConfiguration();
+
+            if (config.SaveRecordingNFO)
+            {
+                if (timer.IsProgramSeries)
+                {
+                    ArgumentNullException.ThrowIfNull(seriesPath);
+
+                    await SaveSeriesNfoAsync(timer, seriesPath).ConfigureAwait(false);
+                    await SaveVideoNfoAsync(timer, recordingPath, program, false).ConfigureAwait(false);
+                }
+                else if (!timer.IsMovie || timer.IsSports || timer.IsNews)
+                {
+                    await SaveVideoNfoAsync(timer, recordingPath, program, true).ConfigureAwait(false);
+                }
+                else
+                {
+                    await SaveVideoNfoAsync(timer, recordingPath, program, false).ConfigureAwait(false);
+                }
+            }
+
+            if (config.SaveRecordingImages)
+            {
+                await SaveRecordingImages(recordingPath, program).ConfigureAwait(false);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error saving nfo");
+        }
+    }
+
+    private static async Task SaveSeriesNfoAsync(TimerInfo timer, string seriesPath)
+    {
+        var nfoPath = Path.Combine(seriesPath, "tvshow.nfo");
+
+        if (File.Exists(nfoPath))
+        {
+            return;
+        }
+
+        var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
+        await using (stream.ConfigureAwait(false))
+        {
+            var settings = new XmlWriterSettings
+            {
+                Indent = true,
+                Encoding = Encoding.UTF8,
+                Async = true
+            };
+
+            var writer = XmlWriter.Create(stream, settings);
+            await using (writer.ConfigureAwait(false))
+            {
+                await writer.WriteStartDocumentAsync(true).ConfigureAwait(false);
+                await writer.WriteStartElementAsync(null, "tvshow", null).ConfigureAwait(false);
+                if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Tvdb.ToString(), out var id))
+                {
+                    await writer.WriteElementStringAsync(null, "id", null, id).ConfigureAwait(false);
+                }
+
+                if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Imdb.ToString(), out id))
+                {
+                    await writer.WriteElementStringAsync(null, "imdb_id", null, id).ConfigureAwait(false);
+                }
+
+                if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Tmdb.ToString(), out id))
+                {
+                    await writer.WriteElementStringAsync(null, "tmdbid", null, id).ConfigureAwait(false);
+                }
+
+                if (timer.SeriesProviderIds.TryGetValue(MetadataProvider.Zap2It.ToString(), out id))
+                {
+                    await writer.WriteElementStringAsync(null, "zap2itid", null, id).ConfigureAwait(false);
+                }
+
+                if (!string.IsNullOrWhiteSpace(timer.Name))
+                {
+                    await writer.WriteElementStringAsync(null, "title", null, timer.Name).ConfigureAwait(false);
+                }
+
+                if (!string.IsNullOrWhiteSpace(timer.OfficialRating))
+                {
+                    await writer.WriteElementStringAsync(null, "mpaa", null, timer.OfficialRating).ConfigureAwait(false);
+                }
+
+                foreach (var genre in timer.Genres)
+                {
+                    await writer.WriteElementStringAsync(null, "genre", null, genre).ConfigureAwait(false);
+                }
+
+                await writer.WriteEndElementAsync().ConfigureAwait(false);
+                await writer.WriteEndDocumentAsync().ConfigureAwait(false);
+            }
+        }
+    }
+
+    private async Task SaveVideoNfoAsync(TimerInfo timer, string recordingPath, BaseItem item, bool lockData)
+    {
+        var nfoPath = Path.ChangeExtension(recordingPath, ".nfo");
+
+        if (File.Exists(nfoPath))
+        {
+            return;
+        }
+
+        var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
+        await using (stream.ConfigureAwait(false))
+        {
+            var settings = new XmlWriterSettings
+            {
+                Indent = true,
+                Encoding = Encoding.UTF8,
+                Async = true
+            };
+
+            var options = _config.GetNfoConfiguration();
+
+            var isSeriesEpisode = timer.IsProgramSeries;
+
+            var writer = XmlWriter.Create(stream, settings);
+            await using (writer.ConfigureAwait(false))
+            {
+                await writer.WriteStartDocumentAsync(true).ConfigureAwait(false);
+
+                if (isSeriesEpisode)
+                {
+                    await writer.WriteStartElementAsync(null, "episodedetails", null).ConfigureAwait(false);
+
+                    if (!string.IsNullOrWhiteSpace(timer.EpisodeTitle))
+                    {
+                        await writer.WriteElementStringAsync(null, "title", null, timer.EpisodeTitle).ConfigureAwait(false);
+                    }
+
+                    var premiereDate = item.PremiereDate ?? (!timer.IsRepeat ? DateTime.UtcNow : null);
+
+                    if (premiereDate.HasValue)
+                    {
+                        var formatString = options.ReleaseDateFormat;
+
+                        await writer.WriteElementStringAsync(
+                            null,
+                            "aired",
+                            null,
+                            premiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                    }
+
+                    if (item.IndexNumber.HasValue)
+                    {
+                        await writer.WriteElementStringAsync(null, "episode", null, item.IndexNumber.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                    }
+
+                    if (item.ParentIndexNumber.HasValue)
+                    {
+                        await writer.WriteElementStringAsync(null, "season", null, item.ParentIndexNumber.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    await writer.WriteStartElementAsync(null, "movie", null).ConfigureAwait(false);
+
+                    if (!string.IsNullOrWhiteSpace(item.Name))
+                    {
+                        await writer.WriteElementStringAsync(null, "title", null, item.Name).ConfigureAwait(false);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(item.OriginalTitle))
+                    {
+                        await writer.WriteElementStringAsync(null, "originaltitle", null, item.OriginalTitle).ConfigureAwait(false);
+                    }
+
+                    if (item.PremiereDate.HasValue)
+                    {
+                        var formatString = options.ReleaseDateFormat;
+
+                        await writer.WriteElementStringAsync(
+                            null,
+                            "premiered",
+                            null,
+                            item.PremiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                        await writer.WriteElementStringAsync(
+                            null,
+                            "releasedate",
+                            null,
+                            item.PremiereDate.Value.ToLocalTime().ToString(formatString, CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                    }
+                }
+
+                await writer.WriteElementStringAsync(
+                    null,
+                    "dateadded",
+                    null,
+                    DateTime.Now.ToString(DateAddedFormat, CultureInfo.InvariantCulture)).ConfigureAwait(false);
+
+                if (item.ProductionYear.HasValue)
+                {
+                    await writer.WriteElementStringAsync(null, "year", null, item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                }
+
+                if (!string.IsNullOrEmpty(item.OfficialRating))
+                {
+                    await writer.WriteElementStringAsync(null, "mpaa", null, item.OfficialRating).ConfigureAwait(false);
+                }
+
+                var overview = (item.Overview ?? string.Empty)
+                    .StripHtml()
+                    .Replace("&quot;", "'", StringComparison.Ordinal);
+
+                await writer.WriteElementStringAsync(null, "plot", null, overview).ConfigureAwait(false);
+
+                if (item.CommunityRating.HasValue)
+                {
+                    await writer.WriteElementStringAsync(null, "rating", null, item.CommunityRating.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                }
+
+                foreach (var genre in item.Genres)
+                {
+                    await writer.WriteElementStringAsync(null, "genre", null, genre).ConfigureAwait(false);
+                }
+
+                var people = item.Id.IsEmpty() ? new List<PersonInfo>() : _libraryManager.GetPeople(item);
+
+                var directors = people
+                    .Where(i => i.IsType(PersonKind.Director))
+                    .Select(i => i.Name)
+                    .ToList();
+
+                foreach (var person in directors)
+                {
+                    await writer.WriteElementStringAsync(null, "director", null, person).ConfigureAwait(false);
+                }
+
+                var writers = people
+                    .Where(i => i.IsType(PersonKind.Writer))
+                    .Select(i => i.Name)
+                    .Distinct(StringComparer.OrdinalIgnoreCase)
+                    .ToList();
+
+                foreach (var person in writers)
+                {
+                    await writer.WriteElementStringAsync(null, "writer", null, person).ConfigureAwait(false);
+                }
+
+                foreach (var person in writers)
+                {
+                    await writer.WriteElementStringAsync(null, "credits", null, person).ConfigureAwait(false);
+                }
+
+                var tmdbCollection = item.GetProviderId(MetadataProvider.TmdbCollection);
+
+                if (!string.IsNullOrEmpty(tmdbCollection))
+                {
+                    await writer.WriteElementStringAsync(null, "collectionnumber", null, tmdbCollection).ConfigureAwait(false);
+                }
+
+                var imdb = item.GetProviderId(MetadataProvider.Imdb);
+                if (!string.IsNullOrEmpty(imdb))
+                {
+                    if (!isSeriesEpisode)
+                    {
+                        await writer.WriteElementStringAsync(null, "id", null, imdb).ConfigureAwait(false);
+                    }
+
+                    await writer.WriteElementStringAsync(null, "imdbid", null, imdb).ConfigureAwait(false);
+
+                    // No need to lock if we have identified the content already
+                    lockData = false;
+                }
+
+                var tvdb = item.GetProviderId(MetadataProvider.Tvdb);
+                if (!string.IsNullOrEmpty(tvdb))
+                {
+                    await writer.WriteElementStringAsync(null, "tvdbid", null, tvdb).ConfigureAwait(false);
+
+                    // No need to lock if we have identified the content already
+                    lockData = false;
+                }
+
+                var tmdb = item.GetProviderId(MetadataProvider.Tmdb);
+                if (!string.IsNullOrEmpty(tmdb))
+                {
+                    await writer.WriteElementStringAsync(null, "tmdbid", null, tmdb).ConfigureAwait(false);
+
+                    // No need to lock if we have identified the content already
+                    lockData = false;
+                }
+
+                if (lockData)
+                {
+                    await writer.WriteElementStringAsync(null, "lockdata", null, "true").ConfigureAwait(false);
+                }
+
+                if (item.CriticRating.HasValue)
+                {
+                    await writer.WriteElementStringAsync(null, "criticrating", null, item.CriticRating.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+                }
+
+                if (!string.IsNullOrWhiteSpace(item.Tagline))
+                {
+                    await writer.WriteElementStringAsync(null, "tagline", null, item.Tagline).ConfigureAwait(false);
+                }
+
+                foreach (var studio in item.Studios)
+                {
+                    await writer.WriteElementStringAsync(null, "studio", null, studio).ConfigureAwait(false);
+                }
+
+                await writer.WriteEndElementAsync().ConfigureAwait(false);
+                await writer.WriteEndDocumentAsync().ConfigureAwait(false);
+            }
+        }
+    }
+
+    private async Task SaveRecordingImages(string recordingPath, LiveTvProgram program)
+    {
+        var image = program.IsSeries ?
+            (program.GetImageInfo(ImageType.Thumb, 0) ?? program.GetImageInfo(ImageType.Primary, 0)) :
+            (program.GetImageInfo(ImageType.Primary, 0) ?? program.GetImageInfo(ImageType.Thumb, 0));
+
+        if (image is not null)
+        {
+            try
+            {
+                await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error saving recording image");
+            }
+        }
+
+        if (!program.IsSeries)
+        {
+            image = program.GetImageInfo(ImageType.Backdrop, 0);
+            if (image is not null)
+            {
+                try
+                {
+                    await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error saving recording image");
+                }
+            }
+
+            image = program.GetImageInfo(ImageType.Thumb, 0);
+            if (image is not null)
+            {
+                try
+                {
+                    await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error saving recording image");
+                }
+            }
+
+            image = program.GetImageInfo(ImageType.Logo, 0);
+            if (image is not null)
+            {
+                try
+                {
+                    await SaveRecordingImage(recordingPath, program, image).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error saving recording image");
+                }
+            }
+        }
+    }
+
+    private async Task SaveRecordingImage(string recordingPath, LiveTvProgram program, ItemImageInfo image)
+    {
+        if (!image.IsLocalFile)
+        {
+            image = await _libraryManager.ConvertImageToLocal(program, image, 0).ConfigureAwait(false);
+        }
+
+        var imageSaveFilenameWithoutExtension = image.Type switch
+        {
+            ImageType.Primary => program.IsSeries ? Path.GetFileNameWithoutExtension(recordingPath) + "-thumb" : "poster",
+            ImageType.Logo => "logo",
+            ImageType.Thumb => program.IsSeries ? Path.GetFileNameWithoutExtension(recordingPath) + "-thumb" : "landscape",
+            ImageType.Backdrop => "fanart",
+            _ => null
+        };
+
+        if (imageSaveFilenameWithoutExtension is null)
+        {
+            return;
+        }
+
+        var imageSavePath = Path.Combine(Path.GetDirectoryName(recordingPath)!, imageSaveFilenameWithoutExtension);
+
+        // preserve original image extension
+        imageSavePath = Path.ChangeExtension(imageSavePath, Path.GetExtension(image.Path));
+
+        File.Copy(image.Path, imageSavePath, true);
+    }
+}
diff --git a/src/Jellyfin.LiveTv/RefreshGuideScheduledTask.cs b/src/Jellyfin.LiveTv/RefreshGuideScheduledTask.cs
deleted file mode 100644
index 18bd61d99..000000000
--- a/src/Jellyfin.LiveTv/RefreshGuideScheduledTask.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Jellyfin.LiveTv.Configuration;
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Model.Tasks;
-
-namespace Jellyfin.LiveTv
-{
-    /// <summary>
-    /// The "Refresh Guide" scheduled task.
-    /// </summary>
-    public class RefreshGuideScheduledTask : IScheduledTask, IConfigurableScheduledTask
-    {
-        private readonly ILiveTvManager _liveTvManager;
-        private readonly IConfigurationManager _config;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RefreshGuideScheduledTask"/> class.
-        /// </summary>
-        /// <param name="liveTvManager">The live tv manager.</param>
-        /// <param name="config">The configuration manager.</param>
-        public RefreshGuideScheduledTask(ILiveTvManager liveTvManager, IConfigurationManager config)
-        {
-            _liveTvManager = liveTvManager;
-            _config = config;
-        }
-
-        /// <inheritdoc />
-        public string Name => "Refresh Guide";
-
-        /// <inheritdoc />
-        public string Description => "Downloads channel information from live tv services.";
-
-        /// <inheritdoc />
-        public string Category => "Live TV";
-
-        /// <inheritdoc />
-        public bool IsHidden => _liveTvManager.Services.Count == 1 && _config.GetLiveTvConfiguration().TunerHosts.Length == 0;
-
-        /// <inheritdoc />
-        public bool IsEnabled => true;
-
-        /// <inheritdoc />
-        public bool IsLogged => true;
-
-        /// <inheritdoc />
-        public string Key => "RefreshGuide";
-
-        /// <inheritdoc />
-        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
-        {
-            var manager = (LiveTvManager)_liveTvManager;
-
-            return manager.RefreshChannels(progress, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
-        {
-            return new[]
-            {
-                // Every so often
-                new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromHours(24).Ticks }
-            };
-        }
-    }
-}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/ItemDataProvider.cs b/src/Jellyfin.LiveTv/Timers/ItemDataProvider.cs
index 547ffeb66..18e4810a2 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/ItemDataProvider.cs
+++ b/src/Jellyfin.LiveTv/Timers/ItemDataProvider.cs
@@ -9,7 +9,7 @@ using System.Text.Json;
 using Jellyfin.Extensions.Json;
 using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.Timers
 {
     public class ItemDataProvider<T>
         where T : class
diff --git a/src/Jellyfin.LiveTv/Timers/SeriesTimerManager.cs b/src/Jellyfin.LiveTv/Timers/SeriesTimerManager.cs
new file mode 100644
index 000000000..6e8444ba2
--- /dev/null
+++ b/src/Jellyfin.LiveTv/Timers/SeriesTimerManager.cs
@@ -0,0 +1,29 @@
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.LiveTv;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.LiveTv.Timers
+{
+    public class SeriesTimerManager : ItemDataProvider<SeriesTimerInfo>
+    {
+        public SeriesTimerManager(ILogger<SeriesTimerManager> logger, IConfigurationManager config)
+            : base(
+                logger,
+                Path.Combine(config.CommonApplicationPaths.DataPath, "livetv/seriestimers.json"),
+                (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase))
+        {
+        }
+
+        /// <inheritdoc />
+        public override void Add(SeriesTimerInfo item)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(item.Id);
+
+            base.Add(item);
+        }
+    }
+}
diff --git a/src/Jellyfin.LiveTv/EmbyTV/TimerManager.cs b/src/Jellyfin.LiveTv/Timers/TimerManager.cs
index 37b1fa14c..da5deea36 100644
--- a/src/Jellyfin.LiveTv/EmbyTV/TimerManager.cs
+++ b/src/Jellyfin.LiveTv/Timers/TimerManager.cs
@@ -3,21 +3,27 @@
 using System;
 using System.Collections.Concurrent;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using Jellyfin.Data.Events;
+using Jellyfin.LiveTv.Recordings;
+using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Model.LiveTv;
 using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.LiveTv.EmbyTV
+namespace Jellyfin.LiveTv.Timers
 {
     public class TimerManager : ItemDataProvider<TimerInfo>
     {
-        private readonly ConcurrentDictionary<string, Timer> _timers = new ConcurrentDictionary<string, Timer>(StringComparer.OrdinalIgnoreCase);
+        private readonly ConcurrentDictionary<string, Timer> _timers = new(StringComparer.OrdinalIgnoreCase);
 
-        public TimerManager(ILogger logger, string dataPath)
-            : base(logger, dataPath, (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase))
+        public TimerManager(ILogger<TimerManager> logger, IConfigurationManager config)
+            : base(
+                logger,
+                Path.Combine(config.CommonApplicationPaths.DataPath, "livetv"),
+                (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase))
         {
         }
 
@@ -80,27 +86,16 @@ namespace Jellyfin.LiveTv.EmbyTV
             AddOrUpdateSystemTimer(item);
         }
 
-        private static bool ShouldStartTimer(TimerInfo item)
-        {
-            if (item.Status == RecordingStatus.Completed
-                || item.Status == RecordingStatus.Cancelled)
-            {
-                return false;
-            }
-
-            return true;
-        }
-
         private void AddOrUpdateSystemTimer(TimerInfo item)
         {
             StopTimer(item);
 
-            if (!ShouldStartTimer(item))
+            if (item.Status is RecordingStatus.Completed or RecordingStatus.Cancelled)
             {
                 return;
             }
 
-            var startDate = RecordingHelper.GetStartTime(item);
+            var startDate = item.StartDate.AddSeconds(-item.PrePaddingSeconds);
             var now = DateTime.UtcNow;
 
             if (startDate < now)
@@ -169,13 +164,9 @@ namespace Jellyfin.LiveTv.EmbyTV
         }
 
         public TimerInfo? GetTimer(string id)
-        {
-            return GetAll().FirstOrDefault(r => string.Equals(r.Id, id, StringComparison.OrdinalIgnoreCase));
-        }
+            => GetAll().FirstOrDefault(r => string.Equals(r.Id, id, StringComparison.OrdinalIgnoreCase));
 
         public TimerInfo? GetTimerByProgramId(string programId)
-        {
-            return GetAll().FirstOrDefault(r => string.Equals(r.ProgramId, programId, StringComparison.OrdinalIgnoreCase));
-        }
+            => GetAll().FirstOrDefault(r => string.Equals(r.ProgramId, programId, StringComparison.OrdinalIgnoreCase));
     }
 }
diff --git a/src/Jellyfin.LiveTv/TunerHosts/TunerHostManager.cs b/src/Jellyfin.LiveTv/TunerHosts/TunerHostManager.cs
index 3e4b0e13f..60be19c68 100644
--- a/src/Jellyfin.LiveTv/TunerHosts/TunerHostManager.cs
+++ b/src/Jellyfin.LiveTv/TunerHosts/TunerHostManager.cs
@@ -6,6 +6,7 @@ using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.LiveTv.Configuration;
+using Jellyfin.LiveTv.Guide;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller.LiveTv;
diff --git a/src/Jellyfin.Networking/ExternalPortForwarding.cs b/src/Jellyfin.Networking/PortForwardingHost.cs
index df9e43ca9..d01343624 100644
--- a/src/Jellyfin.Networking/ExternalPortForwarding.cs
+++ b/src/Jellyfin.Networking/PortForwardingHost.cs
@@ -1,7 +1,3 @@
-#nullable disable
-
-#pragma warning disable CS1591
-
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -12,36 +8,34 @@ using System.Threading.Tasks;
 using MediaBrowser.Common.Net;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Configuration;
-using MediaBrowser.Controller.Plugins;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Mono.Nat;
 
 namespace Jellyfin.Networking;
 
 /// <summary>
-/// Server entrypoint handling external port forwarding.
+/// <see cref="IHostedService"/> responsible for UPnP port forwarding.
 /// </summary>
-public sealed class ExternalPortForwarding : IServerEntryPoint
+public sealed class PortForwardingHost : IHostedService, IDisposable
 {
     private readonly IServerApplicationHost _appHost;
-    private readonly ILogger<ExternalPortForwarding> _logger;
+    private readonly ILogger<PortForwardingHost> _logger;
     private readonly IServerConfigurationManager _config;
+    private readonly ConcurrentDictionary<IPEndPoint, byte> _createdRules = new();
 
-    private readonly ConcurrentDictionary<IPEndPoint, byte> _createdRules = new ConcurrentDictionary<IPEndPoint, byte>();
-
-    private Timer _timer;
-    private string _configIdentifier;
-
+    private Timer? _timer;
+    private string? _configIdentifier;
     private bool _disposed;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="ExternalPortForwarding"/> class.
+    /// Initializes a new instance of the <see cref="PortForwardingHost"/> class.
     /// </summary>
     /// <param name="logger">The logger.</param>
     /// <param name="appHost">The application host.</param>
     /// <param name="config">The configuration manager.</param>
-    public ExternalPortForwarding(
-        ILogger<ExternalPortForwarding> logger,
+    public PortForwardingHost(
+        ILogger<PortForwardingHost> logger,
         IServerApplicationHost appHost,
         IServerConfigurationManager config)
     {
@@ -66,7 +60,7 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
             .ToString();
     }
 
-    private void OnConfigurationUpdated(object sender, EventArgs e)
+    private void OnConfigurationUpdated(object? sender, EventArgs e)
     {
         var oldConfigIdentifier = _configIdentifier;
         _configIdentifier = GetConfigIdentifier();
@@ -79,7 +73,7 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
     }
 
     /// <inheritdoc />
-    public Task RunAsync()
+    public Task StartAsync(CancellationToken cancellationToken)
     {
         Start();
 
@@ -88,6 +82,14 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
         return Task.CompletedTask;
     }
 
+    /// <inheritdoc />
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        Stop();
+
+        return Task.CompletedTask;
+    }
+
     private void Start()
     {
         var config = _config.GetNetworkConfiguration();
@@ -101,7 +103,8 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
         NatUtility.DeviceFound += OnNatUtilityDeviceFound;
         NatUtility.StartDiscovery();
 
-        _timer = new Timer((_) => _createdRules.Clear(), null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
+        _timer?.Dispose();
+        _timer = new Timer(_ => _createdRules.Clear(), null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
     }
 
     private void Stop()
@@ -112,13 +115,23 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
         NatUtility.DeviceFound -= OnNatUtilityDeviceFound;
 
         _timer?.Dispose();
+        _timer = null;
     }
 
-    private async void OnNatUtilityDeviceFound(object sender, DeviceEventArgs e)
+    private async void OnNatUtilityDeviceFound(object? sender, DeviceEventArgs e)
     {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
         try
         {
-            await CreateRules(e.Device).ConfigureAwait(false);
+            // On some systems the device discovered event seems to fire repeatedly
+            // This check will help ensure we're not trying to port map the same device over and over
+            if (!_createdRules.TryAdd(e.Device.DeviceEndpoint, 0))
+            {
+                return;
+            }
+
+            await Task.WhenAll(CreatePortMaps(e.Device)).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
@@ -126,20 +139,6 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
         }
     }
 
-    private Task CreateRules(INatDevice device)
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-
-        // On some systems the device discovered event seems to fire repeatedly
-        // This check will help ensure we're not trying to port map the same device over and over
-        if (!_createdRules.TryAdd(device.DeviceEndpoint, 0))
-        {
-            return Task.CompletedTask;
-        }
-
-        return Task.WhenAll(CreatePortMaps(device));
-    }
-
     private IEnumerable<Task> CreatePortMaps(INatDevice device)
     {
         var config = _config.GetNetworkConfiguration();
@@ -185,8 +184,6 @@ public sealed class ExternalPortForwarding : IServerEntryPoint
 
         _config.ConfigurationUpdated -= OnConfigurationUpdated;
 
-        Stop();
-
         _timer?.Dispose();
         _timer = null;