Merge branch 'Radarr-Sonarr-Integration' of https://gitea.silverhat.ca/T-Gander/jellyfin-plugin-mediacleaner into Radarr-Sonarr-Integration

Refactor of http client and addition of sonarr anime table
Merge branch 'main' into Radarr-Sonarr-Integration
2026-03-08 19:28:26 -06:00 · 2026-03-08 19:28:04 -06:00 · 2026-03-08 00:08:12 -07:00 · 2026-03-08 00:06:48 -07:00 · 2026-03-07 23:22:06 -07:00 · 2026-03-07 19:21:58 -07:00
26 changed files with 1710 additions and 573 deletions
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,5 +1,5 @@
 <Project>
  <PropertyGroup>
-    <AssemblyVersion>0.0.0.8</AssemblyVersion>
+    <AssemblyVersion>0.0.0.12</AssemblyVersion>
  </PropertyGroup>
 </Project>
--- a/Jellyfin.Plugin.MediaCleaner/Configuration/PluginConfiguration.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Configuration/PluginConfiguration.cs
@@ -3,30 +3,43 @@ using System.Collections.ObjectModel;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Model.Plugins;

-namespace Jellyfin.Plugin.MediaCleaner.Configuration;
+namespace Jellyfin.Plugin.MediaCleaner;

 /// <summary>
 /// Plugin configuration.
 /// </summary>
