feat: add TV show trailer downloads, episode trailers, and movie/TV trailer separation

- Download trailers for TV shows from TMDB with separate sources and an independent max-count cap (0 disables a category) - Play trailers before TV episodes via IIntroProvider, limited to the first episode a user watches each day - Tag TV show trailers in their NFO so movies only get movie trailers and episodes only get TV show trailers Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
chore: update manifest.json for v1.0.0.3
2026-06-10 00:41:37 -04:00 · 2026-06-09 21:16:16 +00:00 · 2026-06-09 17:15:38 -04:00 · 2026-06-09 17:44:48 +00:00
10 changed files with 742 additions and 104 deletions
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/PluginConfiguration.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/PluginConfiguration.cs
@@ -8,13 +8,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration

        public string TmdbApiKey { get; set; } = string.Empty;

-        // ── Sources ───────────────────────────────────────────────────────────
+        // ── Sources (Movies) ─────────────────────────────────────────────────

        public bool SourceNowPlaying { get; set; } = true;
        public bool SourceUpcoming { get; set; } = true;
        public bool SourcePopular { get; set; } = false;
        public bool SourceTopRated { get; set; } = false;

+        // ── Sources (TV Shows) ───────────────────────────────────────────────
+
+        public bool SourceTvAiringToday { get; set; } = true;
+        public bool SourceTvOnTheAir { get; set; } = true;
+        public bool SourceTvPopular { get; set; } = false;
+        public bool SourceTvTopRated { get; set; } = false;
+
        // ── Date Range ────────────────────────────────────────────────────────

        public int ReleaseDateRangeMonths { get; set; } = 6;
@@ -22,7 +29,13 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration
        // ── Download Settings ─────────────────────────────────────────────────

        public string DownloadFolder { get; set; } = string.Empty;
+
+        /// <summary>Maximum movie trailers to download per run. 0 = don't download movie trailers.</summary>
        public int MaxTrailersToDownload { get; set; } = 20;
+
+        /// <summary>Maximum TV show trailers to download per run. 0 = don't download TV show trailers.</summary>
+        public int MaxTvTrailersToDownload { get; set; } = 0;
+
        public int MaxPagesPerSource { get; set; } = 3;
        public int PreferredVideoHeight { get; set; } = 720;
        public bool SkipAlreadyDownloaded { get; set; } = true;
@@ -43,5 +56,17 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration

        /// <summary>Number of trailers to inject before each movie via IIntroProvider. 0 = disabled.</summary>
        public int TrailersPerMovie { get; set; } = 1;
+
+        /// <summary>Only pick trailers whose genre overlaps with the movie being played.</summary>
+        public bool FilterByGenre { get; set; } = false;
+
+        /// <summary>Only pick trailers rated at most the same as the movie being played.</summary>
+        public bool FilterByRating { get; set; } = false;
+
+        /// <summary>Cycle through all trailers before repeating any.</summary>
+        public bool AvoidRepeats { get; set; } = true;
+
+        /// <summary>Also inject trailers before TV episodes, but only before the first episode a user watches each day.</summary>
+        public bool TrailersForEpisodes { get; set; } = false;
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/config.html
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/config.html
@@ -72,11 +72,11 @@
                        </div>
                    </fieldset>

-                    <!-- Sources -->
+                    <!-- Movie Sources -->
                    <fieldset class="verticalSection verticalSection-extrabottompadding">
-                        <legend><h3 class="sectionTitle">Trailer Sources</h3></legend>
+                        <legend><h3 class="sectionTitle">Movie Trailer Sources</h3></legend>
                        <p class="fieldDescription">
-                            Choose which TMDB lists to pull trailers from. Enable multiple for more variety.
+                            Choose which TMDB lists to pull movie trailers from. Enable multiple for more variety.
                        </p>

                        <div class="checkboxContainer checkboxContainer-withDescription">
@@ -120,11 +120,60 @@
                        </div>
                    </fieldset>

+                    <!-- TV Show Sources -->
+                    <fieldset class="verticalSection verticalSection-extrabottompadding">
+                        <legend><h3 class="sectionTitle">TV Show Trailer Sources</h3></legend>
+                        <p class="fieldDescription">
+                            Choose which TMDB lists to pull TV show trailers from. Enable multiple for more variety.
+                            Has no effect if "Max TV show trailers per run" below is set to 0.
+                        </p>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-airing-today" />
+                                <span>Airing Today</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                TV shows airing today.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-on-the-air" />
+                                <span>On The Air</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                TV shows airing in the next 7 days.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-popular" />
+                                <span>Popular</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Most popular TV shows on TMDB right now, filtered by the date range below.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-top-rated" />
+                                <span>Top Rated</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Highest rated TV shows on TMDB, filtered by the date range below.
+                            </div>
+                        </div>
+                    </fieldset>
+
                    <!-- Date Range -->
                    <fieldset class="verticalSection verticalSection-extrabottompadding">
                        <legend><h3 class="sectionTitle">Date Range</h3></legend>
                        <div class="selectContainer">
-                            <label class="selectLabel" for="date-range">Only include movies released within</label>
+                            <label class="selectLabel" for="date-range">Only include titles released within</label>
                            <select is="emby-select" id="date-range" class="emby-select-withcolor emby-select">
                                <option value="3">Last 3 months</option>
                                <option value="6">Last 6 months</option>
@@ -133,8 +182,9 @@
                                <option value="0">All time (no limit)</option>
                            </select>
                            <div class="fieldDescription">
-                                Applies to all sources. "Now Playing" and "Upcoming" already have tight date windows
-                                set by TMDB, but this provides an additional filter.
+                                Applies to all sources (movie release date / TV show first-air date). "Now Playing",
+                                "Upcoming", "Airing Today" and "On The Air" already have tight date windows set by
+                                TMDB, but this provides an additional filter.
                            </div>
                        </div>
                    </fieldset>
@@ -153,10 +203,20 @@
                        </div>

                        <div class="inputContainer">
-                            <label class="inputLabel inputLabelUnfocused" for="max-trailers">Max trailers per run</label>
-                            <input type="number" id="max-trailers" is="emby-input" min="1" max="200" />
+                            <label class="inputLabel inputLabelUnfocused" for="max-trailers">Max movie trailers per run</label>
+                            <input type="number" id="max-trailers" is="emby-input" min="0" max="200" />
                            <div class="fieldDescription">
