jellyfin/Emby.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs

#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 Emby.Server.Implementations.Library;
using Jellyfin.Data.Enums;
using Jellyfin.Data.Events;
using Jellyfin.Extensions;
using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.Progress;
using MediaBrowser.Controller;
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 MediaBrowser.Model.Querying;
using Microsoft.Extensions.Logging;

namespace Emby.Server.Implementations.LiveTv.EmbyTV
{
    public class EmbyTV : ILiveTvService, ISupportsDirectStreamProvider, ISupportsNewTimerIds, IDisposable
    {
        public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";

        private const int TunerDiscoveryDurationMs = 3000;

        private readonly IServerApplicationHost _appHost;
        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 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 = false;

        public EmbyTV(
            IServerApplicationHost appHost,
            IStreamHelper streamHelper,
            IMediaSourceManager mediaSourceManager,
            ILogger<EmbyTV> logger,
            IHttpClientFactory httpClientFactory,
            IServerConfigurationManager config,
            ILiveTvManager liveTvManager,
            IFileSystem fileSystem,
            ILibraryManager libraryManager,
            ILibraryMonitor libraryMonitor,
            IProviderManager providerManager,
            IMediaEncoder mediaEncoder)
        {
            Current = this;

            _appHost = appHost;
            _logger = logger;
            _httpClientFactory = httpClientFactory;
            _config = config;
            _fileSystem = fileSystem;
            _libraryManager = libraryManager;
            _libraryMonitor = libraryMonitor;
            _providerManager = providerManager;
            _mediaEncoder = mediaEncoder;
            _liveTvManager = (LiveTvManager)liveTvManager;
            _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 = GetConfiguration().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 = GetConfiguration();

                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 _liveTvManager.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 _liveTvManager.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 = GetConfiguration();

            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 GetConfiguration().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 _liveTvManager.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 _liveTvManager.TunerHosts)
            {
                try
                {
                    var sources = await hostInstance.GetChannelStreamMediaSources(channelId, cancellationToken).ConfigureAwait(false);

                    if (sources.Count > 0)
                    {
                        return sources;
                    }
                }
                catch (NotImplementedException)
                {
                }
            }

            throw new NotImplementedException();
        }

        public async Task<List<MediaSourceInfo>> GetRecordingStreamMediaSources(ActiveRecordingInfo info, CancellationToken cancellationToken)
        {
            var stream = new MediaSourceInfo
            {
                EncoderPath = _appHost.GetApiUrlForLocalAccess() + "/LiveTv/LiveRecordings/" + info.Id + "/stream",
                EncoderProtocol = MediaProtocol.Http,
                Path = info.Path,
                Protocol = MediaProtocol.File,
                Id = info.Id,
                SupportsDirectPlay = false,
                SupportsDirectStream = true,
                SupportsTranscoding = true,
                IsInfiniteStream = true,
                RequiresOpening = false,
                RequiresClosing = false,
                BufferMs = 0,
                IgnoreDts = true,
                IgnoreIndex = true
            };

            await new LiveStreamHelper(_mediaEncoder, _logger, _config.CommonApplicationPaths)
                .AddMediaInfoWithProbe(stream, false, false, cancellationToken).ConfigureAwait(false);

            return new List<MediaSourceInfo>
            {
                stream
            };
        }

        public Task CloseLiveStream(string id, CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }

        public Task RecordLiveStream(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 = GetConfiguration();
            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;
                }

                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 = GetConfiguration();
            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 = GetConfiguration();

                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;
            }

            await using (var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
            {
                var settings = new XmlWriterSettings
                {
                    Indent = true,
                    Encoding = Encoding.UTF8,
                    Async = true
                };

                await using (var writer = XmlWriter.Create(stream, settings))
                {
                    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;
            }

            await using (var stream = new FileStream(nfoPath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
            {
                var settings = new XmlWriterSettings
                {
                    Indent = true,
                    Encoding = Encoding.UTF8,
                    Async = true
                };

                var options = _config.GetNfoConfiguration();

                var isSeriesEpisode = timer.IsProgramSeries;

                await using (var writer = XmlWriter.Create(stream, settings))
                {
                    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);

                        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.Equals(default) ? 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 LiveTvOptions GetConfiguration()
        {
            return _config.GetConfiguration<LiveTvOptions>("livetv");
        }

        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.Equals(default))
            {
                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.Equals(default))
            {
                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()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return;
            }

            if (disposing)
            {
                _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 = GetConfiguration().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 = GetConfiguration().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
                };
            }
        }

        public async Task<List<TunerHostInfo>> DiscoverTuners(bool newDevicesOnly, CancellationToken cancellationToken)
        {
            var list = new List<TunerHostInfo>();

            var configuredDeviceIds = GetConfiguration().TunerHosts
               .Where(i => !string.IsNullOrWhiteSpace(i.DeviceId))
               .Select(i => i.DeviceId)
               .ToList();

            foreach (var host in _liveTvManager.TunerHosts)
            {
                var discoveredDevices = await DiscoverDevices(host, TunerDiscoveryDurationMs, cancellationToken).ConfigureAwait(false);

                if (newDevicesOnly)
                {
                    discoveredDevices = discoveredDevices.Where(d => !configuredDeviceIds.Contains(d.DeviceId, StringComparison.OrdinalIgnoreCase))
                            .ToList();
                }

                list.AddRange(discoveredDevices);
            }

            return list;
        }

        public async Task ScanForTunerDeviceChanges(CancellationToken cancellationToken)
        {
            foreach (var host in _liveTvManager.TunerHosts)
            {
                await ScanForTunerDeviceChanges(host, cancellationToken).ConfigureAwait(false);
            }
        }

        private async Task ScanForTunerDeviceChanges(ITunerHost host, CancellationToken cancellationToken)
        {
            var discoveredDevices = await DiscoverDevices(host, TunerDiscoveryDurationMs, cancellationToken).ConfigureAwait(false);

            var configuredDevices = GetConfiguration().TunerHosts
                .Where(i => string.Equals(i.Type, host.Type, StringComparison.OrdinalIgnoreCase))
                .ToList();

            foreach (var device in discoveredDevices)
            {
                var configuredDevice = configuredDevices.FirstOrDefault(i => string.Equals(i.DeviceId, device.DeviceId, StringComparison.OrdinalIgnoreCase));

                if (configuredDevice is not null && !string.Equals(device.Url, configuredDevice.Url, StringComparison.OrdinalIgnoreCase))
                {
                    _logger.LogInformation("Tuner url has changed from {PreviousUrl} to {NewUrl}", configuredDevice.Url, device.Url);

                    configuredDevice.Url = device.Url;
                    await _liveTvManager.SaveTunerHost(configuredDevice).ConfigureAwait(false);
                }
            }
        }

        private async Task<List<TunerHostInfo>> DiscoverDevices(ITunerHost host, int discoveryDurationMs, CancellationToken cancellationToken)
        {
            try
            {
                var discoveredDevices = await host.DiscoverDevices(discoveryDurationMs, cancellationToken).ConfigureAwait(false);

                foreach (var device in discoveredDevices)
                {
                    _logger.LogInformation("Discovered tuner device {0} at {1}", host.Name, device.Url);
                }

                return discoveredDevices;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error discovering tuner devices");

                return new List<TunerHostInfo>();
            }
        }
    }
}