-public class PluginConfiguration : BasePluginConfiguration
+public class Configuration : BasePluginConfiguration
 {
    /// <summary>
-    /// Initializes a new instance of the <see cref="PluginConfiguration"/> class.
+    /// Gets or sets the http and port address for your Radarr instance.
    /// </summary>
-    public PluginConfiguration()
-    {
-    }
+    public string RadarrAddress { get; set; } = string.Empty;

    /// <summary>
    /// Gets or sets the api for your Radarr instance.
    /// </summary>
    public string RadarrAPIKey { get; set; } = string.Empty;

+    /// <summary>
+    /// Gets or sets the http and port address for your Sonarr instance.
+    /// </summary>
+    public string SonarrAddress { get; set; } = string.Empty;
+
    /// <summary>
    /// Gets or sets the api for your Sonarr instance.
    /// </summary>
    public string SonarrAPIKey { get; set; } = string.Empty;

+    /// <summary>
+    /// Gets or sets the http and port address for your Sonarr instance.
+    /// </summary>
+    public string SonarrAnimeAddress { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the api for your Sonarr instance.
+    /// </summary>
+    public string SonarrAnimeAPIKey { get; set; } = string.Empty;
+
    /// <summary>
    /// Gets or sets the cut off days before deleting unwatched files.
    /// </summary>
--- a/Jellyfin.Plugin.MediaCleaner/Configuration/settings.html
+++ b/Jellyfin.Plugin.MediaCleaner/Configuration/settings.html
@@ -1,108 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <title>Media Cleaner</title>
-</head>
-<body>
-    <div id="MediaCleanerConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
-        <div data-role="content">
-            <div class="content-primary">
-                <form id="MediaCleanerConfigForm">
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="RadarrAPIKey">Radarr API Key</label>
-                        <input id="RadarrAPIKey" name="RadarrAPIKey" type="text" is="emby-input" />
-                        <div class="fieldDescription">The api key used by your radarr instance</div>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="SonarrAPIKey">Sonarr API Key</label>
-                        <input id="SonarrAPIKey" name="SonarrAPIKey" type="text" is="emby-input" />
-                        <div class="fieldDescription">The api key used by your sonarr instance</div>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="StaleMediaCutoff">Stale Media Cutoff</label>
-                        <input id="StaleMediaCutoff" name="StaleMediaCutoff" type="number" is="emby-input" style="width: 20%;"/>
-                        <div class="fieldDescription">How many days to wait before marking files as stale</div>
-                    </div>
-                    <div class="checkboxContainer checkboxContainer-withDescription">
-                        <label class="emby-checkbox-label">
-                            <input id="DebugMode" name="DebugMode" type="checkbox" is="emby-checkbox" />
-                            <span>Debug Mode</span>
-                        </label>
-                    </div>
-                    <!-- <div class="selectContainer">
-                        <label class="selectLabel" for="Options">Several Options</label>
-                        <select is="emby-select" id="Options" name="Options" class="emby-select-withcolor emby-select">
-                            <option id="optOneOption" value="OneOption">One Option</option>
-                            <option id="optAnotherOption" value="AnotherOption">Another Option</option>
-                        </select>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="AnInteger">An Integer</label>
-                        <input id="AnInteger" name="AnInteger" type="number" is="emby-input" min="0" />
-                        <div class="fieldDescription">A Description</div>
-                    </div>
-                    <div class="checkboxContainer checkboxContainer-withDescription">
-                        <label class="emby-checkbox-label">
-                            <input id="TrueFalseSetting" name="TrueFalseCheckBox" type="checkbox" is="emby-checkbox" />
-                            <span>A Checkbox</span>
-                        </label>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="AString">A String</label>
-                        <input id="AString" name="AString" type="text" is="emby-input" />
-                        <div class="fieldDescription">Another Description</div>
-                    </div> -->
-                    <div>
-                        <button is="emby-button" type="submit" class="raised button-submit block emby-button">
-                            <span>Save</span>
-                        </button>
-                    </div>
-                </form>
-            </div>
-        </div>
-        <script type="text/javascript">
-            var MediaCleanerConfig = {
-                pluginUniqueId: 'fef007a8-3e8f-4aa8-a22e-486a387f4192'
-            };
-
-            document.querySelector('#MediaCleanerConfigPage')
-                .addEventListener('pageshow', function() {
-                    Dashboard.showLoadingMsg();
-                    ApiClient.getPluginConfiguration(MediaCleanerConfig.pluginUniqueId).then(function (config) {
-                        // document.querySelector('#Options').value = config.Options;
-                        // document.querySelector('#AnInteger').value = config.AnInteger;
-                        // document.querySelector('#TrueFalseSetting').checked = config.TrueFalseSetting;
-                        // document.querySelector('#AString').value = config.AString;
-                        document.querySelector('#RadarrAPIKey').value = config.RadarrAPIKey;
-                        document.querySelector('#SonarrAPIKey').value = config.SonarrAPIKey;
-                        document.querySelector('#StaleMediaCutoff').value = config.StaleMediaCutoff;
-                        document.querySelector('#DebugMode').checked = config.DebugMode;
-                        Dashboard.hideLoadingMsg();
-                    });
-                });
-
-            document.querySelector('#MediaCleanerConfigForm')
-                .addEventListener('submit', function(e) {
-                Dashboard.showLoadingMsg();
-                ApiClient.getPluginConfiguration(MediaCleanerConfig.pluginUniqueId).then(function (config) {
-                    // config.Options = document.querySelector('#Options').value;
-                    // config.AnInteger = document.querySelector('#AnInteger').value;
-                    // config.TrueFalseSetting = document.querySelector('#TrueFalseSetting').checked;
-                    // config.AString = document.querySelector('#AString').value;
-                    config.RadarrAPIKey = document.querySelector('#RadarrAPIKey').value;
-                    config.SonarrAPIKey = document.querySelector('#SonarrAPIKey').value;
-                    config.StaleMediaCutoff = document.querySelector('#StaleMediaCutoff').value;
-                    config.DebugMode = document.querySelector('#DebugMode').checked;
-                    ApiClient.updatePluginConfiguration(MediaCleanerConfig.pluginUniqueId, config).then(function (result) {
-                        Dashboard.processPluginConfigurationUpdateResult(result);
-                    });
-                });
-
-                e.preventDefault();
-                return false;
-            });
-        </script>
-    </div>
-</body>
-</html>
--- a/Jellyfin.Plugin.MediaCleaner/Controllers/RadarrController.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Controllers/RadarrController.cs
@@ -0,0 +1,111 @@
+using Jellyfin.Plugin.MediaCleaner.Helpers;
+using Jellyfin.Plugin.MediaCleaner.Models;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.MediaCleaner.Enums;
+using Microsoft.AspNetCore.Http;
+using System.Linq;
+
+namespace Jellyfin.Plugin.MediaCleaner.Controllers;
+
+public record ConnectionTestRequest(string Address, string ApiKey);
+
+public record RadarrMovie(
+    [property: JsonPropertyName("id")] int? Id,
+    [property: JsonPropertyName("title")] string? Title
+);
+
+[Route("radarr")]
+public class RadarrController : Controller
+{
+    private async Task<ObjectResult> GetRadarrMovieInfo(MovieInfo movieInfo)
+    {
+        HttpHelper httpHelper = new(ServerType.Radarr);
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Get,
+            $"/api/v3/movie?tmdbId={Uri.EscapeDataString(movieInfo.TmdbId ?? string.Empty)}&excludeLocalCovers=false"
+        ).ConfigureAwait(false);
+
+        var movies = JsonSerializer.Deserialize<List<RadarrMovie>>(responseBody.GetRawText());
+        var movie = movies?.FirstOrDefault();
+
+        if (movie == null)
+        {
+            return NotFound("Movie not found in Radarr library.");
+        }
+
+        return Ok(movie);
+    }
+
+    [HttpPost("deleteMovieFromRadarr")]
+    public async Task<IActionResult> DeleteMovieFromRadarr([FromBody] MovieInfo movieInfo){
+
+        if (movieInfo == null || string.IsNullOrEmpty(movieInfo.TmdbId))
+        {
+            return BadRequest("Invalid movie information provided.");
+        }
+
+        try
+        {
+            var radarrMovieInfoResult = await GetRadarrMovieInfo(movieInfo).ConfigureAwait(false);
+
+            if(radarrMovieInfoResult.StatusCode != StatusCodes.Status200OK || radarrMovieInfoResult.Value is not RadarrMovie){
+                return radarrMovieInfoResult;
+            }
+
+            RadarrMovie movie = (RadarrMovie)radarrMovieInfoResult.Value;
+
+            HttpHelper httpHelper = new(ServerType.Radarr);
+            var responseBody = await httpHelper.SendHttpRequestAsync(
+                HttpMethod.Delete,
+                $"/api/v3/movie/{movie.Id}?deleteFiles=true&addImportExclusion=true"
+            ).ConfigureAwait(false);
+
+            // Radarr typically returns an empty body on successful delete.
+            return Ok(responseBody);
+        }
+        catch (HttpRequestException e)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, $"An unexpected error occurred. {e.Message}");
+        }
+    }
+
+    [HttpPost("testConnection")]
+    public async Task<IActionResult> TestConnection([FromBody] ConnectionTestRequest request)
+    {
+        if (request == null || string.IsNullOrWhiteSpace(request.Address) || string.IsNullOrWhiteSpace(request.ApiKey))
+        {
+            return BadRequest("Address and ApiKey are required.");
+        }
+
+        var address = request.Address.Trim();
+        if (!address.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
+            !address.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+        {
+            address = "http://" + address;
+        }
+
+        try
+        {
+            using var testHttpClient = new HttpClient();
+            using var httpRequest = new HttpRequestMessage(HttpMethod.Get, address);
+            httpRequest.Headers.Add("X-Api-Key", request.ApiKey);
+
+            var response = await testHttpClient.SendAsync(httpRequest).ConfigureAwait(false);
+            return Ok(new { success = response.IsSuccessStatusCode });
+        }
+        catch (HttpRequestException e)
+        {
+            return StatusCode(StatusCodes.Status502BadGateway, e.Message);
+        }
+        catch (Exception e)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+        }
+    }
+}
--- a/Jellyfin.Plugin.MediaCleaner/Controllers/SonarrController.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Controllers/SonarrController.cs
@@ -0,0 +1,267 @@
+using Jellyfin.Plugin.MediaCleaner.Models;
+using Microsoft.AspNetCore.Mvc;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using System.Net.Http.Headers;
+using System;
+using System.Web;
+using System.Text.Json;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+using System.Globalization;
+using Jellyfin.Plugin.MediaCleaner.Enums;
+using Jellyfin.Plugin.MediaCleaner.Helpers;
+
+namespace Jellyfin.Plugin.MediaCleaner.Controllers;
+
+public record SonarrSeries(
+    [property: JsonPropertyName("id")] int? Id,
+    [property: JsonPropertyName("title")] string? Title,
+    [property: JsonPropertyName("seasons")] IReadOnlyList<Season> Seasons
+);
+
+public record EpisodeDeletionDetails(
+    [property: JsonPropertyName("id")] int? EpisodeId,
+    [property: JsonPropertyName("episodeFileId")] int? EpisodeFileId,
+    [property: JsonPropertyName("seasonNumber")] int? SeasonNumber
+);
+
+public record EpisodeIdLists(IReadOnlyList<int> EpisodeIds, IReadOnlyList<int> EpisodeFileIds);
+
+public record Season(
+    [property: JsonPropertyName("seasonNumber")] int? SeasonNumber
+);
+
+[Route("sonarr")]
+public class SonarrController : Controller
+{
+    private readonly HttpClient _httpClient;
+
+    public SonarrController(HttpClient httpClient)
+    {
+        _httpClient = httpClient;
+
+        // Set the default request headers
+        _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+    }
+
+    private async Task<ObjectResult> GetSonarrSeriesInfo(SeriesInfo seriesInfo){
+        HttpHelper httpHelper = new(ServerType.Sonarr);
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Get,
+            $"/api/v3/series?tvdbId={Uri.EscapeDataString(seriesInfo.TvdbId ?? string.Empty)}"
+        ).ConfigureAwait(false);
+
+        var seriesResponseObj = JsonSerializer.Deserialize<List<SonarrSeries>>(responseBody.GetRawText());
+        var series = seriesResponseObj?.FirstOrDefault();
+
+        if (series == null)
+        {
+            return NotFound("Series not found in Sonarr library.");
+        }
+
+        return Ok(series);
+    }
+
+    private async Task<ObjectResult> GetSonarrEpisodeInfo(SonarrSeries sonarrSeries){
+        HttpHelper httpHelper = new(ServerType.Sonarr);
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Get,
+            $"/api/v3/episode?seriesId={sonarrSeries.Id?.ToString(CultureInfo.InvariantCulture)}"
+        ).ConfigureAwait(false);
+
+        var episodesResponseObj = JsonSerializer.Deserialize<List<EpisodeDeletionDetails>>(responseBody.GetRawText());
+
+        if(episodesResponseObj == null){
+            return NotFound("No episodes in response object.");
+        }
+
+        var seasonNumbers = new HashSet<int>(sonarrSeries.Seasons
+            .Where(s => s.SeasonNumber.HasValue)
+            .Select(s => s.SeasonNumber!.Value));
+
+        var staleEpisodesResponseObj = episodesResponseObj
+            .Where(episodeDeletionDetail => episodeDeletionDetail.SeasonNumber != null &&
+                        seasonNumbers.Contains(episodeDeletionDetail.SeasonNumber.Value))
+            .ToList();
+
+        var episodeIds = staleEpisodesResponseObj
+            .Select(episodeDeletionDetail => episodeDeletionDetail.EpisodeId)
+            .Where(id => id.HasValue)
+            .Select(id => id!.Value)
+            .ToList();
+
+        var episodeFileIds = staleEpisodesResponseObj
+            .Select(episodeDeletionDetail => episodeDeletionDetail.EpisodeFileId)
+            .Where(id => id.HasValue)
+            .Select(id => id!.Value)
+            .ToList();
+
+        return Ok(new EpisodeIdLists(episodeIds, episodeFileIds));
+    }
+
+    [HttpPost("deleteSeriesFromSonarr")]
+    public async Task<IActionResult> DeleteSeriesFromSonarr([FromBody] SeriesInfo seriesInfo){
+
+        if (seriesInfo == null || string.IsNullOrEmpty(seriesInfo.TvdbId))
+        {
+            return BadRequest("Invalid series information provided.");
+        }
+
+        try
+        {
+            var sonarrSeriesInfoResult = await GetSonarrSeriesInfo(seriesInfo).ConfigureAwait(false);
+
+            if(sonarrSeriesInfoResult.StatusCode != StatusCodes.Status200OK || sonarrSeriesInfoResult.Value is not SonarrSeries){
+                return sonarrSeriesInfoResult;
+            }
+
+            SonarrSeries retrievedSeries = (SonarrSeries)sonarrSeriesInfoResult.Value;
+            SonarrSeries staleSeries = new(
+                Id: retrievedSeries.Id,
+                Title: retrievedSeries.Title,
+                Seasons: [.. seriesInfo.Seasons.Select(season => new Season(SeasonNumber: int.Parse(season, CultureInfo.InvariantCulture)))]
+            );
+
+            var episodesToPurgeResult = await GetSonarrEpisodeInfo(staleSeries).ConfigureAwait(false);
+            if (episodesToPurgeResult.StatusCode != StatusCodes.Status200OK || episodesToPurgeResult.Value is not EpisodeIdLists)
+            {
+                return sonarrSeriesInfoResult;
+            }
+
+            EpisodeIdLists episodesToPurge = (EpisodeIdLists)episodesToPurgeResult.Value;
+
+            await UnmonitorSeasons(staleSeries).ConfigureAwait(false);
+            await UnmonitorEpisodeIds(episodesToPurge.EpisodeIds).ConfigureAwait(false);
+            await DeleteEpisodeFiles(episodesToPurge.EpisodeFileIds).ConfigureAwait(false);
+
+            return Ok();
+        }
+        catch (HttpRequestException e)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, $"An unexpected error occurred. {e.Message}");
+        }
+    }
+
+    private async Task<ObjectResult> UnmonitorSeasons(SonarrSeries staleSeries){
+        if (staleSeries == null)
+        {
+            return BadRequest("No stale series provided.");
+        }
+
+        HttpHelper httpHelper = new(ServerType.Sonarr);
+        var series = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Get,
+            $"/api/v3/series/{staleSeries.Id}"
+        ).ConfigureAwait(false);
+
+        var seriesDict = JsonSerializer.Deserialize<Dictionary<string, object>>(series.GetRawText());
+        if (seriesDict == null)
+        {
+            throw new InvalidOperationException("Failed to deserialize season.");
+        }
+        var seasons = series.GetProperty("seasons").EnumerateArray().ToList();
+
+        var staleSeasonNumbers = staleSeries.Seasons
+            .Select(s => s.SeasonNumber)
+            .ToHashSet();
+
+        var updatedSeasons = seasons.Select(season =>
+        {
+            var seasonNumber = season.GetProperty("seasonNumber").GetInt32();
+
+            if (staleSeasonNumbers.Contains(seasonNumber))
+            {
+                var seasonDict = JsonSerializer.Deserialize<Dictionary<string, object>>(season.GetRawText());
+                if (seasonDict == null)
+                {
+                    throw new InvalidOperationException("Failed to deserialize season.");
+                }
+                seasonDict["monitored"] = false;
+                return seasonDict;
+            }
+
+            return JsonSerializer.Deserialize<Dictionary<string, object>>(season.GetRawText());
+        }).ToArray();
+
+        seriesDict["seasons"] = updatedSeasons;
+
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Put,
+            $"/api/v3/series/{staleSeries.Id}",
+            seriesDict
+        ).ConfigureAwait(false);
+
+        return Ok(responseBody);
+    }
+
+    private async Task<ObjectResult> DeleteEpisodeFiles(IReadOnlyList<int> episodeFileIds)
+    {
+        if (episodeFileIds == null || episodeFileIds.Count == 0)
+        {
+            return BadRequest("No episode file IDs provided.");
+        }
+
+        HttpHelper httpHelper = new(ServerType.Sonarr);
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Delete,
+            "/api/v3/episodefile/bulk",
+            new { episodeFileIds }
+        ).ConfigureAwait(false);
+
+        return Ok(responseBody);
+    }
+
+    private async Task<ObjectResult> UnmonitorEpisodeIds(IReadOnlyList<int> episodeIds)
+    {
+        if (episodeIds == null || episodeIds.Count == 0)
+        {
+            return BadRequest("No episode IDs provided.");
+        }
+
+
+        HttpHelper httpHelper = new(ServerType.Sonarr);
+        var responseBody = await httpHelper.SendHttpRequestAsync(
+            HttpMethod.Put,
+            "/api/v3/episode/monitor",
+            new { episodeIds, monitored = false }
+        ).ConfigureAwait(false);
+
+        return Ok(responseBody);
+    }
+
+    [HttpPost("testConnection")]
+    public async Task<IActionResult> TestConnection([FromBody] ConnectionTestRequest request)
+    {
+        if (request == null || string.IsNullOrWhiteSpace(request.Address) || string.IsNullOrWhiteSpace(request.ApiKey))
+        {
+            return BadRequest("Address and ApiKey are required.");
+        }
+
+        var address = request.Address.Trim();
+        if (!address.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
+            !address.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+        {
+            address = "http://" + address;
+        }
+
+        try
+        {
+            using var httpRequest = new HttpRequestMessage(HttpMethod.Get, address);
+            httpRequest.Headers.Add("X-Api-Key", request.ApiKey);
+
+            var response = await _httpClient.SendAsync(httpRequest).ConfigureAwait(false);
+            return Ok(new { success = response.IsSuccessStatusCode });
+        }
+        catch (HttpRequestException e)
+        {
+            return StatusCode(StatusCodes.Status502BadGateway, e.Message);
+        }
+        catch (Exception e)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+        }
+    }
+}
--- a/Jellyfin.Plugin.MediaCleaner/Controllers/StateController.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Controllers/StateController.cs
@@ -0,0 +1,35 @@
+using Jellyfin.Plugin.MediaCleaner.Data;
+using Jellyfin.Plugin.MediaCleaner;
+using Jellyfin.Plugin.MediaCleaner.Models;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Jellyfin.Plugin.MediaCleaner.Controllers;
+
+[Route("mediacleaner/state")]
+public class StateController(MediaCleanerState state) : Controller
+{
+    private readonly MediaCleanerState _state = state;
+    private static Configuration Configuration =>
+            Plugin.Instance!.Configuration;
+
+    [HttpGet("getSeriesInfo")]
+    public IActionResult GetSeriesInfo() => Ok(_state.GetSeriesInfo());
+
+    [HttpGet("getMovieInfo")]
+    public IActionResult GetMovieInfo() => Ok(_state.GetMovieInfo());
+
+    [HttpGet("updateState")]
+    public IActionResult GetUpdateState() => Ok(_state.UpdateState());
+
+    [HttpGet("getMoviesTitle")]
+    public IActionResult GetMoviesTitle() =>
+        Ok($"Stale Movies (Unwatched for and created over {Configuration.StaleMediaCutoff} Days ago.)");
+
+    [HttpGet("getSeriesTitle")]
+    public IActionResult GetSeriesTitle() =>
+        Ok($"Stale TV Series (Unwatched for and created over {Configuration.StaleMediaCutoff} Days ago.)");
+
+    [HttpGet("getAnimeSeriesTitle")]
+    public IActionResult GetAnimeSeriesTitle() =>
+        Ok($"Stale Anime Series (Unwatched for and created over {Configuration.StaleMediaCutoff} Days ago.)");
+}
--- a/Jellyfin.Plugin.MediaCleaner/Data/MediaCleanerState.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Data/MediaCleanerState.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations.ModelConfiguration;
+using Jellyfin.Plugin.MediaCleaner;
+using Jellyfin.Plugin.MediaCleaner.Models;
+using Jellyfin.Plugin.MediaCleaner.ScheduledTasks;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.MediaCleaner.Data;
+
+public class MediaCleanerState(ILogger<StaleMediaScanner> logger, ILibraryManager libraryManager)
+{
+    private readonly Lock _lock = new();
+    private IEnumerable<MediaInfo> _mediaInfo = [];
+    private readonly StaleMediaScanner _staleMediaScanner = new(logger, libraryManager);
+
+    public async Task UpdateState()
+    {
+        _mediaInfo = await _staleMediaScanner.ScanStaleMedia().ConfigureAwait(false);
+    }
+
+    public IEnumerable<SeriesInfo> GetSeriesInfo()
+    {
+        lock (_lock)
+        {
+            return _mediaInfo.OfType<SeriesInfo>();
+        }
+    }
+
+     public IEnumerable<MovieInfo> GetMovieInfo()
+    {
+        lock (_lock)
+        {
+            return _mediaInfo.OfType<MovieInfo>();
+        }
+    }
+}
--- a/Jellyfin.Plugin.MediaCleaner/Enums/ServerType.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Enums/ServerType.cs
@@ -0,0 +1,8 @@
+namespace Jellyfin.Plugin.MediaCleaner.Enums;
+
+public enum ServerType
+{
+    Radarr,
+    Sonarr,
+    SonarrAnime
+}
--- a/Jellyfin.Plugin.MediaCleaner/Helpers/HttpHelper.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Helpers/HttpHelper.cs
@@ -0,0 +1,77 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.MediaCleaner.Enums;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.MediaCleaner.Helpers;
+
+public class HttpHelper
+{
+    private string _baseAddress { get; }
+    private HttpClient _httpClient { get; }
+
+    private static Configuration Configuration =>
+            Plugin.Instance!.Configuration;
+
+    public HttpHelper(ServerType serverType)
+    {
+        _httpClient = new HttpClient();
+
+        // Set the default request headers
+        _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+        _httpClient.DefaultRequestHeaders.Add("X-Api-Key", RetrieveApiKey(serverType));
+
+        _baseAddress = RetrieveBaseAddress(serverType);
+    }
+
+    /// <summary>
+    /// Sends a JSON request and returns the raw JSON element response.
+    /// </summary>
+    /// <remarks>
+    /// Do NOT create a new HttpClient on every call; reuse one instance (DI or a singleton) to avoid socket exhaustion.
+    /// </remarks>
+    public async Task<JsonElement> SendHttpRequestAsync(HttpMethod method, string path, object? body = null)
+    {
+        var uri = new UriBuilder($"{_baseAddress}{path}").Uri;
+        using var request = new HttpRequestMessage(method, uri);
+
+        if (body != null)
+        {
+            var json = JsonSerializer.Serialize(body);
+            request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
+        }
+
+        var response = await _httpClient.SendAsync(request).ConfigureAwait(false);
+        response.EnsureSuccessStatusCode();
+
+        var responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        return JsonSerializer.Deserialize<JsonElement>(responseBody);
+    }
+
+    private string RetrieveApiKey(ServerType serverType)
+    {
+        return serverType switch
+        {
+            ServerType.Sonarr => Configuration.SonarrAPIKey,
+            ServerType.SonarrAnime => Configuration.SonarrAnimeAPIKey,
+            ServerType.Radarr => Configuration.RadarrAPIKey,
+            _ => string.Empty,
+        };
+    }
+
+    private string RetrieveBaseAddress(ServerType serverType)
+    {
+        return serverType switch
+        {
+            ServerType.Sonarr => Configuration.SonarrAddress,
+            ServerType.SonarrAnime => Configuration.SonarrAnimeAddress,
+            ServerType.Radarr => Configuration.RadarrAddress,
+            _ => string.Empty,
+        };
+    }
+}
--- a/Jellyfin.Plugin.MediaCleaner/Helpers/LoggingHelper.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Helpers/LoggingHelper.cs
@@ -1,168 +1,28 @@
 using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Runtime.CompilerServices;