-                                Maximum number of trailers to download each time the task runs. Default: 20.
+                                Maximum number of movie trailers to download each time the task runs.
+                                Set to 0 to not download any movie trailers. Default: 20.
+                            </div>
+                        </div>
+
+                        <div class="inputContainer">
+                            <label class="inputLabel inputLabelUnfocused" for="max-tv-trailers">Max TV show trailers per run</label>
+                            <input type="number" id="max-tv-trailers" is="emby-input" min="0" max="200" />
+                            <div class="fieldDescription">
+                                Maximum number of TV show trailers to download each time the task runs.
+                                Set to 0 to not download any TV show trailers. Default: 0.
                            </div>
                        </div>

@@ -164,7 +224,7 @@
                            <label class="inputLabel inputLabelUnfocused" for="max-pages">Pages per source</label>
                            <input type="number" id="max-pages" is="emby-input" min="1" max="10" />
                            <div class="fieldDescription">
-                                How many pages to fetch from each TMDB source (20 movies per page). Default: 3.
+                                How many pages to fetch from each TMDB source (20 results per page). Default: 3.
                            </div>
                        </div>

@@ -180,10 +240,10 @@
                        <div class="checkboxContainer checkboxContainer-withDescription">
                            <label>
                                <input is="emby-checkbox" type="checkbox" id="skip-library" />
-                                <span>Skip movies already in my Jellyfin library</span>
+                                <span>Skip movies/shows already in my Jellyfin library</span>
                            </label>
                            <div class="fieldDescription checkboxFieldDescription">
-                                Trailers for movies you already own won't be downloaded.
+                                Trailers for movies and TV shows you already own won't be downloaded.
                            </div>
                        </div>

@@ -193,7 +253,7 @@
                                <span>Skip trailers already downloaded</span>
                            </label>
                            <div class="fieldDescription checkboxFieldDescription">
-                                If a folder already exists for a movie, don't re-download it.
+                                If a folder already exists for a movie or TV show, don't re-download it.
                            </div>
                        </div>
                    </fieldset>
@@ -235,6 +295,50 @@
                                Default: 1.
                            </div>
                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="filter-genre" />
+                                <span>Match genre to the movie being played</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Only pick trailers whose genre overlaps with the movie you are watching.
+                                Falls back to any trailer if no match is found.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="filter-rating" />
+                                <span>Limit to same age rating or lower</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Never show a trailer rated higher than the movie being played.
+                                Falls back to any trailer if no match is found.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="avoid-repeats" />
+                                <span>Avoid repeating trailers</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Cycle through all available trailers before playing any again.
+                                Resets automatically once every trailer has been shown. Default: on.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="trailers-for-episodes" />
+                                <span>Also play trailers before TV episodes</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Only plays before the first episode a user watches each day —
+                                if you watch several episodes back-to-back, only the first gets trailers.
+                            </div>
+                        </div>
                    </fieldset>

                    <!-- Advanced -->
@@ -262,6 +366,13 @@
        <script type="text/javascript">
            var pluginId = "b581493e-1046-40ed-b6dc-cb8027624984";

+            // parseInt(...) || fallback treats 0 as falsy, which breaks fields where
+            // 0 is a meaningful value (e.g. "don't download any").
+            function parseIntOrDefault(value, fallback) {
+                var n = parseInt(value, 10);
+                return isNaN(n) ? fallback : n;
+            }
+
            $('.cinemaTrailers4JellyfinsConfigPage').on('pageshow', function () {
                Dashboard.showLoadingMsg();
                ApiClient.getPluginConfiguration(pluginId).then(function (config) {
@@ -270,9 +381,14 @@
                    document.getElementById('source-upcoming').checked      = config.SourceUpcoming !== false;
                    document.getElementById('source-popular').checked       = !!config.SourcePopular;
                    document.getElementById('source-top-rated').checked     = !!config.SourceTopRated;
+                    document.getElementById('source-tv-airing-today').checked = config.SourceTvAiringToday !== false;
+                    document.getElementById('source-tv-on-the-air').checked   = config.SourceTvOnTheAir !== false;
+                    document.getElementById('source-tv-popular').checked      = !!config.SourceTvPopular;
+                    document.getElementById('source-tv-top-rated').checked    = !!config.SourceTvTopRated;
                    document.getElementById('date-range').value             = String(config.ReleaseDateRangeMonths ?? 6);
                    document.getElementById('download-folder').value        = config.DownloadFolder || '';
                    document.getElementById('max-trailers').value           = config.MaxTrailersToDownload ?? 20;
+                    document.getElementById('max-tv-trailers').value        = config.MaxTvTrailersToDownload ?? 0;
                    document.getElementById('max-pages').value              = config.MaxPagesPerSource ?? 3;
                    document.getElementById('video-quality').value          = String(config.PreferredVideoHeight ?? 720);
                    document.getElementById('skip-library').checked         = config.SkipMoviesInLibrary !== false;
@@ -285,6 +401,10 @@
                        });
                    document.getElementById('max-total-trailers').value     = config.MaxTotalTrailers ?? 50;
                    document.getElementById('trailers-per-movie').value     = config.TrailersPerMovie ?? 1;
+                    document.getElementById('filter-genre').checked         = !!config.FilterByGenre;
+                    document.getElementById('filter-rating').checked        = !!config.FilterByRating;
+                    document.getElementById('avoid-repeats').checked        = config.AvoidRepeats !== false;
+                    document.getElementById('trailers-for-episodes').checked = !!config.TrailersForEpisodes;
                    Dashboard.hideLoadingMsg();
                });
            });
@@ -297,9 +417,14 @@
                    config.SourceUpcoming         = document.getElementById('source-upcoming').checked;
                    config.SourcePopular          = document.getElementById('source-popular').checked;
                    config.SourceTopRated         = document.getElementById('source-top-rated').checked;
+                    config.SourceTvAiringToday    = document.getElementById('source-tv-airing-today').checked;
+                    config.SourceTvOnTheAir       = document.getElementById('source-tv-on-the-air').checked;
+                    config.SourceTvPopular        = document.getElementById('source-tv-popular').checked;
+                    config.SourceTvTopRated       = document.getElementById('source-tv-top-rated').checked;
                    config.ReleaseDateRangeMonths = parseInt(document.getElementById('date-range').value, 10);
                    config.DownloadFolder         = document.getElementById('download-folder').value;
-                    config.MaxTrailersToDownload  = parseInt(document.getElementById('max-trailers').value, 10) || 20;
+                    config.MaxTrailersToDownload  = parseIntOrDefault(document.getElementById('max-trailers').value, 20);
+                    config.MaxTvTrailersToDownload = parseIntOrDefault(document.getElementById('max-tv-trailers').value, 0);
                    config.MaxPagesPerSource      = parseInt(document.getElementById('max-pages').value, 10) || 3;
                    config.PreferredVideoHeight   = parseInt(document.getElementById('video-quality').value, 10) || 720;
                    config.SkipMoviesInLibrary    = document.getElementById('skip-library').checked;
@@ -311,8 +436,12 @@
                    });
                    // If all are checked treat it as "no preference" (empty string)
                    config.AllowedLanguages       = checkedLangs.length === allLangCodes.length ? '' : checkedLangs.join(',');
-                    config.MaxTotalTrailers       = parseInt(document.getElementById('max-total-trailers').value, 10) || 50;
+                    config.MaxTotalTrailers       = parseIntOrDefault(document.getElementById('max-total-trailers').value, 50);
                    config.TrailersPerMovie       = parseInt(document.getElementById('trailers-per-movie').value, 10) || 0;
+                    config.FilterByGenre         = document.getElementById('filter-genre').checked;
+                    config.FilterByRating        = document.getElementById('filter-rating').checked;
+                    config.AvoidRepeats          = document.getElementById('avoid-repeats').checked;
+                    config.TrailersForEpisodes   = document.getElementById('trailers-for-episodes').checked;
                    ApiClient.updatePluginConfiguration(pluginId, config)
                        .then(Dashboard.processPluginConfigurationUpdateResult);
                });
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Jellyfin.Plugin.CinemaTrailers4Jellyfins.csproj
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Jellyfin.Plugin.CinemaTrailers4Jellyfins.csproj
@@ -3,8 +3,8 @@
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <RootNamespace>Jellyfin.Plugin.CinemaTrailers4Jellyfins</RootNamespace>
-    <AssemblyVersion>1.0.0.2</AssemblyVersion>
-    <FileVersion>1.0.0.2</FileVersion>
+    <AssemblyVersion>1.0.0.4</AssemblyVersion>
+    <FileVersion>1.0.0.4</FileVersion>
    <Nullable>enable</Nullable>
    <GenerateDocumentationFile>false</GenerateDocumentationFile>
    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs
@@ -8,6 +8,7 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Tasks;
@@ -25,7 +26,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

        public string Name => "Download TMDB Trailers";
        public string Key => "CinemaTrailers4JellyfinsDownload";
-        public string Description => "Downloads trailers from TMDB for upcoming and recently released movies not in your library, packaged as fake-movie folders for use with a Cinema Mode / trailer pre-roll plugin.";
+        public string Description => "Downloads trailers from TMDB for upcoming and recently released movies and TV shows not in your library, packaged as fake-movie folders for use with a Cinema Mode / trailer pre-roll plugin.";
        public string Category => "CinemaTrailers4Jellyfins";

        public DownloadTrailersTask(
@@ -67,9 +68,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                return;
            }

-            if (!config.SourceNowPlaying && !config.SourceUpcoming && !config.SourcePopular && !config.SourceTopRated)
+            var downloadMovies = config.MaxTrailersToDownload > 0;
+            var downloadTvShows = config.MaxTvTrailersToDownload > 0;
+
+            if (!downloadMovies && !downloadTvShows)
            {
-                _logger.LogWarning("|CinemaTrailers4Jellyfins| No TMDB sources selected. Enable at least one source. Skipping task.");
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| Both 'Max movie trailers' and 'Max TV show trailers' are 0. Skipping task.");
                return;
            }

@@ -79,26 +83,64 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

            progress.Report(5);

-            var libraryTmdbIds = config.SkipMoviesInLibrary
-                ? GetLibraryTmdbIds()
-                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-
-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} movies with TMDB IDs (will skip these)", libraryTmdbIds.Count);
-
-            progress.Report(10);
-
            var allowedLanguages = string.IsNullOrWhiteSpace(config.AllowedLanguages)
                ? null
                : new HashSet<string>(
                    config.AllowedLanguages.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries),
                    StringComparer.OrdinalIgnoreCase) as IReadOnlySet<string>;

-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching candidates from TMDB...");
+            int totalDownloaded = 0;
+
+            if (downloadMovies)
+            {
+                if (!config.SourceNowPlaying && !config.SourceUpcoming && !config.SourcePopular && !config.SourceTopRated)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No movie TMDB sources selected. Skipping movie trailers.");
+                }
+                else
+                {
+                    var progressEnd = downloadTvShows ? 50 : 95;
+                    totalDownloaded += await DownloadMoviesAsync(config, allowedLanguages, progress, 5, progressEnd, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+
+            if (downloadTvShows)
+            {
+                if (!config.SourceTvAiringToday && !config.SourceTvOnTheAir && !config.SourceTvPopular && !config.SourceTvTopRated)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No TV show TMDB sources selected. Skipping TV show trailers.");
+                }
+                else
+                {
+                    var progressStart = downloadMovies ? 50 : 5;
+                    totalDownloaded += await DownloadTvShowsAsync(config, allowedLanguages, progress, progressStart, 95, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Task complete. Downloaded {Count} trailer(s).", totalDownloaded);
+            progress.Report(100);
+        }
+
+        private async Task<int> DownloadMoviesAsync(
+            Configuration.PluginConfiguration config,
+            IReadOnlySet<string>? allowedLanguages,
+            IProgress<double> progress,
+            double progressStart,
+            double progressEnd,
+            CancellationToken cancellationToken)
+        {
+            var libraryTmdbIds = config.SkipMoviesInLibrary
+                ? GetLibraryMovieTmdbIds()
+                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} movies with TMDB IDs (will skip these)", libraryTmdbIds.Count);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching movie candidates from TMDB...");
            var candidates = await _tmdbService.GetCandidateMoviesAsync(config, cancellationToken).ConfigureAwait(false);
            _logger.LogInformation("|CinemaTrailers4Jellyfins| Found {Count} candidate movies across all sources", candidates.Count);

-            progress.Report(20);
-
            if (config.SkipMoviesInLibrary)
            {
                candidates = candidates
@@ -109,9 +151,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

            if (candidates.Count == 0)
            {
-                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new candidates to download. All done.");
-                progress.Report(100);
-                return;
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new movie candidates to download.");
+                return 0;
            }

            int downloaded = 0;
@@ -124,20 +165,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                if (downloaded >= config.MaxTrailersToDownload)
                    break;

-                double taskProgress = 20 + (80.0 * processed / candidates.Count);
+                double taskProgress = progressStart + (progressEnd - progressStart) * processed / candidates.Count;
                progress.Report(taskProgress);
                processed++;

-                var paths = BuildMoviePaths(movie.Title, movie.Year, config);
+                var paths = BuildMediaPaths(movie.Title, movie.Year, config);

-                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MovieFolder))
+                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MediaFolder))
                {
-                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MovieFolder);
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
                    continue;
                }

                var trailers = await _tmdbService.GetTrailersAsync(
-                    movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
+                    "movie", movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);

                if (trailers.Count == 0)
                {
@@ -163,24 +204,128 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                {
                    _logger.LogError(
                        "|CinemaTrailers4Jellyfins| Could not create the fake movie file for '{Movie}'. Removing incomplete folder {Folder}.",
-                        movie.Title, paths.MovieFolder);
-                    TryDeleteFolder(paths.MovieFolder);
+                        movie.Title, paths.MediaFolder);
+                    TryDeleteFolder(paths.MediaFolder);
                    continue;
                }