-using Jellyfin.Plugin.MediaCleaner.Configuration;
-using Jellyfin.Plugin.MediaCleaner.Models;
-using Jellyfin.Plugin.MediaCleaner.ScheduledTasks;
-using MediaBrowser.Controller.Entities;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Logging;

 namespace Jellyfin.Plugin.MediaCleaner.Helpers;

-public class LoggingHelper
+public class LoggingHelper(ILogger logger)
 {
-    private readonly ILogger _logger;
+    private readonly ILogger _logger = logger ?? throw new ArgumentNullException(nameof(logger));

-    public LoggingHelper(ILogger logger)
+    [SuppressMessage("Microsoft.Performance", "CA2254:TemplateShouldBeConstant", Justification = "Message parameter is intentionally variable for flexible debug logging")]
+    public void LogDebugInformation(string message, params object?[] args)
    {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        if (Configuration.DebugMode)
+        {
+            _logger.LogInformation(message, args);
+        }
    }

-    private static PluginConfiguration Configuration =>
+    [SuppressMessage("Microsoft.Performance", "CA2254:TemplateShouldBeConstant", Justification = "Message parameter is intentionally variable for flexible logging")]
+    public void LogInformation(string message, params object?[] args)
+    {
+        _logger.LogInformation(message, args);
+    }
+
+    private static Configuration Configuration =>
        Plugin.Instance!.Configuration;
-
-    public void StartLogging()
-    {
-        if (Configuration.DebugMode)
-        {
-            _logger.LogInformation("--DEBUG MODE ACTIVE--");
-        }
-
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Starting stale media scan...");
-    }
-
-    public void EndLogging()
-    {
-        _logger.LogInformation("Ending stale media scan...");
-        _logger.LogInformation("-------------------------------------------------");
-    }
-
-    public void EndOfScanningForSeries(BaseItem item)
-    {
-        _logger.LogInformation("End of scanning for series: {Series}", item);
-        _logger.LogInformation("-------------------------------------------------");
-    }
-
-
-    public void StartScanningSeriesItems()
-    {
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Starting scan of series items.");
-        _logger.LogInformation("-------------------------------------------------");
-    }
-
-    public void StartScanningMoviesItems()
-    {
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Starting scan of movies items.");
-        _logger.LogInformation("-------------------------------------------------");
-    }
-
-    public void PrintStaleItemsInformation(IReadOnlyCollection<BaseItem> staleItems)
-    {
-        ArgumentNullException.ThrowIfNull(staleItems);
-
-        _logger.LogInformation("Total stale items: {ItemCount}", staleItems.Count);
-        _logger.LogInformation("Stale items found: {AllItems}", staleItems);
-    }
-
-    public void PrintStaleMoviesInformation(IReadOnlyCollection<BaseItem> staleMovies)
-    {
-        ArgumentNullException.ThrowIfNull(staleMovies);
-
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Stale Movies found: {StaleMovies}", staleMovies.Count);
-
-        if (staleMovies.Count > 0 && Configuration.DebugMode)
-        {
-            foreach (var movieInfo in staleMovies)
-            {
-                _logger.LogInformation("Movie Info: ID: {Id} | Movie Name: {MovieName}", [movieInfo.Id, movieInfo.Name]);
-            }
-        }
-    }
-
-    public void PrintStaleEpisodesInformation(Func<IReadOnlyCollection<BaseItem>, List<SeriesInfo>> findSeriesInfoFromEpisodes, IReadOnlyCollection<BaseItem> staleEpisodes)
-    {
-        ArgumentNullException.ThrowIfNull(staleEpisodes);
-        ArgumentNullException.ThrowIfNull(findSeriesInfoFromEpisodes);
-
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Stale Episodes found: {StaleEpisodes}", staleEpisodes.Count);
-
-        if (staleEpisodes.Count > 0 && Configuration.DebugMode)
-        {
-            if (findSeriesInfoFromEpisodes == null)
-            {
-                throw new ArgumentNullException(nameof(findSeriesInfoFromEpisodes), "The method to find series information cannot be null.");
-            }
-
-            List<SeriesInfo> seriesInfoList = findSeriesInfoFromEpisodes(staleEpisodes);
-
-            foreach (var seriesInfo in seriesInfoList)
-            {
-                _logger.LogInformation("Series Info: ID: {Id} | Series Name: {SeriesName} | Stale Seasons: {Seasons}", [seriesInfo.Id, seriesInfo.SeriesName, string.Join(", ", seriesInfo.Seasons)]);
-            }
-        }
-
-        _logger.LogInformation("-------------------------------------------------");
-    }
-
-    public void PrintDebugDataForSeries(BaseItem item)
-    {
-        ArgumentNullException.ThrowIfNull(item);
-
-        if (Configuration.DebugMode)
-        {
-            _logger.LogInformation("-------------------------------------------------");
-            _logger.LogInformation("Debug data for series: {SeriesName}", item.Name);
-            _logger.LogInformation("-------------------------------------------------");
-        }
-    }
-
-    public void PrintDebugSeasonNumber(int seasonNumber)
-    {
-        if (Configuration.DebugMode)
-        {
-            _logger.LogInformation("Season {SeasonNumber} debug information:", [seasonNumber]);
-        }
-    }
-
-    public void PrintDebugSeasonCreatedOutsideCutoff()
-    {
-        if(Configuration.DebugMode)
-        {
-            _logger.LogInformation("All episodes were created outside of media cutoff, season is possibly stale.");
-        }
-    }
-
-    public void PrintDebugEpisodesWithUserData(IReadOnlyCollection<BaseItem> episodesWithUserData)
-    {
-        if(Configuration.DebugMode){
-            _logger.LogInformation("Episodes with user data: {EpisodesWithUserData}", episodesWithUserData);
-            _logger.LogInformation("-------------------------------------------------");
-        }
-    }
-
-    public void PrintDebugNoUserDataAndOutsideCutoffEpisodeInfo(IReadOnlyCollection<BaseItem> episodes, int seasonNumber)
-    {
-        ArgumentNullException.ThrowIfNull(episodes);
-
-        if(Configuration.DebugMode){
-            _logger.LogInformation("No user data, and creation date is outside of media cutoff, Season {SeasonNumber} is stale.", seasonNumber);
-
-            _logger.LogInformation("-------------------------------------------------");
-            _logger.LogInformation("Episode creation dates:");
-            _logger.LogInformation("-------------------------------------------------");
-            foreach(BaseItem episode in episodes)
-            {
-                _logger.LogInformation("Episode: {EpisodeName} | Date Created: {EpisodeDateCreated}", [episode.Name, episode.DateCreated]);
-            }
-            _logger.LogInformation("-------------------------------------------------");
-        }
-    }
-
-
 }
--- a/Jellyfin.Plugin.MediaCleaner/Helpers/MovieHelper.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Helpers/MovieHelper.cs
@@ -1,30 +1,25 @@
 using System;
 using System.Linq;
-using System.Threading;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Plugin.MediaCleaner.Configuration;
 using MediaBrowser.Controller.Entities;
 using Microsoft.Extensions.Logging;

 namespace Jellyfin.Plugin.MediaCleaner.Helpers;