-                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year);
+                var metadata = await _tmdbService.GetMediaMetadataAsync(
+                    "movie", movie.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
+
+                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year, metadata.Genres, metadata.Certification);

                downloaded++;
                _logger.LogInformation(
                    "|CinemaTrailers4Jellyfins| [{Done}/{Max}] Saved trailer for '{Movie}' → {Path}",
-                    downloaded, config.MaxTrailersToDownload, movie.Title, paths.MovieFolder);
+                    downloaded, config.MaxTrailersToDownload, movie.Title, paths.MediaFolder);
            }

-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Task complete. Downloaded {Count} trailer(s).", downloaded);
-            progress.Report(100);
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Movie trailers complete. Downloaded {Count}.", downloaded);
+            return downloaded;
        }

-        private HashSet<string> GetLibraryTmdbIds()
+        private async Task<int> DownloadTvShowsAsync(
+            Configuration.PluginConfiguration config,
+            IReadOnlySet<string>? allowedLanguages,
+            IProgress<double> progress,
+            double progressStart,
+            double progressEnd,
+            CancellationToken cancellationToken)
+        {
+            var librarySeriesTmdbIds = config.SkipMoviesInLibrary
+                ? GetLibrarySeriesTmdbIds()
+                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} TV shows with TMDB IDs (will skip these)", librarySeriesTmdbIds.Count);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching TV show candidates from TMDB...");
+            var candidates = await _tmdbService.GetCandidateTvShowsAsync(config, cancellationToken).ConfigureAwait(false);
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Found {Count} candidate TV shows across all sources", candidates.Count);
+
+            if (config.SkipMoviesInLibrary)
+            {
+                candidates = candidates
+                    .Where(s => !librarySeriesTmdbIds.Contains(s.Id.ToString()))
+                    .ToList();
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| {Count} candidates remain after filtering library TV shows", candidates.Count);
+            }
+
+            if (candidates.Count == 0)
+            {
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new TV show candidates to download.");
+                return 0;
+            }
+
+            int downloaded = 0;
+            int processed = 0;
+
+            foreach (var show in candidates)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (downloaded >= config.MaxTvTrailersToDownload)
+                    break;
+
+                double taskProgress = progressStart + (progressEnd - progressStart) * processed / candidates.Count;
+                progress.Report(taskProgress);
+                processed++;
+
+                var paths = BuildMediaPaths(show.Title, show.Year, config);
+
+                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MediaFolder))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
+                    continue;
+                }
+
+                var trailers = await _tmdbService.GetTrailersAsync(
+                    "tv", show.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
+
+                if (trailers.Count == 0)
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| No YouTube trailers on TMDB for '{Title}'", show.Title);
+                    continue;
+                }
+
+                var trailer = trailers[0];
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Downloading '{Trailer}' for '{Show}'", trailer.Name, show.Title);
+
+                var success = await _downloadService.DownloadAsync(
+                    trailer.Key,
+                    paths.TrailerPath,
+                    config.PreferredVideoHeight,
+                    config.YtDlpPath,
+                    cancellationToken).ConfigureAwait(false);
+
+                if (!success)
+                    continue;
+
+                var fakeMovieReady = await _fakeMovieService.CopyFakeMovieAsync(paths.FakeMoviePath, cancellationToken).ConfigureAwait(false);
+                if (!fakeMovieReady)
+                {
+                    _logger.LogError(
+                        "|CinemaTrailers4Jellyfins| Could not create the fake movie file for '{Show}'. Removing incomplete folder {Folder}.",
+                        show.Title, paths.MediaFolder);
+                    TryDeleteFolder(paths.MediaFolder);
+                    continue;
+                }
+
+                var metadata = await _tmdbService.GetMediaMetadataAsync(
+                    "tv", show.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
+
+                _fakeMovieService.WriteNfo(paths.NfoPath, show.Title, show.Year, metadata.Genres, metadata.Certification, new[] { TrailerTags.TvShow });
+
+                downloaded++;
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| [{Done}/{Max}] Saved trailer for '{Show}' → {Path}",
+                    downloaded, config.MaxTvTrailersToDownload, show.Title, paths.MediaFolder);
+            }
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| TV show trailers complete. Downloaded {Count}.", downloaded);
+            return downloaded;
+        }
+
+        private HashSet<string> GetLibraryMovieTmdbIds()
        {
            var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

@@ -198,7 +343,25 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
            return ids;
        }

-        // Each trailer lives in its own "{Movie Title} ({Year})" folder alongside a fake
+        private HashSet<string> GetLibrarySeriesTmdbIds()
+        {
+            var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            var series = _libraryManager
+                .GetItemList(new InternalItemsQuery { IncludeItemTypes = new[] { BaseItemKind.Series }, Recursive = true })
+                .OfType<Series>();
+
+            foreach (var s in series)
+            {
+                var tmdbId = s.GetProviderId(MetadataProvider.Tmdb);
+                if (!string.IsNullOrEmpty(tmdbId))
+                    ids.Add(tmdbId);
+            }
+
+            return ids;
+        }
+
+        // Each trailer lives in its own "{Title} ({Year})" folder alongside a fake
        // movie file and NFO. Removing a trailer always means removing that whole folder.
        private void CleanupOldTrailers(Configuration.PluginConfiguration config)
        {
@@ -235,20 +398,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
            }
        }

-        private readonly record struct MoviePaths(string MovieFolder, string FakeMoviePath, string TrailerPath, string NfoPath);
+        private readonly record struct MediaPaths(string MediaFolder, string FakeMoviePath, string TrailerPath, string NfoPath);

-        private static MoviePaths BuildMoviePaths(string title, int? year, Configuration.PluginConfiguration config)
+        private static MediaPaths BuildMediaPaths(string title, int? year, Configuration.PluginConfiguration config)
        {
            var safeTitle = string.Concat(title.Split(Path.GetInvalidFileNameChars())).Trim();
            var folderName = year.HasValue ? $"{safeTitle} ({year.Value})" : safeTitle;

-            var movieFolder = Path.Combine(config.DownloadFolder, folderName);
+            var mediaFolder = Path.Combine(config.DownloadFolder, folderName);

-            return new MoviePaths(
-                MovieFolder: movieFolder,
-                FakeMoviePath: Path.Combine(movieFolder, $"{folderName}.mp4"),
-                TrailerPath: Path.Combine(movieFolder, $"{folderName}-trailer.mp4"),
-                NfoPath: Path.Combine(movieFolder, $"{folderName}.nfo"));
+            return new MediaPaths(
+                MediaFolder: mediaFolder,
+                FakeMoviePath: Path.Combine(mediaFolder, $"{folderName}.mp4"),
+                TrailerPath: Path.Combine(mediaFolder, $"{folderName}-trailer.mp4"),
+                NfoPath: Path.Combine(mediaFolder, $"{folderName}.nfo"));
        }
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FakeMovieService.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FakeMovieService.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Threading;
@@ -55,7 +56,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        /// Writes a minimal Jellyfin/Kodi-compatible movie NFO with &lt;lockdata&gt;true&lt;/lockdata&gt;
        /// so Jellyfin never tries to refresh metadata for the fake entry from TMDB.
        /// </summary>