-public class MovieHelper
+public class MovieHelper(ILogger logger)
 {
-    private readonly ILogger _logger;
+    private readonly LoggingHelper _loggingHelper = new(logger);

-    public MovieHelper(ILogger logger)
-    {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-    }
-
-    private static PluginConfiguration Configuration =>
+    private static Configuration Configuration =>
        Plugin.Instance!.Configuration;

    public bool IsMovieStale(BaseItem movie)
    {
-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("Start of scanning for movie: {Movie}", movie);
-        _logger.LogInformation("-------------------------------------------------");
+        ArgumentNullException.ThrowIfNull(movie, "IsMovieStale process recieved a null movie. Logic failure. Exception thrown.");
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("Scanning movie: {Movie}", movie);
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");

        bool movieIsStale = false;

@@ -33,40 +28,42 @@ public class MovieHelper

        if (hasUserData)
        {
-            var mostRecentUserData = movie.UserData.OrderByDescending(data => data.LastPlayedDate).Where(data => data.LastPlayedDate != null).First();
+            var mostRecentUserData = movie.UserData.OrderByDescending(data => data.LastPlayedDate).First(data => data.LastPlayedDate != null);

-            if (Configuration.DebugMode){
-                _logger.LogInformation("Most recent user data: {Movie}", movie);
+            _loggingHelper.LogDebugInformation("Most recent user data: {Movie}", movie);

            foreach (var property in typeof(UserData).GetProperties())
            {
-                    _logger.LogInformation("{PropertyName}: {PropertyValue}", property.Name, property.GetValue(mostRecentUserData));
-                }
-                _logger.LogInformation("-------------------------------------------------");
+                _loggingHelper.LogDebugInformation("{PropertyName}: {PropertyValue}", property.Name, property.GetValue(mostRecentUserData));
            }

+            _loggingHelper.LogDebugInformation("-------------------------------------------------");
+
            if (mostRecentUserData.LastPlayedDate < DateTime.Now.AddDays(-Configuration.StaleMediaCutoff))
            {
-                if (Configuration.DebugMode)
-                {
-                    _logger.LogInformation("Most recent user data last played date is outside of cutoff. Adding {Movie} to stale movies.", movie);
-                }
+                _loggingHelper.LogDebugInformation("Most recent user data has last played date that is outside of cutoff.");
+                _loggingHelper.LogDebugInformation("Adding {Movie} to stale movies.", movie);
+                _loggingHelper.LogDebugInformation("With Last Played Date: {LastPlayedDate}", mostRecentUserData.LastPlayedDate);
+
                movieIsStale = true;
            }
        }
-        else if (createdOutsideCutoff)
+
+        if (createdOutsideCutoff && !hasUserData)
        {
-            if (Configuration.DebugMode)
-            {
-                _logger.LogInformation("Movie has no user data and was created outside of cutoff: {DateCreated}. Adding {Movie} to stale movies.", [movie.DateCreated, movie]);
-            }
+            _loggingHelper.LogDebugInformation("Movie has no user data and was created outside of cutoff: {DateCreated}.", movie.DateCreated);
+            _loggingHelper.LogDebugInformation("Adding {Movie} to stale movies.", movie);
            movieIsStale = true;
        }

+        if (!createdOutsideCutoff && !hasUserData)
+        {
+            _loggingHelper.LogDebugInformation("Movie has no user data and was not created outside of cutoff: {DateCreated}.", movie.DateCreated);
+            _loggingHelper.LogDebugInformation("Movie is not stale.");
+        }

-        _logger.LogInformation("-------------------------------------------------");
-        _logger.LogInformation("End of scanning for movie: {Movie}", movie);
-        _logger.LogInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("End of scanning for movie: {Movie}", movie);

        return movieIsStale;
    }
--- a/Jellyfin.Plugin.MediaCleaner/Helpers/SeriesHelper.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Helpers/SeriesHelper.cs
@@ -1,61 +1,86 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Entities.Libraries;
-using Jellyfin.Plugin.MediaCleaner.Configuration;
 using MediaBrowser.Controller.Entities;
 using Microsoft.Extensions.Logging;


 namespace Jellyfin.Plugin.MediaCleaner.Helpers;

-public class SeriesHelper
+public class SeriesHelper(ILogger logger)
 {
-    private readonly ILogger _logger;
-    private readonly LoggingHelper _loggingHelper;
+    private readonly LoggingHelper _loggingHelper = new(logger);

-    public SeriesHelper(ILogger logger)
-    {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        _loggingHelper = new LoggingHelper(logger);
-    }
-
-    private static PluginConfiguration Configuration =>
+    private static Configuration Configuration =>
        Plugin.Instance!.Configuration;

-    public bool IsSeasonUserDataStale(IReadOnlyList<BaseItem> episodes, int seasonNumber)
+    private List<BaseItem> ProcessEpisodes(IReadOnlyCollection<BaseItem> episodes)
    {
-        bool seasonIsStale = false;
-
-        var episodesWithUserData = episodes.Where(episode => episode.UserData.Where(data => data.LastPlayedDate != null).ToList().Count > 0).ToList();
-
-        _loggingHelper.PrintDebugEpisodesWithUserData(episodesWithUserData);
-
-        foreach (var episode in episodesWithUserData)
+        List<BaseItem> staleEpisodes = [.. episodes
+        .Where(episode =>
        {
-            var mostRecentUserData = episode.UserData.OrderByDescending(data => data.LastPlayedDate).Where(data => data.LastPlayedDate != null).First();
-            if(Configuration.DebugMode){
-                _logger.LogInformation("User data for episode: {Episode}", episode);
-                _logger.LogInformation("-------------------------------------------------");
+            bool episodeIsStale = false;
+
+            var staleCreationDate = episode.DateCreated < DateTime.Now.AddDays(-Configuration.StaleMediaCutoff);
+            var hasUserDataWithLastPlayedDate = episode.UserData.Any(data => data.LastPlayedDate != null);
+
+            _loggingHelper.LogDebugInformation("-------------------------------------------------");
+            _loggingHelper.LogDebugInformation("Debug data for episode: {Episode}", episode);
+            _loggingHelper.LogDebugInformation("-------------------------------------------------");
+
+            if (staleCreationDate && !hasUserDataWithLastPlayedDate){
+                _loggingHelper.LogDebugInformation("Creation date is stale, and no user data for episode {Episode}.", episode);
+                _loggingHelper.LogDebugInformation("Date created: {DateCreated}", episode.DateCreated);
+                episodeIsStale = true;
+            }
+
+            if (hasUserDataWithLastPlayedDate){
+                UserData mostRecentUserData = episode.UserData
+                .OrderByDescending(data => data.LastPlayedDate)
+                .First();
+
                foreach (var property in typeof(UserData).GetProperties())
                {
-                    _logger.LogInformation("{PropertyName}: {PropertyValue}", property.Name, property.GetValue(mostRecentUserData));
-                }
-                _logger.LogInformation("-------------------------------------------------");
-            }
-            if (mostRecentUserData.LastPlayedDate < DateTime.Now.AddDays(-Configuration.StaleMediaCutoff))
-            {
-                if(Configuration.DebugMode){
-                    _logger.LogInformation("Most recent user data has a last played date of: {LastPlayedDate}. Therefore all episodes are stale. Adding Season {SeasonNumber} to stale list.", [mostRecentUserData.LastPlayedDate, seasonNumber]);
-                    _logger.LogInformation("-------------------------------------------------");
+                    _loggingHelper.LogDebugInformation("{PropertyName}: {PropertyValue}", property.Name, property.GetValue(mostRecentUserData));
                }

-                seasonIsStale = true;
+                _loggingHelper.LogDebugInformation("-------------------------------------------------");
+
+                bool staleLastPlayedDate = mostRecentUserData.LastPlayedDate < DateTime.Now.AddDays(-Configuration.StaleMediaCutoff);
+
+                if (staleLastPlayedDate && staleCreationDate)
+                {
+                    episodeIsStale = true;
+                    _loggingHelper.LogDebugInformation("Most recent user data has a last played date of: {LastPlayedDate}.", [mostRecentUserData.LastPlayedDate]);
+                    _loggingHelper.LogDebugInformation("Episode created {DateCreated}.", episode.DateCreated);
+                    _loggingHelper.LogDebugInformation("Episode is marked as stale.");
                }
            }

+            return episodeIsStale;
+        })];
+
+        return staleEpisodes;
+    }
+
+    public bool IsSeasonDataStale(IReadOnlyList<BaseItem> episodes)
+    {
+        ArgumentNullException.ThrowIfNull(episodes, "IsSeasonDataStale process recieved null episodes. Logic failure. Exception thrown.");
+
+        bool seasonIsStale = false;
+
+        List<BaseItem> staleEpisodes = ProcessEpisodes(episodes);
+
+        if(staleEpisodes.Count == episodes.Count)
+        {
+            seasonIsStale = true;
+
+            _loggingHelper.LogDebugInformation("-------------------------------------------------");
+            _loggingHelper.LogDebugInformation("Stale episodes count matches season episode count. Season is stale.");
+            _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        }
+
        return seasonIsStale;
    }
 }
--- a/Jellyfin.Plugin.MediaCleaner/Jellyfin.Plugin.MediaCleaner.csproj
+++ b/Jellyfin.Plugin.MediaCleaner/Jellyfin.Plugin.MediaCleaner.csproj
@@ -20,10 +20,8 @@
  </ItemGroup>

  <ItemGroup>
-    <None Remove="Configuration\settings.html" />
-    <EmbeddedResource Include="Configuration\settings.html" />
-    <None Remove="Pages\home.html" />
-    <EmbeddedResource Include="Pages\home.html" />
+    <None Remove="Pages\*" />
+    <EmbeddedResource Include="Pages\*" />
  </ItemGroup>

  <PropertyGroup>
--- a/Jellyfin.Plugin.MediaCleaner/Models/MediaInfo.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Models/MediaInfo.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Jellyfin.Plugin.MediaCleaner.Models;
+
+public abstract class MediaInfo
+{
+    public required string? TmdbId { get; set; }
+    public required string Name { get; set; }
+}
--- a/Jellyfin.Plugin.MediaCleaner/Models/MovieInfo.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Models/MovieInfo.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Jellyfin.Plugin.MediaCleaner;
+
+namespace Jellyfin.Plugin.MediaCleaner.Models;
+
+/// <summary>
+/// Contains Movie information.
+/// </summary>
+public class MovieInfo : MediaInfo
+{
+
+}
--- a/Jellyfin.Plugin.MediaCleaner/Models/SeriesInfo.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Models/SeriesInfo.cs
@@ -1,30 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using Jellyfin.Plugin.MediaCleaner;

 namespace Jellyfin.Plugin.MediaCleaner.Models;

 /// <summary>
 /// Contains series information.
 /// </summary>
-public class SeriesInfo
+public class SeriesInfo : MediaInfo
 {
-    /// <summary>
-    /// Gets or sets series identifier.
-    /// </summary>
-    public Guid Id { get; set; }
-
-    /// <summary>
-    /// Gets or sets series name.
-    /// </summary>
-    public string SeriesName { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Gets or sets seasons.
-    /// </summary>
-#pragma warning disable CA2227 // Collection properties should be read only
-#pragma warning disable CA1002 // Do not expose generic lists
-    public List<string> Seasons { get; set; } = [];
-#pragma warning restore CA1002 // Do not expose generic lists
-#pragma warning restore CA2227 // Collection properties should be read only
+    public Guid SeriesId { get; set; }
+    public IEnumerable<string> Seasons { get; set; } = [];
+    public required string? TvdbId { get; set; }
 }
--- a/Jellyfin.Plugin.MediaCleaner/Pages/configuration.html
+++ b/Jellyfin.Plugin.MediaCleaner/Pages/configuration.html
@@ -0,0 +1,94 @@
+<div id="MediaCleanerConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox" data-controller="__plugin/configuration.js">
+    <div data-role="content">
+        <div class="content-primary">
+            <link rel="stylesheet" href="/web/configurationpage?name=global.css" />
+            <form id="MediaCleanerConfigForm">
+                <h2>Media Cleaner Configuration</h2>
+
+                <h3>Management Configuration</h3>
+
+                <div class="inlineContainer">
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="RadarrAddress">Radarr Address (http:port)</label>
+                        <input id="RadarrAddress" name="RadarrAddress" type="text" is="emby-input" />
+                        <div class="fieldDescription">The address and port of your radarr instance.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="RadarrAPIKey">Radarr API Key</label>
+                        <input id="RadarrAPIKey" name="RadarrAPIKey" type="text" is="emby-input" />
+                        <div class="fieldDescription">The api key used by your radarr instance</div>
+                    </div>
+                    <div class="inputContainer">
+                        <button id="RadarrTestConnectionButton" is="emby-button" type="button" class="raised button-submit block emby-button">
+                            <span>Test</span>
+                        </button>
+                        <div class="validation" id="RadarrConnectionValidation" hidden>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="inlineContainer">
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="SonarrAddress">Sonarr Address (http:port)</label>
+                        <input id="SonarrAddress" name="SonarrAddress" type="text" is="emby-input" />
+                        <div class="fieldDescription">The address and port of your sonarr instance.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="SonarrAPIKey">Sonarr API Key</label>
+                        <input id="SonarrAPIKey" name="SonarrAPIKey" type="text" is="emby-input" />
+                        <div class="fieldDescription">The api key used by your sonarr instance</div>
+                    </div>
+                    <div class="inputContainer">
+                        <button id="SonarrTestConnectionButton" is="emby-button" type="button" class="raised button-submit block emby-button">
+                            <span>Test</span>
+                        </button>
+                        <div class="validation" id="SonarrConnectionValidation" hidden>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="inlineContainer">
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="SonarrAnimeAddress">Sonarr Anime Address (http:port)</label>
+                        <input id="SonarrAnimeAddress" name="SonarrAnimeAddress" type="text" is="emby-input" />
+                        <div class="fieldDescription">The address and port of your sonarr instance.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="SonarrAnimeAPIKey">Sonarr Anime API Key</label>
+                        <input id="SonarrAnimeAPIKey" name="SonarrAnimeAPIKey" type="text" is="emby-input" />
+                        <div class="fieldDescription">The api key used by your sonarr instance</div>
+                    </div>
+                    <div class="inputContainer">
+                        <button id="SonarrAnimeTestConnectionButton" is="emby-button" type="button" class="raised button-submit block emby-button">
+                            <span>Test</span>
+                        </button>
+                        <div class="validation" id="SonarrAnimeConnectionValidation" hidden>
+                        </div>
+                    </div>
+                </div>
+
+                <h3>General Settings</h3>
+                <div class="inlineContainer">
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="StaleMediaCutoff">Stale Media Cutoff</label>
+                        <input id="StaleMediaCutoff" class="medium-width" name="StaleMediaCutoff" type="number" is="emby-input"/>
+                        <div class="fieldDescription">How many days to wait before marking files as stale</div>
+                    </div>
+
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="DebugMode" name="DebugMode" type="checkbox" is="emby-checkbox" />
+                            <span>Debug Mode</span>
+                        </label>
+                    </div>
+                </div>
+
+                <div>
+                    <button is="emby-button" type="submit" class="raised button-submit block emby-button">
+                        <span>Save</span>
+                    </button>
+                </div>
+            </form>
+        </div>
+    </div>
+</div>
--- a/Jellyfin.Plugin.MediaCleaner/Pages/configuration.js
+++ b/Jellyfin.Plugin.MediaCleaner/Pages/configuration.js
@@ -0,0 +1,180 @@
+// Variables
+var MediaCleanerConfig = {
+    pluginUniqueId: 'fef007a8-3e8f-4aa8-a22e-486a387f4192'
+};
+
+// Fades
+const startFadeOut = (element, interval = 100) => {
+  const timer = setInterval(() => {
+    let currentOpacity = parseFloat(getComputedStyle(element).opacity);
+    if (isNaN(currentOpacity)) currentOpacity = 1;
+    if (currentOpacity > 0) {
+      currentOpacity = Math.max(0, currentOpacity - 0.05);
+      element.style.opacity = currentOpacity.toString();
+    } else {
+      clearInterval(timer);
+      element.setAttribute('hidden', '');
+    }
+  }, interval);
+};
+
+const startFadeIn = (element, interval = 100) => {
+  const timer = setInterval(() => {
+    let currentOpacity = parseFloat(getComputedStyle(element).opacity);
+    if (isNaN(currentOpacity)) currentOpacity = 0;
+    if (currentOpacity < 1) {
+      currentOpacity = Math.max(0, currentOpacity + 0.05);
+      element.style.opacity = currentOpacity.toString();
+    } else {
+      clearInterval(timer);
+    }
+  }, interval);
+};
+
+// Connection Methods
+const testConnectionSonarrAnime = async () => {
+    var apiKeyElement = document.getElementById('SonarrAnimeAPIKey');
+    var addressElement = document.getElementById('SonarrAnimeAddress');
+    var validationElement = document.getElementById('SonarrAnimeConnectionValidation');
+
+    await validateConnection(apiKeyElement, addressElement, validationElement, "sonarr");
+}
+
+const testConnectionSonarr = async () => {
+    var apiKeyElement = document.getElementById('SonarrAPIKey');
+    var addressElement = document.getElementById('SonarrAddress');
+    var validationElement = document.getElementById('SonarrConnectionValidation');
+
+    await validateConnection(apiKeyElement, addressElement, validationElement, "sonarr");
+}
+
+const testConnectionRadarr = async () => {
+    var apiKeyElement = document.getElementById('RadarrAPIKey');
+    var addressElement = document.getElementById('RadarrAddress');
+    var validationElement = document.getElementById('RadarrConnectionValidation');
+
+    await validateConnection(apiKeyElement, addressElement, validationElement, "radarr");
+}
+
+// Validation and Normalization
+const normalizeUrl = (url) => {
+    let normalizedUrl = url.trim();
+    if (!/^https?:\/\//i.test(normalizedUrl)) {
+        normalizedUrl = 'http://' + normalizedUrl;
+    }
+    return normalizedUrl;
+};
+
+const validateConnection = async (apiKeyElement, addressElement, validationElement, controller) => {
+    var httpAddress = addressElement.value;
+    var apiKey = apiKeyElement.value;
+
+    console.log("Address: ", httpAddress);
+    console.log("Api Key: ", apiKey);
+
+    // Only valid with characters
+    const validHttp = httpAddress.trim().length > 0;
+    const validApiKey = apiKey.trim().length > 0;
+
+    console.log("Valid Http: ", validHttp);
+    console.log("Valid Api: ", validApiKey);
+
+    var success = false;
+
+    if(validHttp && validApiKey){
+        setAttemptingConnection(validationElement);
+        try{
+            const url = normalizeUrl(httpAddress);
+            // Move endpoint to a constant?
+            const response = await fetch(`/${controller}/testConnection`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({ address: url, apiKey })
+            });
+
+            if (response.ok) {
+                const result = await response.json();
+                success = result?.success === true;
+            }
+        }
+        catch (error){
+            console.error(`Error: ${error}`);
+        }
+    }
+
+    processValidationElement(validationElement, success);
+}
+
+const setAttemptingConnection = (validationElement) => {
+    validationElement.removeAttribute('hidden');
+    validationElement.style.opacity = '0';
+
+    validationElement.style.color = 'Yellow';
+    validationElement.innerText = "Attempting Connection..."
+    setTimeout(startFadeIn(validationElement, 50));
+}
+
+const processValidationElement = (validationElement, success) => {
+    validationElement.removeAttribute('hidden');
+    validationElement.style.opacity = '1';
+
+    if(success){
+        validationElement.style.color = 'Green';
+        validationElement.innerText = "Successful Connection!"
+    }
+    else {
+        validationElement.style.color = 'Red';
+        validationElement.innerText = "Failed Connection!"
+    }
+
+    setTimeout(() => startFadeOut(validationElement, 50), 2000);
+}
+
+// Handlers
+document.querySelector('#RadarrTestConnectionButton')
+    .addEventListener('click', testConnectionRadarr);
+
+document.querySelector('#SonarrTestConnectionButton')
+    .addEventListener('click', testConnectionSonarr);
+
+document.querySelector('#SonarrAnimeTestConnectionButton')
+    .addEventListener('click', testConnectionSonarrAnime);
+
+document.querySelector('#MediaCleanerConfigPage')
+    .addEventListener('pageshow', function() {
+        Dashboard.showLoadingMsg();
+        ApiClient.getPluginConfiguration(MediaCleanerConfig.pluginUniqueId).then(function (config) {
+            document.querySelector('#RadarrAPIKey').value = config.RadarrAPIKey;
+            document.querySelector('#RadarrAddress').value = config.RadarrAddress;
+            document.querySelector('#SonarrAPIKey').value = config.SonarrAPIKey;
+            document.querySelector('#SonarrAddress').value = config.SonarrAddress;
+            document.querySelector('#SonarrAnimeAPIKey').value = config.SonarrAnimeAPIKey;
+            document.querySelector('#SonarrAnimeAddress').value = config.SonarrAnimeAddress;
+            document.querySelector('#StaleMediaCutoff').value = config.StaleMediaCutoff;
+            document.querySelector('#DebugMode').checked = config.DebugMode;
+            Dashboard.hideLoadingMsg();
+        });
+    });
+
+document.querySelector('#MediaCleanerConfigForm')
+    .addEventListener('submit', function(e) {
+    Dashboard.showLoadingMsg();
+    ApiClient.getPluginConfiguration(MediaCleanerConfig.pluginUniqueId).then(function (config) {
+        config.RadarrAPIKey = document.querySelector('#RadarrAPIKey').value;
+        config.RadarrAddress = document.querySelector('#RadarrAddress').value;
+        config.SonarrAPIKey = document.querySelector('#SonarrAPIKey').value;
+        config.SonarrAddress = document.querySelector('#SonarrAddress').value;
+        config.SonarrAnimeAPIKey = document.querySelector('#SonarrAnimeAPIKey').value;
+        config.SonarrAnimeAddress = document.querySelector('#SonarrAnimeAddress').value;
+        config.StaleMediaCutoff = document.querySelector('#StaleMediaCutoff').value;
+        config.DebugMode = document.querySelector('#DebugMode').checked;
+        ApiClient.updatePluginConfiguration(MediaCleanerConfig.pluginUniqueId, config).then(function (result) {
+            Dashboard.processPluginConfigurationUpdateResult(result);
+        });
+    });
+
+    e.preventDefault();
+    return false;
+});
--- a/Jellyfin.Plugin.MediaCleaner/Pages/global.css
+++ b/Jellyfin.Plugin.MediaCleaner/Pages/global.css
@@ -0,0 +1,91 @@
+.content-primary > * {
+    box-sizing: border-box;
+}
+
+.inlineContainer {
+    display: inline-flex;
+    flex-direction: column;
+    /* Would be nice to figure out why 50% doesn't work. */
+    width: 49%;
+}
+
+.inlineContainer > * {
+    padding: 0 0.5rem;
+}
+
+table {
+    border: 1px solid;
+    border-collapse: collapse;
+}
+
+td, th {
+    border: 1px solid;
+    padding: 0.5rem 0.75rem;
+    text-align: left;
+}
+
+.table-text {
+    font-size: large;
+    text-align: center;
+}
+
+/* Custom emby checkbox for table */
+.table-checkbox {
+    padding-left: 1.05rem;
+}
+
+.table-checkbox .checkboxContainer .emby-checkbox-label .checkboxOutline {
+    height: 1.5em;
+    width: 1.5em;
+}
+
+.table-checkbox .checkboxContainer .emby-checkbox-label {
+    height: 1.8em
+}
+
+.links {
+    background-color: #0f0f0f;
+    border: 1px solid #00a4dc;
+    border-radius: 0.25rem;
+    padding: 0.8rem 1.8rem;
+    font-size: 1.2rem;
+    color: #ffffff;
+    text-decoration: none;
+    cursor: pointer;
+    line-height: inherit;
+    vertical-align: baseline;
+    transition: background-color 0.3s ease;
+}
+
+.links:hover {
+    background-color: #2a2a2a;
+}
+
+.actions-cell {
+    text-align: center;
+}
+
+.validation {
+    border: 1px solid;
+    border-radius: 0.25rem;
+    margin-top: 1rem;
+    margin-bottom: 0;
+    padding: 1rem;
+    opacity: 1;
+}
+
+.max-width{
+    width: 100%;
+}
+
+.medium-width {
+    width: 50%;
+}
+
+.small-width {
+    width: 20%;
+}
+
+.xsmall-width {
+    width: 10%;
+}
--- a/Jellyfin.Plugin.MediaCleaner/Pages/home.html
+++ b/Jellyfin.Plugin.MediaCleaner/Pages/home.html
@@ -1,11 +1,52 @@
-<div data-role="page" class="page type-interior pluginConfigurationPage withTabs">
+<div data-role="page" class="page type-interior pluginConfigurationPage"
+     data-controller="__plugin/home.js">
 	<div data-role="content">
 		<div class="content-primary">
-            <div>
-                <a href="#configurationpage?name=Home">Home</a>
-                <a href="#configurationpage?name=Settings">Settings</a>
-            </div>
+            <link rel="stylesheet" href="/web/configurationpage?name=global.css" />
+            <div id="loading">Loading...</div>
+            <div id="homepage" style="visibility: hidden;">
+                <button class="links" data-target="configurationpage?name=Configuration">Configuration</button>
                <h2>Media Cleaner</h2>
+
+                <h3 id="moviesTitle"></h3>
+                <table id="moviesTable">
+                    <thead>
+                        <tr>
+                            <th>Name</th>
+                            <th></th>
+                        </tr>
+                    </thead>
+                    <tbody></tbody>
+                </table>
+                <button id="moviesDeleteButton" class="delete-button raised button-submit emby-button" style="visibility: hidden;">Delete</button>
+                <br>
+
+                <h3 id="seriesTitle"></h3>
+                <table id="seriesTable">
+                    <thead>
+                        <tr>
+                            <th>Name</th>
+                            <th>Seasons</th>
+                            <th></th>
+                        </tr>
+                    </thead>
+                    <tbody></tbody>
+                </table>
+                <button id="seriesDeleteButton" class="delete-button raised button-submit emby-button" style="visibility: hidden;">Delete</button>
+                <br>
+                <h3 id="animeSeriesTitle"></h3>
+                <table id="animeSeriesTable">
+                    <thead>
+                        <tr>
+                            <th>Name</th>
+                            <th>Seasons</th>
+                            <th></th>
+                        </tr>
+                    </thead>
+                    <tbody></tbody>
+                </table>
+                <button id="animeSeriesDeleteButton" class="delete-button raised button-submit emby-button" style="visibility: hidden;">Delete</button>
+            </div>
 		</div>
 	</div>
 </div>
--- a/Jellyfin.Plugin.MediaCleaner/Pages/home.js
+++ b/Jellyfin.Plugin.MediaCleaner/Pages/home.js
@@ -0,0 +1,317 @@
+document.addEventListener('pageshow', async () => {
+    await refreshFrontEnd();
+});
+
+const refreshFrontEnd = async () => {
+    startLoading();
+    await updateMediaCleanerState();
+
+    var moviesTitle = document.getElementById("moviesTitle");
+    var seriesTitle = document.getElementById("seriesTitle");
+    var animeSeriesTitle = document.getElementById("animeSeriesTitle");
+
+    moviesTitle.innerHTML = await getMediaCleanerMoviesTitle();
+    seriesTitle.innerHTML = await getMediaCleanerSeriesTitle();
+    animeSeriesTitle.innerHTML = await getMediaCleanerAnimeSeriesTitle();
+
+    await populateTables();
+    addClickHandlersToLinks();
+    addClickHandlersToDeleteButtons();
+    finishLoading();
+}
+
+const getMediaCleanerSeriesInfo = async () => {
+    const response = await fetch("/mediacleaner/state/getSeriesInfo");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+
+    return response.json();
+};
+
+const getMediaCleanerMovieInfo = async () => {
+    const response = await fetch("/mediacleaner/state/getMovieInfo");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+
+    return response.json();
+};
+
+const updateMediaCleanerState = async () => {
+    const response = await fetch("/mediacleaner/state/updateState");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+
+    return response.json();
+};
+
+const getMediaCleanerAnimeSeriesTitle = async () => {
+    const response = await fetch("/mediacleaner/state/getAnimeSeriesTitle");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`);
+    }
+
+    return response.json();
+};
+
+const getMediaCleanerSeriesTitle = async () => {
+    const response = await fetch("/mediacleaner/state/getSeriesTitle");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`);
+    }
+
+    return response.json();
+};
+
+const getMediaCleanerMoviesTitle = async () => {
+    const response = await fetch("/mediacleaner/state/getMoviesTitle");
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`);
+    }
+
+    return response.json();
+};
+
+
+const populateTables = async () => {
+    var moviesInfo = await getMediaCleanerMovieInfo();
+    var seriesInfo = await getMediaCleanerSeriesInfo();
+    var animeSeriesInfo = await getMediaCleanerAnimeSeriesInfo();
+
+    var seriesTable = document.getElementById("seriesTable");
+    var moviesTable = document.getElementById("moviesTable");
+    var animeSeriesTable = document.getElementById("animeSeriesTable");
+
+    var seriesTableBody = seriesTable.getElementsByTagName('tbody')[0];
+    seriesTableBody.replaceChildren();
+    var seriesDeleteButton = document.getElementById('seriesDeleteButton');
+
+    var moviesTableBody = moviesTable.getElementsByTagName('tbody')[0];
+    moviesTableBody.replaceChildren();
+    var moviesDeleteButton = document.getElementById('moviesDeleteButton');
+
+    var animeSeriesTableBody = animeSeriesTable.getElementsByTagName('tbody')[0];
+    animeSeriesTableBody.replaceChildren();
+    var animeSeriesDeleteButton = document.getElementById('animeSeriesDeleteButton');
+
+    if (moviesInfo.length > 0){
+        for(let i = 0; i < moviesInfo.length; i++){
+            var row = moviesTableBody.insertRow(-1);
+            var cell1 = row.insertCell(0);
+            var cell2 = row.insertCell(1);
+            cell1.innerHTML = moviesInfo[i].Name;
+            cell1.className = "table-text";
+            cell2.appendChild(createCheckbox(moviesInfo[i], moviesTable, moviesDeleteButton));
+            cell2.className = "table-checkbox"
+        }
+    }
+    else{
+        var columnCount = moviesTable.tHead.rows[0].cells.length;
+        var row = moviesTableBody.insertRow(-1);
+        var cell1 = row.insertCell(0);
+        cell1.colSpan = columnCount;
+        cell1.innerHTML = "No stale movies found.";
+        cell1.className = "table-text";
+    }
+
+    if(seriesInfo.length > 0){
+        for(let i = 0; i < seriesInfo.length; i++){
+            var row = seriesTableBody.insertRow(-1);
+            var cell1 = row.insertCell(0);
+            var cell2 = row.insertCell(1);
+            var cell3 = row.insertCell(2);
+            cell1.innerHTML = seriesInfo[i].Name;
+            cell1.className = "table-text";
+            cell2.innerHTML = seriesInfo[i].Seasons.map(season => season).join(", ");
+            cell2.className = "table-text";
+            cell3.appendChild(createCheckbox(seriesInfo[i], seriesTable, seriesDeleteButton));
+            cell3.className = "table-checkbox"
+        }
+    }
+    else{
+        var columnCount = seriesTable.tHead.rows[0].cells.length;
+        var row = seriesTableBody.insertRow(-1);
+        var cell1 = row.insertCell(0);
+        cell1.colSpan = columnCount;
+        cell1.innerHTML = "No stale tv series found.";
+        cell1.className = "table-text";
+    }
+
+    if(animeSeriesInfo.length > 0){
+        for(let i = 0; i < animeSeriesInfo.length; i++){
+            var row = animeSeriesTableBody.insertRow(-1);
+            var cell1 = row.insertCell(0);
+            var cell2 = row.insertCell(1);
+            var cell3 = row.insertCell(2);
+            cell1.innerHTML = animeSeriesInfo[i].Name;
+            cell1.className = "table-text";
+            cell2.innerHTML = animeSeriesInfo[i].Seasons.map(season => season).join(", ");
+            cell2.className = "table-text";
+            cell3.appendChild(createCheckbox(animeSeriesInfo[i], animeSeriesTable, animeSeriesDeleteButton));
+            cell3.className = "table-checkbox"
+        }
+    }
+    else{
+        var columnCount = animeSeriesTableBody.tHead.rows[0].cells.length;
+        var row = animeSeriesTableBody.insertRow(-1);
+        var cell1 = row.insertCell(0);
+        cell1.colSpan = columnCount;
+        cell1.innerHTML = "No stale anime series found.";
+        cell1.className = "table-text";
+    }
+};
+
+const createCheckbox = (mediaInfo = {}, table, deleteButton) => {
+    const container = document.createElement('div');
+    container.className = 'checkboxContainer';
+    container.style.marginBottom = 0;
+
+    const label = document.createElement('label');
+    label.className = 'emby-checkbox-label';
+    label.style.textAlign = 'center';
+    label.style.paddingLeft = '1.8em';
+
+    const checkbox = document.createElement('input');
+    checkbox.type = 'checkbox';
+    checkbox.setAttribute('is', 'emby-checkbox');
+    checkbox.dataset.mediaInfo = JSON.stringify(mediaInfo) || '';
+
+    const span = document.createElement('span');
+    span.textContent = '';
+
+    label.appendChild(checkbox);
+    label.appendChild(span);
+    container.appendChild(label);
+
+    checkbox.addEventListener('change', (e) => {
+        if(isDeleteButtonVisible(table)){
+            deleteButton.style.visibility = 'visible';
+        }
+        else {
+            deleteButton.style.visibility = 'hidden';
+        }
+    });
+
+    return container;
+};
+
+const isDeleteButtonVisible = (table) => {
+    const checkboxes = table.getElementsByClassName('emby-checkbox');
+    const hasChecked = Array.from(checkboxes).some(checkbox => checkbox.checked);
+    return hasChecked;
+}
+
+const addClickHandlersToLinks = () => {
+    const linkBtns = document.querySelectorAll("button.links");
+    linkBtns.forEach(btn => {
+        btn.addEventListener("click", () => {
+            const target = btn.dataset.target;
+            if (!target) return;
+            window.location.hash = target;
+        })
+    })
+}
+
+const addClickHandlersToDeleteButtons = () => {
+    const deleteMoviesButtonElement = document.getElementById("moviesDeleteButton");
+    const deleteSeriesButtonElement = document.getElementById("seriesDeleteButton");
+    const deleteAnimeSeriesButtonElement = document.getElementById("animeSeriesDeleteButton");
+    deleteMoviesButtonElement.addEventListener("click", deleteFromRadarr);
+    deleteSeriesButtonElement.addEventListener("click", deleteFromSonarr);
+    deleteAnimeSeriesButtonElement.addEventListener("click", deleteFromSonarrAnime);
+}
+
+const getCheckedMedia = (table) => {
+    const checkboxes = table.getElementsByClassName('emby-checkbox');
+    const selectedMediaCheckboxes = Array.from(checkboxes).filter(checkbox => checkbox.checked);
+    const selectedMedia = selectedMediaCheckboxes.map(selectedMediaCheckbox => JSON.parse(selectedMediaCheckbox.dataset.mediaInfo));
+    console.log("Selected media: ", selectedMedia);
+    return selectedMedia;
+}
+
+const deleteMovieFromRadarrApi = async (movie) => {
+    const response = await fetch("/radarr/deleteMovieFromRadarr", {
+        method: "POST",
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(movie)
+    });
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+}
+
+const deleteSeriesFromSonarrApi = async (series) => {
+    const response = await fetch("/sonarr/deleteSeriesFromSonarr", {
+        method: "POST",
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(series)
+    });
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+}
+
+const deleteSeriesFromSonarrAnimeApi = async (series) => {
+    const response = await fetch("/sonarr/deleteSeriesFromSonarrAnime", {
+        method: "POST",
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(series)
+    });
+
+    if(!response.ok){
+        throw new Error(`Response status: ${response.status}`)
+    }
+}
+
+const deleteFromRadarr = async () => {
+    const selectedMovies = getCheckedMedia(moviesTable);
+    selectedMovies.forEach(async movie => await deleteMovieFromRadarrApi(movie));
+    refreshFrontEnd();
+}
+
+const deleteFromSonarr = () => {
+    const selectedSeries = getCheckedMedia(seriesTable);
+    selectedSeries.forEach(async series => await deleteSeriesFromSonarrApi(series));
+    refreshFrontEnd();
+}
+
+const deleteFromAnimeSonarr = () => {
+    const selectedSeries = getCheckedMedia(animeSeriesTable);
+    selectedSeries.forEach(async series => await deleteSeriesFromSonarrApi(series));
+    refreshFrontEnd();
+}
+
+const finishLoading = () => {
+    const loadingElement = document.getElementById("loading");
+    const homepage = document.getElementById("homepage");
+    loadingElement.style.visibility = "hidden";
+    homepage.style.visibility = "visible";
+}
+
+const startLoading = () => {
+    const loadingElement = document.getElementById("loading");
+    const homepage = document.getElementById("homepage");
+    const moviesDeleteButton = document.getElementById('moviesDeleteButton');
+    const seriesDeleteButton = document.getElementById('seriesDeleteButton');
+
+    loadingElement.style.visibility = "visible";
+    homepage.style.visibility = "hidden";
+    moviesDeleteButton.style.visibility = "hidden";
+    seriesDeleteButton.style.visibility = "hidden";
+}
--- a/Jellyfin.Plugin.MediaCleaner/Plugin.cs
+++ b/Jellyfin.Plugin.MediaCleaner/Plugin.cs
@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using Jellyfin.Plugin.MediaCleaner.Configuration;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Plugins;
-using MediaBrowser.Controller.Entities;
 using MediaBrowser.Model.Plugins;
 using MediaBrowser.Model.Serialization;

@@ -13,7 +11,7 @@ namespace Jellyfin.Plugin.MediaCleaner;
 /// <summary>
 /// The main plugin.
 /// </summary>
-public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
+public class Plugin : BasePlugin<Configuration>, IHasWebPages
 {
    /// <summary>
    /// Initializes a new instance of the <see cref="Plugin"/> class.
@@ -44,8 +42,13 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
        [
            new PluginPageInfo
            {
-                Name = "Settings",
-                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Configuration.settings.html", GetType().Namespace),
+                Name = "configuration.js",
+                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.configuration.js", GetType().Namespace),
+            },
+            new PluginPageInfo
+            {
+                Name = "Configuration",
+                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.configuration.html", GetType().Namespace),
            },
            new PluginPageInfo
            {
@@ -53,6 +56,16 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.home.html", GetType().Namespace),
                EnableInMainMenu = true,
            },
+            new PluginPageInfo
+            {
+                Name = "home.js",
+                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.home.js", GetType().Namespace),
+            },
+            new PluginPageInfo
+            {
+                Name = "global.css",
+                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.global.css", GetType().Namespace),
+            }
        ];
    }
 }
--- a/Jellyfin.Plugin.MediaCleaner/PluginServiceRegistrator.cs
+++ b/Jellyfin.Plugin.MediaCleaner/PluginServiceRegistrator.cs
@@ -0,0 +1,13 @@
+using Jellyfin.Plugin.MediaCleaner.Data;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Plugins;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Jellyfin.Plugin.MediaCleaner;
+public class PluginServiceRegistrator : IPluginServiceRegistrator
+{
+    public void RegisterServices(IServiceCollection serviceCollection, IServerApplicationHost applicationHost)
+    {
+        serviceCollection.AddSingleton<MediaCleanerState>();
+    }
+}
--- a/Jellyfin.Plugin.MediaCleaner/ScheduledTasks/StaleMediaTask.cs
+++ b/Jellyfin.Plugin.MediaCleaner/ScheduledTasks/StaleMediaTask.cs
@@ -1,198 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel;
-using System.Data.Common;
-using System.Diagnostics;
-using System.Linq;
-using System.Net;
-using System.Reflection.Metadata.Ecma335;
-using System.Threading;
-using System.Threading.Tasks;
-using Jellyfin.Data.Enums;
-using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Entities.Libraries;
-using Jellyfin.Plugin.MediaCleaner.Configuration;
-using Jellyfin.Plugin.MediaCleaner.Helpers;
-using Jellyfin.Plugin.MediaCleaner.Models;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.Tasks;
-using Microsoft.Extensions.Logging;
-
-namespace Jellyfin.Plugin.MediaCleaner.ScheduledTasks;
-
-/// <summary>
-/// A task to scan media for stale files.
-/// </summary>
-public sealed class StaleMediaTask : IScheduledTask
-{
-    private readonly ILogger _logger;
-    private readonly ILibraryManager _libraryManager;
-    private readonly LoggingHelper _loggingHelper;
-    private readonly MovieHelper _movieHelper;
-    private readonly SeriesHelper _seriesHelper;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="StaleMediaTask"/> class.
-    /// </summary>
-    /// <param name="logger">Logger for StaleMediaTask.</param>
-    /// <param name="libraryManager">Accesses jellyfin's library manager for media.</param>
-    public StaleMediaTask(ILogger<StaleMediaTask> logger, ILibraryManager libraryManager)
-    {
-        _logger = logger;
-        _libraryManager = libraryManager;
-        _loggingHelper = new LoggingHelper(_logger);
-        _movieHelper = new MovieHelper(_logger);
-        _seriesHelper = new SeriesHelper(_logger);
-    }
-
-    private static PluginConfiguration Configuration =>
-            Plugin.Instance!.Configuration;
-
-    string IScheduledTask.Name => "Scan Stale Media";
-
-    string IScheduledTask.Key => "Stale Media";
-
-    string IScheduledTask.Description => "Scan Stale Media";
-
-    string IScheduledTask.Category => "Media";
-
-    Task IScheduledTask.ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
-    {
-        _loggingHelper.StartLogging();
-
-        var query = new InternalItemsQuery
-        {
-            IncludeItemTypes = [BaseItemKind.Movie, BaseItemKind.Series],
-            Recursive = true
-        };
-
-        List<BaseItem> allItems = [.. _libraryManager.GetItemsResult(query).Items];
-
-        _loggingHelper.PrintStaleItemsInformation(allItems);
-
-        List<BaseItem> series = [.. allItems.Where(item => item.GetBaseItemKind() == BaseItemKind.Series)];
-        List<BaseItem> movies = [.. allItems.Where(item => item.GetBaseItemKind() == BaseItemKind.Movie)];
-
-        _loggingHelper.StartScanningSeriesItems();
-        List<BaseItem> staleEpisodes = [.. series.SelectMany(GetStaleEpisodes)];
-
-        _loggingHelper.StartScanningMoviesItems();
-        List<BaseItem> staleMovies = [.. GetStaleMovies(movies)];
-
-        _loggingHelper.PrintStaleMoviesInformation(staleMovies);
-        _loggingHelper.PrintStaleEpisodesInformation(FindSeriesInfoFromEpisodes, staleEpisodes);
-
-        _loggingHelper.EndLogging();
-
-        return Task.CompletedTask;
-    }
-
-    private List<BaseItem> GetStaleMovies(List<BaseItem> movies)
-    {
-        List<BaseItem> staleMovies = [];
-
-        staleMovies.AddRange(movies.Where(_movieHelper.IsMovieStale));
-
-        return staleMovies;
-    }
-
-
-    private List<BaseItem> GetStaleEpisodes(BaseItem item)
-    {
-        List<BaseItem> staleEpisodes = [];
-
-        // Gets each season in a show
-        var seasons = _libraryManager.GetItemList(new InternalItemsQuery
-        {
-            ParentId = item.Id,
-            Recursive = false
-        });
-
-        _loggingHelper.PrintDebugDataForSeries(item);
-
-        int seasonNumber = 1;
-
-        foreach (var season in seasons)
-        {
-            // Gets each episode, to access user data.
-            var episodes = _libraryManager.GetItemList(new InternalItemsQuery
-            {
-                ParentId = season.Id,
-                Recursive = false
-            });
-
-            bool seasonCreatedOutsideCutoff = episodes.All(episode => episode.DateCreated < DateTime.Now.AddDays(-Configuration.StaleMediaCutoff));
-
-            _loggingHelper.PrintDebugSeasonNumber(seasonNumber);
-
-            if (seasonCreatedOutsideCutoff)
-            {
-                _loggingHelper.PrintDebugSeasonCreatedOutsideCutoff();
-            }
-
-            bool seasonHasUserData = episodes.Any(episode => episode.UserData.Count > 0);
-            bool seasonIsStale = (seasonHasUserData && _seriesHelper.IsSeasonUserDataStale(episodes, seasonNumber)) || seasonCreatedOutsideCutoff;
-            bool noUserDataAndOutsideCutoff = !seasonHasUserData && seasonCreatedOutsideCutoff;
-
-            if (seasonIsStale)
-            {
-                if (noUserDataAndOutsideCutoff)
-                {
-                    _loggingHelper.PrintDebugNoUserDataAndOutsideCutoffEpisodeInfo(episodes, seasonNumber);
-                }
-
-                staleEpisodes.AddRange(episodes);
-            }
-            seasonNumber++;
-        }
-
-        _loggingHelper.EndOfScanningForSeries(item);
-
-        return staleEpisodes;
-    }
-
-    private List<SeriesInfo> FindSeriesInfoFromEpisodes(IReadOnlyCollection<BaseItem> episodes)
-    {
-        Guid[] seasonIds = [.. episodes.Select(episode => episode.ParentId).Distinct()];
-
-        var seasons = _libraryManager.GetItemList(new InternalItemsQuery
-        {
-            ItemIds = seasonIds
-        });
-
-        Guid[] seriesIds = [.. seasons.Select(season => season.ParentId).Distinct()];
-
-        var series = _libraryManager.GetItemList(new InternalItemsQuery
-        {
-            ItemIds = seriesIds
-        }).ToList();
-
-        List<string> seriesNames = [.. series.Select(series => series.Name).Distinct()];
-
-        List<SeriesInfo> seriesInfoList = [];
-
-        series.ForEach(series =>
-        {
-            seriesInfoList.Add(new SeriesInfo
-            {
-                Id = series.Id,
-                SeriesName = series.Name,
-                Seasons = [.. seasons.Where(season => season.ParentId == series.Id).Select(season => season.Name)]
-            });
-        });
-
-        return seriesInfoList;
-    }
-
-    IEnumerable<TaskTriggerInfo> IScheduledTask.GetDefaultTriggers()
-    {
-        // Run this task every 24 hours
-        yield return new TaskTriggerInfo
-        {
-            Type = TaskTriggerInfoType.IntervalTrigger,
-            IntervalTicks = TimeSpan.FromHours(24).Ticks
-        };
-    }
-}
--- a/Jellyfin.Plugin.MediaCleaner/StaleMediaScanner.cs
+++ b/Jellyfin.Plugin.MediaCleaner/StaleMediaScanner.cs
@@ -0,0 +1,251 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.MediaCleaner.Helpers;
+using Jellyfin.Plugin.MediaCleaner.Models;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.MediaCleaner;
+
+/// <summary>
+/// A task to scan media for stale files.
+/// </summary>
+public sealed class StaleMediaScanner
+{
+    private readonly ILogger _logger;
+    private readonly ILibraryManager _libraryManager;
+    private readonly LoggingHelper _loggingHelper;
+    private readonly MovieHelper _movieHelper;
+    private readonly SeriesHelper _seriesHelper;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StaleMediaTask"/> class.
+    /// </summary>
+    /// <param name="logger">Logger for StaleMediaTask.</param>
+    /// <param name="libraryManager">Accesses jellyfin's library manager for media.</param>
+    public StaleMediaScanner(ILogger<StaleMediaScanner> logger, ILibraryManager libraryManager)
+    {
+        _logger = logger;
+        _libraryManager = libraryManager;
+        _loggingHelper = new LoggingHelper(_logger);
+        _movieHelper = new MovieHelper(_logger);
+        _seriesHelper = new SeriesHelper(_logger);
+    }
+
+    public Task<IEnumerable<MediaInfo>> ScanStaleMedia()
+    {
+        _loggingHelper.LogDebugInformation("--DEBUG MODE ACTIVE--");
+        _loggingHelper.LogInformation("-------------------------------------------------");
+        _loggingHelper.LogInformation("Starting stale media scan...");
+        _loggingHelper.LogInformation("-------------------------------------------------");
+
+        var query = new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Movie, BaseItemKind.Series],
+            Recursive = true
+        };
+
+        List<BaseItem> allItems = [.. _libraryManager.GetItemsResult(query).Items];
+
+        _loggingHelper.LogInformation("Total items to scan: {ItemCount}", allItems.Count);
+        _loggingHelper.LogDebugInformation("Items found: {AllItems}", allItems);
+
+        List<BaseItem> series = [.. allItems.Where(item => item.GetBaseItemKind() == BaseItemKind.Series)];
+        List<BaseItem> movies = [.. allItems.Where(item => item.GetBaseItemKind() == BaseItemKind.Movie)];
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("Starting scan of series items.");
+
+        List<BaseItem> staleSeasons = [.. series.SelectMany(GetStaleSeasons)];
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("End of scan for series items.");
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("Starting scan of movie items.");
+
+        List<BaseItem> staleMovies = [.. GetStaleMovies(movies)];
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("End of scan for movie items.");
+
+        _loggingHelper.LogInformation("-------------------------------------------------");
+        _loggingHelper.LogInformation("Stale seasons found: {StaleSeasons}", staleSeasons.Count);
+
+        IEnumerable<MediaInfo> staleSeriesInfo = [];
+
+        if (staleSeasons.Count > 0)
+        {
+            staleSeriesInfo = FindSeriesInfo(staleSeasons);
+
+            foreach (SeriesInfo seriesInfo in staleSeriesInfo.Cast<SeriesInfo>())
+            {
+                _loggingHelper.LogInformation("Series Info: TmbdID: {Id} | Series Name: {SeriesName} | Stale Seasons: {Seasons}", [seriesInfo.TmdbId, seriesInfo.Name, string.Join(", ", seriesInfo.Seasons)]);
+            }
+        }
+        else
+        {
+            _loggingHelper.LogInformation("No stale seasons found!");
+        }
+
+        _loggingHelper.LogInformation("-------------------------------------------------");
+        _loggingHelper.LogInformation("Stale Movies found: {StaleMovies}", staleMovies.Count);
+
+        IEnumerable<MediaInfo> staleMoviesInfo = [];
+
+        if (staleMovies.Count > 0)
+        {
+            staleMoviesInfo = staleMovies.Select(movie => {
+                movie.ProviderIds.TryGetValue("Tmdb", out string? tmdbId);
+                return new MovieInfo
+                {
+                    TmdbId = tmdbId,
+                    Name = movie.Name
+                };
+            });
+
+            foreach (MovieInfo movieInfo in staleMoviesInfo.Cast<MovieInfo>())
+            {
+                _loggingHelper.LogInformation("Movie Info: TmdbID: {Id} | Movie Name: {MovieName}", [movieInfo.TmdbId, movieInfo.Name]);
+            }
+        }
+        else
+        {
+            _loggingHelper.LogInformation("No stale movies found!");
+        }
+
+        _loggingHelper.LogInformation("-------------------------------------------------");
+        _loggingHelper.LogInformation("Ending stale media scan...");
+        _loggingHelper.LogInformation("-------------------------------------------------");
+
+        IEnumerable<MediaInfo> mediaInfo = staleSeriesInfo.Concat(staleMoviesInfo);
+
+        return Task.FromResult(mediaInfo);
+    }
+
+    private List<BaseItem> GetStaleMovies(List<BaseItem> movies)
+    {
+        List<BaseItem> staleMovies = [];
+
+        try
+        {
+            staleMovies.AddRange(movies.Where(_movieHelper.IsMovieStale));
+        }
+        catch (ArgumentNullException ex)
+        {
+            _loggingHelper.LogInformation("Arguement Null Exception in GetStaleMovies!");
+            _loggingHelper.LogInformation(ex.Message);
+        }
+
+        return staleMovies;
+    }
+
+    private IEnumerable<BaseItem> GetStaleSeasonsWithShortCircuitOnNonStaleSeason(IEnumerable<BaseItem> seasons)
+    {
+        foreach (BaseItem season in seasons)
+        {
+            var episodes = _libraryManager.GetItemList(new InternalItemsQuery
+            {
+                ParentId = season.Id,
+                Recursive = false
+            });
+
+            _loggingHelper.LogDebugInformation("Season debug information for {SeasonNumber}:", season);
+
+            bool isSeasonDataStale = false;
+
+            try
+            {
+                isSeasonDataStale = _seriesHelper.IsSeasonDataStale(episodes);
+            }
+            catch (ArgumentNullException ex)
+            {
+                _loggingHelper.LogInformation("Argument Null Exception in GetStaleSeasons!");
+                _loggingHelper.LogInformation(ex.Message);
+            }
+
+            _loggingHelper.LogDebugInformation("End of season debug information for {SeasonNumber}.", season);
+
+            if (!isSeasonDataStale) yield break;
+            yield return season;
+        }
+    }
+
+    private List<BaseItem> GetStaleSeasons(BaseItem item)
+    {
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("Debug data for series: {SeriesName}", item.Name);
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+
+        var seasons = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            ParentId = item.Id,
+            Recursive = false
+        });
+
+        List<BaseItem> staleSeasons = [.. GetStaleSeasonsWithShortCircuitOnNonStaleSeason(seasons)];
+
+        // [ ..seasons
+        // .Where(season => {
+        //     var episodes = _libraryManager.GetItemList(new InternalItemsQuery
+        //     {
+        //         ParentId = season.Id,
+        //         Recursive = false
+        //     });
+
+        //     _loggingHelper.LogDebugInformation("Season debug information for {SeasonNumber}:", season);
+
+        //     bool isSeasonDataStale = false;
+
+        //     try
+        //     {
+        //         isSeasonDataStale = _seriesHelper.IsSeasonDataStale(episodes);
+        //     }
+        //     catch (ArgumentNullException ex)
+        //     {
+        //         _loggingHelper.LogInformation("Arguement Null Exception in GetStaleSeasons!");
+        //         _loggingHelper.LogInformation(ex.Message);
+        //     }
+
+        //     _loggingHelper.LogDebugInformation("End of season debug information for {SeasonNumber}.", season);
+
+        //     return isSeasonDataStale;
+        // })];
+
+
+        _loggingHelper.LogDebugInformation("-------------------------------------------------");
+        _loggingHelper.LogDebugInformation("End of scanning for series: {Series}", item);
+
+        return staleSeasons;
+    }
+
+    private IEnumerable<MediaInfo> FindSeriesInfo(IReadOnlyCollection<BaseItem> seasons)
+    {
+        Guid[] seriesIds = [.. seasons.Select(season => season.ParentId).Distinct()];
+
+        IReadOnlyCollection<BaseItem> series = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            ItemIds = seriesIds
+        });
+
+        IEnumerable<SeriesInfo> seriesInfoList = series.Select(series =>
+        {
+            series.ProviderIds.TryGetValue("Tvdb", out string? tvdbId);
+            series.ProviderIds.TryGetValue("Tmdb", out string? tmdbId);
+            return new SeriesInfo
+            {
+                SeriesId = series.Id,
+                TmdbId = tmdbId,
+                TvdbId = tvdbId,
+                Name = series.Name,
+                Seasons = [.. seasons.Where(season => season.ParentId == series.Id).Select(season => season.Name.Replace("Season ", "", StringComparison.OrdinalIgnoreCase))]
+            };
+        });
+
+        return seriesInfoList;
+    }
+}
--- a/README.md
+++ b/README.md
@@ -1,10 +1,11 @@
 The idea behind this plugin is to have an easy way to run a task to find all movies and shows in your media collection that users haven't viewed in a number of cutoff days.

-At the time of writing, the plugin is only capable of logging movies and shows that are stale (Unwatched for 90 days) by running a scheduled task. You will need to view your logs to know the number of stale files.
+At the time of writing, the plugin is only capable of logging movies and shows that are stale (Unwatched for a user set number of days) by running a scheduled task. You will need to view your logs to know the number of stale files and the names of said files.

 Planned features:
- Better logging to show more than just the count.
- A page that shows what media is currently flagged for removal. And a button to confirm removal.
+- Better logging to show more than just the count. ✅
+- A page that shows what media is currently flagged for removal. ✅
+- Checkboxes to select media for removal within Jellyfin. ✅
 - Integration with sonarr and radarr apis to delete your media.
 - Whitelist for shows to ignore. (Seasonal shows)
Author	SHA1	Message	Date
Thomas Gander	a676a8e8ec	Merge branch 'Radarr-Sonarr-Integration' of https://gitea.silverhat.ca/T-Gander/jellyfin-plugin-mediacleaner into Radarr-Sonarr-Integration	2026-03-08 19:28:26 -06:00
Thomas Gander	21a9cc86d8	Refactor of http client and addition of sonarr anime table	2026-03-08 19:28:04 -06:00
T-Gander	b41979297a	Merge branch 'main' into Radarr-Sonarr-Integration	2026-03-08 00:08:12 -07:00
Thomas Gander	8f049e6704	Added refresh for buttons so that they aren't visible after delete	2026-03-08 00:06:48 -07:00
Thomas Gander	324d48e7cf	Finished off sonarr integration (Non anime) and refactored requests into a Http helper.	2026-03-07 23:22:06 -07:00
Thomas Gander	11c241b149	Finished Radarr integration	2026-03-07 19:21:58 -07:00
Thomas Gander	3f5074aa3b	Reworked Models to use tmdb to enable integration with Radarr api. Also reworked test connection to use api to validate as I ran into CORS errors. I also set up an endpoint to call radarr to delete movies. Currently only got to retrieving movie info. Should be able to use the id retrieved to then delete the movie.	2026-03-07 18:02:45 -07:00
Thomas Gander	958c581280	Added comments to figure out which endpoint to use	2026-03-07 12:24:13 -07:00
Thomas Gander	c94a8b8391	Added click handlers for radarr and sonarr	2026-03-07 12:10:09 -07:00
Thomas Gander	fe3b7e412b	Added delete buttons to home page	2026-03-07 11:56:26 -07:00
Thomas Gander	bf40d758fc	Resolved initialization order	2026-02-17 21:31:32 -07:00
Thomas Gander	48d118c56a	Swapped layout of Address and API key	2026-02-17 21:28:12 -07:00
Thomas Gander	4bcd89c1a9	Added logic to be able to test your Management configuration settings for radarr and sonarr	2026-02-17 21:27:05 -07:00
Thomas Gander	da94e130ac	Fixed issue with async task	2026-02-17 20:40:44 -07:00
T-Gander	4642a6c762	Update README.md	2026-02-16 18:44:13 -07:00
Thomas Gander	1253693ebe	Added comment	2026-02-16 18:41:12 -07:00
Thomas Gander	80a126fb30	Created custom styling for checkbox	2026-02-16 18:38:33 -07:00
Thomas Gander	be5a58dcf1	Added a border radius and color to configuration button	2026-02-16 17:54:29 -07:00
Thomas Gander	e6c4939191	Removed margins from some areas to improve spacing	2026-02-16 17:50:19 -07:00
Thomas Gander	9348b33ed6	Updated styling for the configuration page	2026-02-16 17:47:26 -07:00
Thomas Gander	462a2beea1	Moved styles to a global.css stylesheet. Also added basic validation with a transition	2026-02-16 16:08:12 -07:00
Thomas Gander	a720bba7a7	Refactor of plugin structure to make more sense compared to the default template	2026-02-16 14:08:15 -07:00
Thomas Gander	61e868bfa2	Added settings for radarr and sonarr addresses	2026-02-14 16:18:11 -07:00
Thomas Gander	bc7c95af08	Added basic state with selections	2026-02-14 16:01:06 -07:00
T-Gander	1dfa4f9996	Merge pull request 'Media-Cleaner-Homepage-and-Api' (#9 ) from Media-Cleaner-Homepage-and-Api into main Reviewed-on: #9	2026-02-12 19:30:36 -07:00
T-Gander	b3db9a86f6	Merge branch 'main' into Media-Cleaner-Homepage-and-Api	2026-02-12 19:30:18 -07:00
Thomas Gander	d6bdfb95c7	Updated table to use check boxes for future selections. Added short circuiting when parsing seasons	2026-02-12 19:27:41 -07:00
Thomas Gander	d73153ad37	Merge branch 'Media-Cleaner-Homepage-and-Api' of https://gitea.silverhat.ca/T-Gander/jellyfin-plugin-mediacleaner into Media-Cleaner-Homepage-and-Api	2026-01-28 08:05:06 -07:00
Thomas Gander	1a4d1145b3	Managed to move css injection to a link tag by moving the link tag inside the div.	2026-01-28 08:04:34 -07:00
T-Gander	629d5d1f2e	Merge pull request 'Media-Cleaner-Homepage-and-Api' (#7 ) from Media-Cleaner-Homepage-and-Api into main Reviewed-on: #7	2026-01-27 08:16:01 -07:00
T-Gander	1bd4935232	Merge branch 'main' into Media-Cleaner-Homepage-and-Api	2026-01-27 08:15:49 -07:00
Thomas Gander	984db9e089	Bumped build version	2026-01-27 08:10:20 -07:00
Thomas Gander	e77f7dcd5f	Cleaned up media_cleaner_table.js and renamed to home.js. Updated table with no data to have a message.	2026-01-27 08:09:03 -07:00
Thomas Gander	669f59db15	Managed to move js styling to css file and inject it during load.	2026-01-26 08:15:53 -07:00
Thomas Gander	a69f9df4e1	Disabled buttons with no click handlers and added comments. Also updated Settings button styling	2026-01-25 23:02:05 -07:00
Thomas Gander	e99ce96563	Added styling for tables and also converted settings anchor to a button to enable styling	2026-01-25 22:55:00 -07:00
Thomas Gander	56403b5722	Updated plugin to refresh page and state whenever the page is shown	2026-01-25 15:34:59 -07:00
Thomas Gander	ebe24e2630	Added barebones UI for Media Cleaner	2026-01-25 15:07:55 -07:00
Thomas Gander	04ef815a9b	Converted StaleMediaTask to StaleMediaScanner for use in plugin home page. Also added a generic Media Info class that can be filtered to return the data you desire.	2026-01-25 14:52:47 -07:00
Thomas Gander	66716a9bc9	Updated logging to be more concise when debug is not active	2026-01-25 09:15:26 -07:00
Thomas Gander	9bddc59fe2	Further improvement to logging formatting and readability	2026-01-25 09:11:45 -07:00
Thomas Gander	82441d5247	Improved logging futher and updated some methods to use LogDebugInformation and to handle exceptions	2026-01-25 08:58:46 -07:00
T-Gander	5ba270c9a0	Merge pull request 'Media cleaner logging improvements and refactors' (#6 ) from Media-Cleaner-Homepage-and-Api into main Reviewed-on: #6	2026-01-24 23:16:39 -07:00
Thomas Gander	4fc8b4799d	Continued to improve logging and fixed a few bugs introduced by refactor	2026-01-24 23:14:16 -07:00
Thomas Gander	9e324f14a7	Significantly refactored code to help with readability of logging and episode processing	2026-01-24 08:34:42 -07:00
Thomas Gander	d024035d07	Managed to figure out how to use javascript on the plugin page by utilizing data-controller as found in other repos. Unsure how this is used, but appears to be how you can attach a js file to a div. Also implemented a basic state api to build off of in future.	2026-01-20 20:32:37 -07:00
Thomas Gander	8d85194df5	Removed unused logging	2026-01-19 08:12:19 -07:00
Thomas Gander	d78d1069b1	Merge branch 'main' of https://gitea.silverhat.ca/T-Gander/jellyfin-plugin-mediacleaner	2026-01-19 08:11:10 -07:00
Thomas Gander	f7c463aba4	Simplified Stale Episodes logic	2026-01-19 08:10:54 -07:00
T-Gander	77f2873180	Update README.md	2026-01-19 08:03:56 -07:00
Thomas Gander	b2da7beb00	Renamed method to be clearer in intention	2026-01-19 08:01:49 -07:00
Thomas Gander	9696826406	Increment version	2026-01-18 20:37:58 -07:00
Thomas Gander	873b29985c	Fixed stale episode logic.	2026-01-18 20:32:27 -07:00
Thomas Gander	30107010b1	Simplified some linq queries and fixed some debug logging getting through	2026-01-18 19:23:59 -07:00