-        public void WriteNfo(string nfoPath, string title, int? year)
+        public void WriteNfo(string nfoPath, string title, int? year, IReadOnlyList<string>? genres = null, string? mpaa = null, IReadOnlyList<string>? tags = null)
        {
            var settings = new XmlWriterSettings { Indent = true };
            using var writer = XmlWriter.Create(nfoPath, settings);
@@ -64,6 +65,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            writer.WriteElementString("title", title);
            if (year.HasValue)
                writer.WriteElementString("year", year.Value.ToString());
+            if (genres != null)
+                foreach (var genre in genres)
+                    writer.WriteElementString("genre", genre);
+            if (!string.IsNullOrWhiteSpace(mpaa))
+                writer.WriteElementString("mpaa", mpaa);
+            if (tags != null)
+                foreach (var tag in tags)
+                    writer.WriteElementString("tag", tag);
            writer.WriteElementString("lockdata", "true");
            writer.WriteEndElement();
            writer.WriteEndDocument();
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TmdbService.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TmdbService.cs
@@ -14,11 +14,13 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 {
    public record TmdbVideo(string Key, string Name, string Language, bool Official, int Size);

-    public record TmdbMovieResult(int Id, string Title, string ReleaseDate)
+    public record TmdbMediaResult(int Id, string Title, string ReleaseDate)
    {
        public int? Year => DateTime.TryParse(ReleaseDate, out var d) ? d.Year : (int?)null;
    }

+    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification);
+
    public class TmdbService : IDisposable
    {
        private readonly HttpClient _httpClient;
@@ -73,7 +75,39 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        /// Fetches candidate movies from the configured TMDB sources, optionally filtered
        /// by a minimum release date. Deduplicates across sources by TMDB ID.
        /// </summary>
-        public async Task<List<TmdbMovieResult>> GetCandidateMoviesAsync(
+        public Task<List<TmdbMediaResult>> GetCandidateMoviesAsync(
+            Configuration.PluginConfiguration config,
+            CancellationToken ct)
+        {
+            var sources = new List<string>();
+            if (config.SourceNowPlaying) sources.Add("now_playing");
+            if (config.SourceUpcoming)   sources.Add("upcoming");
+            if (config.SourcePopular)    sources.Add("popular");
+            if (config.SourceTopRated)   sources.Add("top_rated");
+
+            return GetCandidatesAsync("movie", sources, config, ct);
+        }
+
+        /// <summary>
+        /// Fetches candidate TV shows from the configured TMDB sources, optionally filtered
+        /// by a minimum first-air date. Deduplicates across sources by TMDB ID.
+        /// </summary>
+        public Task<List<TmdbMediaResult>> GetCandidateTvShowsAsync(
+            Configuration.PluginConfiguration config,
+            CancellationToken ct)
+        {
+            var sources = new List<string>();
+            if (config.SourceTvAiringToday) sources.Add("airing_today");
+            if (config.SourceTvOnTheAir)    sources.Add("on_the_air");
+            if (config.SourceTvPopular)     sources.Add("popular");
+            if (config.SourceTvTopRated)    sources.Add("top_rated");
+
+            return GetCandidatesAsync("tv", sources, config, ct);
+        }
+
+        private async Task<List<TmdbMediaResult>> GetCandidatesAsync(
+            string mediaType,
+            List<string> sourceEndpoints,
            Configuration.PluginConfiguration config,
            CancellationToken ct)
        {
@@ -82,36 +116,36 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                : null;

            var seen = new HashSet<int>();
-            var results = new List<TmdbMovieResult>();
+            var results = new List<TmdbMediaResult>();

-            async Task FetchSource(string endpoint)
+            foreach (var endpoint in sourceEndpoints)
            {
-                var movies = await FetchSourcePagesAsync(endpoint, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
+                var items = await FetchSourcePagesAsync(mediaType, endpoint, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
                    .ConfigureAwait(false);

-                foreach (var m in movies)
+                foreach (var item in items)
                {
-                    if (seen.Add(m.Id))
-                        results.Add(m);
+                    if (seen.Add(item.Id))
+                        results.Add(item);
                }
            }

-            if (config.SourceNowPlaying) await FetchSource("now_playing");
-            if (config.SourceUpcoming)   await FetchSource("upcoming");
-            if (config.SourcePopular)    await FetchSource("popular");
-            if (config.SourceTopRated)   await FetchSource("top_rated");
-
            return results;
        }

-        private async Task<List<TmdbMovieResult>> FetchSourcePagesAsync(
+        private async Task<List<TmdbMediaResult>> FetchSourcePagesAsync(
+            string mediaType,
            string endpoint,
            string apiKey,
            DateTime? releasedAfter,
            int maxPages,
            CancellationToken ct)
        {
-            var results = new List<TmdbMovieResult>();
+            var results = new List<TmdbMediaResult>();
+
+            // Movies use "title"/"release_date"; TV shows use "name"/"first_air_date".
+            var titleField = mediaType == "movie" ? "title" : "name";
+            var dateField = mediaType == "movie" ? "release_date" : "first_air_date";

            for (int page = 1; page <= maxPages; page++)
            {
@@ -119,7 +153,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services

                try
                {
-                    var url = $"{BaseUrl}/movie/{endpoint}?language=en-US&page={page}";
+                    var url = $"{BaseUrl}/{mediaType}/{endpoint}?language=en-US&page={page}";
                    using var request = new HttpRequestMessage(HttpMethod.Get, url);
                    ApplyAuth(request, apiKey);
                    using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -131,11 +165,11 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    int totalPages = doc.RootElement.GetProperty("total_pages").GetInt32();
                    bool anyInRange = false;

-                    foreach (var movie in pageResults.EnumerateArray())
+                    foreach (var entry in pageResults.EnumerateArray())
                    {
-                        var releaseDate = movie.TryGetProperty("release_date", out var rd) ? rd.GetString() ?? string.Empty : string.Empty;
-                        var title = movie.TryGetProperty("title", out var t) ? t.GetString() ?? string.Empty : string.Empty;
-                        var id = movie.GetProperty("id").GetInt32();
+                        var releaseDate = entry.TryGetProperty(dateField, out var rd) ? rd.GetString() ?? string.Empty : string.Empty;
+                        var title = entry.TryGetProperty(titleField, out var t) ? t.GetString() ?? string.Empty : string.Empty;
+                        var id = entry.GetProperty("id").GetInt32();

                        if (releasedAfter.HasValue && DateTime.TryParse(releaseDate, out var parsed))
                        {
@@ -143,7 +177,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                        }

                        anyInRange = true;
-                        results.Add(new TmdbMovieResult(id, title, releaseDate));
+                        results.Add(new TmdbMediaResult(id, title, releaseDate));
                    }

                    if (page >= totalPages || (releasedAfter.HasValue && !anyInRange))
@@ -155,7 +189,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                }
                catch (Exception ex)
                {
-                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{Endpoint}' page {Page}", endpoint, page);
+                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{MediaType}/{Endpoint}' page {Page}", mediaType, endpoint, page);
                    break;
                }
            }
@@ -187,7 +221,113 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            return null;
        }

+        /// <summary>
+        /// Returns the genre names and US certification for a movie or TV show
+        /// (e.g. PG-13 for movies, TV-14 for TV shows). Movies use a single
+        /// /movie/{id}?append_to_response=release_dates call; TV shows use
+        /// /tv/{id}?append_to_response=content_ratings.
+        /// </summary>
+        public async Task<TmdbMediaMetadata> GetMediaMetadataAsync(
+            string mediaType,
+            string tmdbId,
+            string apiKey,
+            CancellationToken ct)
+        {
+            try
+            {
+                var appendField = mediaType == "movie" ? "release_dates" : "content_ratings";
+                var url = $"{BaseUrl}/{mediaType}/{tmdbId}?append_to_response={appendField}&language=en-US";
+                using var request = new HttpRequestMessage(HttpMethod.Get, url);
+                ApplyAuth(request, apiKey);
+                using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
+                response.EnsureSuccessStatusCode();
+                var json = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
+                using var doc = JsonDocument.Parse(json);
+
+                var genres = new List<string>();
+                if (doc.RootElement.TryGetProperty("genres", out var genreArr))
+                {
+                    foreach (var g in genreArr.EnumerateArray())
+                    {
+                        if (g.TryGetProperty("name", out var name))
+                        {
+                            var genreName = name.GetString();
+                            if (!string.IsNullOrEmpty(genreName))
+                                genres.Add(genreName);
+                        }
+                    }
+                }
+
+                string? certification = mediaType == "movie"
+                    ? GetMovieCertification(doc)
+                    : GetTvCertification(doc);
+
+                return new TmdbMediaMetadata(genres.AsReadOnly(), certification);
+            }
+            catch (OperationCanceledException) { throw; }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetMediaMetadata failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
+                return new TmdbMediaMetadata(Array.Empty<string>(), null);
+            }
+        }
+
+        // Finds the US theatrical certification (G, PG, PG-13, R, NC-17) from release_dates.
+        private static string? GetMovieCertification(JsonDocument doc)
+        {
+            if (!doc.RootElement.TryGetProperty("release_dates", out var releaseDates)
+                || !releaseDates.TryGetProperty("results", out var rdResults))
+                return null;
+
+            foreach (var country in rdResults.EnumerateArray())
+            {
+                if (!country.TryGetProperty("iso_3166_1", out var iso)
+                    || !string.Equals(iso.GetString(), "US", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                if (!country.TryGetProperty("release_dates", out var dates))
+                    return null;
+
+                foreach (var date in dates.EnumerateArray())
+                {
+                    if (!date.TryGetProperty("certification", out var cert))
+                        continue;
+                    var certStr = cert.GetString();
+                    if (!string.IsNullOrWhiteSpace(certStr))
+                        return certStr;
+                }
+
+                return null;
+            }
+
+            return null;
+        }
+
+        // Finds the US TV content rating (TV-Y, TV-PG, TV-14, TV-MA, etc.) from content_ratings.
+        private static string? GetTvCertification(JsonDocument doc)
+        {
+            if (!doc.RootElement.TryGetProperty("content_ratings", out var contentRatings)
+                || !contentRatings.TryGetProperty("results", out var crResults))
+                return null;
+
+            foreach (var country in crResults.EnumerateArray())
+            {
+                if (!country.TryGetProperty("iso_3166_1", out var iso)
+                    || !string.Equals(iso.GetString(), "US", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                if (!country.TryGetProperty("rating", out var rating))
+                    return null;
+
+                var ratingStr = rating.GetString();
+                return string.IsNullOrWhiteSpace(ratingStr) ? null : ratingStr;
+            }
+
+            return null;
+        }
+
        public async Task<List<TmdbVideo>> GetTrailersAsync(
+            string mediaType,
            string tmdbId,
            string apiKey,
            IReadOnlySet<string>? allowedLanguages,
@@ -197,7 +337,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            {
                // No language filter on the URL — we want all available trailers so we can
                // filter by iso_639_1 ourselves based on the user's language preference.
-                var url = $"{BaseUrl}/movie/{tmdbId}/videos";
+                var url = $"{BaseUrl}/{mediaType}/{tmdbId}/videos";
                using var request = new HttpRequestMessage(HttpMethod.Get, url);
                ApplyAuth(request, apiKey);
                using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -238,7 +378,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            catch (OperationCanceledException) { throw; }
            catch (Exception ex)
            {
-                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetTrailers failed for TMDB ID {Id}", tmdbId);
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetTrailers failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
                return new List<TmdbVideo>();
            }
        }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -7,6 +8,7 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using Microsoft.Extensions.Logging;

@@ -15,6 +17,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
    public class TrailerIntroProvider : IIntroProvider
    {
        private static readonly Random _rng = new();
+
+        // Per-user set of trailer IDs already shown in the current cycle.
+        // Resets automatically once every trailer in the active pool has been seen.
+        private static readonly ConcurrentDictionary<Guid, HashSet<Guid>> _seenByUser = new();
+        private static readonly object _seenLock = new();
+
+        // Per-user date of the last episode that received trailers, so only the
+        // first episode a user watches each day gets them.
+        private static readonly ConcurrentDictionary<Guid, DateTime> _lastEpisodeTrailerDateByUser = new();
+
        private readonly ILibraryManager _libraryManager;
        private readonly ILogger<TrailerIntroProvider> _logger;

@@ -32,23 +44,45 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            if (config == null || config.TrailersPerMovie <= 0)
                return Task.FromResult(Enumerable.Empty<IntroInfo>());

-            if (item is not Movie)
-                return Task.FromResult(Enumerable.Empty<IntroInfo>());
+            // The item used for genre/rating filtering. For episodes this is the
+            // parent series, since episodes rarely carry their own genre metadata.
+            BaseItem feature;
+            bool isEpisode;
+
+            switch (item)
+            {
+                case Movie:
+                    feature = item;
+                    isEpisode = false;
+                    break;
+
+                case Episode episode:
+                    if (!config.TrailersForEpisodes)
+                        return Task.FromResult(Enumerable.Empty<IntroInfo>());
+
+                    if (!IsFirstEpisodeOfDay(user.Id))
+                        return Task.FromResult(Enumerable.Empty<IntroInfo>());
+
+                    feature = episode.Series ?? (BaseItem)episode;
+                    isEpisode = true;
+                    break;
+
+                default:
+                    return Task.FromResult(Enumerable.Empty<IntroInfo>());
+            }

            var outputFolder = config.DownloadFolder?.TrimEnd(
                Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
            if (string.IsNullOrEmpty(outputFolder))
                return Task.FromResult(Enumerable.Empty<IntroInfo>());

-            // Break potential recursion: don't inject intros before items that live inside
-            // our output folder. This covers both the fake-movie files and their trailer
-            // extras, so Wholphin can't trigger a getIntros loop on the intro item itself.
+            // Break recursion: don't inject intros before items from our own output folder
+            // (covers both the fake-movie files and their trailer extras).
            if (item.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true)
                return Task.FromResult(Enumerable.Empty<IntroInfo>());

-            // Server-scoped query (no User parameter) so library visibility settings don't
-            // prevent trailer discovery even when the output library is hidden from users.
-            var fakeMovies = _libraryManager
+            // Server-scoped query so hidden libraries don't block trailer discovery.
+            var pairs = _libraryManager
                .GetItemList(new InternalItemsQuery
                {
                    IncludeItemTypes = new[] { BaseItemKind.Movie },
@@ -57,29 +91,134 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                .OfType<Movie>()
                .Where(m =>
                    m.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true
-                    && m.LocalTrailers.Count > 0)
+                    && m.LocalTrailers.Count > 0
+                    // Keep TV show trailers for episodes and movie trailers for movies separate.
+                    && m.Tags.Contains(TrailerTags.TvShow, StringComparer.OrdinalIgnoreCase) == isEpisode)
+                .SelectMany(m => m.LocalTrailers.Select(t => (Movie: m, Trailer: t)))
                .ToList();

-            if (fakeMovies.Count == 0)
+            if (pairs.Count == 0)
            {
                _logger.LogDebug(
-                    "|CinemaTrailers4Jellyfins| No indexed trailers found in {Folder}. "
+                    "|CinemaTrailers4Jellyfins| No indexed {Kind} trailers in {Folder}. "
                    + "Ensure the output folder is added as a Jellyfin Movies library and scanned.",
+                    isEpisode ? "TV show" : "movie",
                    outputFolder);
                return Task.FromResult(Enumerable.Empty<IntroInfo>());
            }

-            var selected = fakeMovies
+            // Apply enabled filters. If nothing survives, fall back to the full pool.
+            var filtered = ApplyFilters(pairs, feature, config);
+            var pool = filtered.Count > 0 ? filtered : pairs;
+
+            // Prefer unseen trailers within the pool; reset the cycle when all have been shown.
+            pool = ApplyAvoidRepeats(pool, user.Id, config.AvoidRepeats);
+
+            var selected = pool
                .OrderBy(_ => _rng.Next())
                .Take(config.TrailersPerMovie)
-                .Select(m =>
-                {
-                    var t = m.LocalTrailers.ElementAt(_rng.Next(m.LocalTrailers.Count));
-                    return new IntroInfo { ItemId = t.Id, Path = t.Path };
-                })
                .ToList();

-            return Task.FromResult<IEnumerable<IntroInfo>>(selected);
+            if (config.AvoidRepeats)
+                MarkSeen(user.Id, selected.Select(p => p.Trailer.Id));
+
+            var intros = selected.Select(p => new IntroInfo { ItemId = p.Trailer.Id, Path = p.Trailer.Path });
+            return Task.FromResult<IEnumerable<IntroInfo>>(intros.ToList());
+        }
+
+        private static List<(Movie Movie, BaseItem Trailer)> ApplyFilters(
+            List<(Movie Movie, BaseItem Trailer)> pairs,
+            BaseItem feature,
+            Configuration.PluginConfiguration config)
+        {
+            var result = pairs;
+
+            if (config.FilterByGenre && feature.Genres.Length > 0)
+            {
+                var featureGenres = new HashSet<string>(feature.Genres, StringComparer.OrdinalIgnoreCase);
+                result = result
+                    .Where(p => p.Movie.Genres.Any(g => featureGenres.Contains(g)))
+                    .ToList();
+            }
+
+            if (config.FilterByRating)
+            {
+                result = result
+                    .Where(p =>
+                        // Unrated trailer: no restriction — include it.
+                        p.Movie.InheritedParentalRatingValue == null
+                        // Unrated feature: can't determine a ceiling — include everything.
+                        || feature.InheritedParentalRatingValue == null
+                        // Trailer rating must be at most the feature's rating.
+                        || p.Movie.InheritedParentalRatingValue <= feature.InheritedParentalRatingValue)
+                    .ToList();
+            }
+
+            return result;
+        }
+
+        private static List<(Movie Movie, BaseItem Trailer)> ApplyAvoidRepeats(
+            List<(Movie Movie, BaseItem Trailer)> pool,
+            Guid userId,
+            bool enabled)
+        {
+            if (!enabled)
+                return pool;
+
+            lock (_seenLock)
+            {
+                var seen = _seenByUser.GetOrAdd(userId, _ => new HashSet<Guid>());
+                var unseen = pool.Where(p => !seen.Contains(p.Trailer.Id)).ToList();
+
+                if (unseen.Count > 0)
+                    return unseen;
+
+                // All trailers in this pool have been seen — reset the cycle.
+                foreach (var p in pool)
+                    seen.Remove(p.Trailer.Id);
+
+                return pool.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Returns true (and records today's date) only the first time this is called
+        /// for a given user on a given day.
+        /// </summary>
+        private static bool IsFirstEpisodeOfDay(Guid userId)
+        {
+            var today = DateTime.Now.Date;
+            var isFirst = false;
+
+            _lastEpisodeTrailerDateByUser.AddOrUpdate(
+                userId,
+                _ =>
+                {
+                    isFirst = true;
+                    return today;
+                },
+                (_, lastDate) =>
+                {
+                    if (lastDate < today)
+                    {
+                        isFirst = true;
+                        return today;
+                    }
+
+                    return lastDate;
+                });
+
+            return isFirst;
+        }
+
+        private static void MarkSeen(Guid userId, IEnumerable<Guid> trailerIds)
+        {
+            lock (_seenLock)
+            {
+                var seen = _seenByUser.GetOrAdd(userId, _ => new HashSet<Guid>());
+                foreach (var id in trailerIds)
+                    seen.Add(id);
+            }
        }
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs
@@ -0,0 +1,12 @@
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
+{
+    /// <summary>
+    /// Tags written into each downloaded trailer's NFO so <see cref="TrailerIntroProvider"/>
+    /// can tell movie trailers and TV show trailers apart within the shared output folder.
+    /// </summary>
+    public static class TrailerTags
+    {
+        /// <summary>Marks a fake-movie folder as containing a TV show trailer.</summary>
+        public const string TvShow = "ct4j-tvshow";
+    }
+}
--- a/build.yaml
+++ b/build.yaml
@@ -1,5 +1,5 @@
 ---
-version: 1.0.0.2
+version: 1.0.0.4
 name: CinemaTrailers4Jellyfins
 guid: b581493e-1046-40ed-b6dc-cb8027624984
 description: >
@@ -12,10 +12,15 @@ category: General
 owner: 514mart
 targetAbi: 10.11.0.0
 changelog:
-  - Add IIntroProvider support — downloaded trailers now play as pre-rolls before
-    movies in Jellyfin clients with cinema mode (Wholphin, etc.); configurable
-    trailers-per-movie count; recursion-safe so the intro items themselves never
-    trigger a second round of intro injection
+  - Add TV show trailer downloads — separate TMDB sources (Airing Today, On The Air,
+    Popular, Top Rated) and a "Max TV show trailers per run" cap independent from
+    movies; set either cap to 0 to skip that category entirely
+  - Add trailers before TV episodes via IIntroProvider — only the first episode a
+    user watches each day gets trailers, picked using the show's genre/rating for
+    filtering
+  - Movie and TV trailers are now kept separate — movies only ever get movie
+    trailers and episodes only ever get TV show trailers, via a tag written to each
+    trailer's NFO at download time

 dotnetProjects:
  - name: Jellyfin.Plugin.CinemaTrailers4Jellyfins
--- a/manifest.json
+++ b/manifest.json
@@ -8,6 +8,22 @@
        "owner": "514mart",
        "imageUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/raw/branch/main/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Images/logo.svg",
        "versions": [
+            {
+                "checksum": "d43b8d007051d04984d9395d29bc306f",
+                "changelog": "- Add trailer selection filters \u2014 genre match, age rating ceiling, and avoid-repeats cycle; genre and rating are written to each fake-movie NFO at download time from TMDB so Jellyfin can use them for filtering; filters fall back to random when no match is found\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.3/cinematrailers4jellyfins_1.0.0.3.zip",
+                "timestamp": "2026-06-09T21:16:16Z",
+                "version": "1.0.0.3"
+            },
+            {
+                "checksum": "0259ff74b5e12089c45b8823d6ff6a19",
+                "changelog": "- Add IIntroProvider support \u2014 downloaded trailers now play as pre-rolls before movies in Jellyfin clients with cinema mode (Wholphin, etc.); configurable trailers-per-movie count; recursion-safe so the intro items themselves never trigger a second round of intro injection\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.2/cinematrailers4jellyfins_1.0.0.2.zip",
+                "timestamp": "2026-06-09T17:44:48Z",
+                "version": "1.0.0.2"
+            },
            {
                "checksum": "70edda53c848d5481223dda7afc763c2",
                "changelog": "- Initial release based on Trailers4Jellyfin \u2014 TMDB/YouTube trailer downloads, scheduled task, language/date filters, and trailer rotation, repackaged so each trailer ships inside its own fake-movie folder (placeholder video + locked NFO + trailer) for use with a Cinema Mode pre-roll plugin\n",
Author	SHA1	Message	Date
Martin	f49c32f181	feat: add TV show trailer downloads, episode trailers, and movie/TV trailer separation All checks were successful Publish Release / release (push) Successful in 23s Details - Download trailers for TV shows from TMDB with separate sources and an independent max-count cap (0 disables a category) - Play trailers before TV episodes via IIntroProvider, limited to the first episode a user watches each day - Tag TV show trailers in their NFO so movies only get movie trailers and episodes only get TV show trailers Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-10 00:41:37 -04:00
gitea-actions	f769e33b8d	chore: update manifest.json for v1.0.0.3	2026-06-09 21:16:16 +00:00
Martin	83966f40ea	feat: add genre, rating, and avoid-repeats trailer filters All checks were successful Publish Release / release (push) Successful in 23s Details Trailer selection now supports three optional filters: - Genre match: prefer trailers whose fake-movie genre overlaps with the feature being played (requires TMDB genres in NFO) - Age rating ceiling: exclude trailers rated higher than the feature (requires TMDB certification in NFO) - Avoid repeats: cycle through all trailers before replaying any; resets per-user once the pool is exhausted Genre and certification are fetched from TMDB at download time via a single /movie/{id}?append_to_response=release_dates call and written into the fake-movie NFO as <genre> and <mpaa> tags. All filters fall back to the full unfiltered pool when no match is found. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-09 17:15:38 -04:00
gitea-actions	6772bde3b4	chore: update manifest.json for v1.0.0.2	2026-06-09 17:44:48 +00:00