Initial commit: CinemaTrailers4Jellyfins plugin

Adapted from Trailers4Jellyfin: keeps TMDB/YouTube trailer downloading,
the scheduled task, language/source/date filters, and trailer rotation,
but drops cinema-mode/IIntroProvider entirely. Each trailer now ships in
its own fake-movie folder (placeholder video + locked NFO + trailer) for
use with a Cinema Mode / trailer pre-roll plugin.

Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
+{
+    public class DownloadTrailersTask : IScheduledTask
+    {
+        private readonly ILogger<DownloadTrailersTask> _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly TmdbService _tmdbService;
+        private readonly TrailerDownloadService _downloadService;
+        private readonly FakeMovieService _fakeMovieService;
+
+        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 Category => "CinemaTrailers4Jellyfins";
+
+        public DownloadTrailersTask(
+            ILogger<DownloadTrailersTask> logger,
+            ILibraryManager libraryManager,
+            TmdbService tmdbService,
+            TrailerDownloadService downloadService,
+            FakeMovieService fakeMovieService)
+        {
+            _logger = logger;
+            _libraryManager = libraryManager;
+            _tmdbService = tmdbService;
+            _downloadService = downloadService;
+            _fakeMovieService = fakeMovieService;
+        }
+
+        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+        {
+            yield return new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfoType.IntervalTrigger,
+                IntervalTicks = TimeSpan.FromHours(24).Ticks,
+            };
+        }
+
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var config = Plugin.Instance.Configuration;
+
+            if (string.IsNullOrWhiteSpace(config.TmdbApiKey))
+            {
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| No TMDB API key configured. Skipping task.");
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(config.DownloadFolder))
+            {
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| No output folder configured. Skipping task.");
+                return;
+            }
+
+            if (!config.SourceNowPlaying && !config.SourceUpcoming && !config.SourcePopular && !config.SourceTopRated)
+            {
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| No TMDB sources selected. Enable at least one source. Skipping task.");
+                return;
+            }
+
+            Directory.CreateDirectory(config.DownloadFolder);
+
+            CleanupOldTrailers(config);
+
+            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...");
+            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
+                    .Where(m => !libraryTmdbIds.Contains(m.Id.ToString()))
+                    .ToList();
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| {Count} candidates remain after filtering library movies", candidates.Count);
+            }
+
+            if (candidates.Count == 0)
+            {
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new candidates to download. All done.");
+                progress.Report(100);
+                return;
+            }
+
+            int downloaded = 0;
+            int processed = 0;
+
+            foreach (var movie in candidates)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (downloaded >= config.MaxTrailersToDownload)
+                    break;
+
+                double taskProgress = 20 + (80.0 * processed / candidates.Count);
+                progress.Report(taskProgress);
+                processed++;
+
+                var paths = BuildMoviePaths(movie.Title, movie.Year, config);
+
+                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MovieFolder))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MovieFolder);
+                    continue;
+                }
+
+                var trailers = await _tmdbService.GetTrailersAsync(
+                    movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
+
+                if (trailers.Count == 0)
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| No YouTube trailers on TMDB for '{Title}'", movie.Title);
+                    continue;
+                }
+
+                var trailer = trailers[0];
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Downloading '{Trailer}' for '{Movie}'", trailer.Name, movie.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 '{Movie}'. Removing incomplete folder {Folder}.",
+                        movie.Title, paths.MovieFolder);
+                    TryDeleteFolder(paths.MovieFolder);
+                    continue;
+                }
+
+                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year);
+
+                downloaded++;
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| [{Done}/{Max}] Saved trailer for '{Movie}' → {Path}",
+                    downloaded, config.MaxTrailersToDownload, movie.Title, paths.MovieFolder);
+            }
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Task complete. Downloaded {Count} trailer(s).", downloaded);
+            progress.Report(100);
+        }
+
+        private HashSet<string> GetLibraryTmdbIds()
+        {
+            var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            var movies = _libraryManager
+                .GetItemList(new InternalItemsQuery { IncludeItemTypes = new[] { BaseItemKind.Movie }, Recursive = true })
+                .OfType<Movie>();
+
+            foreach (var movie in movies)
+            {
+                var tmdbId = movie.GetProviderId(MetadataProvider.Tmdb);
+                if (!string.IsNullOrEmpty(tmdbId))
+                    ids.Add(tmdbId);
+            }
+
+            return ids;
+        }
+
+        // Each trailer lives in its own "{Movie 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)
+        {
+            if (config.MaxTotalTrailers <= 0)
+                return;
+
+            var folders = Directory.GetDirectories(config.DownloadFolder)
+                .Select(f => new DirectoryInfo(f))
+                .OrderBy(d => d.CreationTimeUtc)
+                .ToList();
+
+            if (folders.Count <= config.MaxTotalTrailers)
+                return;
+
+            var toDelete = folders.Take(folders.Count - config.MaxTotalTrailers);
+
+            foreach (var folder in toDelete)
+            {
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Deleting oldest trailer to stay under cap: {Folder}", folder.Name);
+                TryDeleteFolder(folder.FullName);
+            }
+        }
+
+        private void TryDeleteFolder(string folderPath)
+        {
+            try
+            {
+                if (Directory.Exists(folderPath))
+                    Directory.Delete(folderPath, recursive: true);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to delete folder {Folder}", folderPath);
+            }
+        }
+
+        private readonly record struct MoviePaths(string MovieFolder, string FakeMoviePath, string TrailerPath, string NfoPath);
+
+        private static MoviePaths BuildMoviePaths(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);
+
+            return new MoviePaths(
+                MovieFolder: movieFolder,
+                FakeMoviePath: Path.Combine(movieFolder, $"{folderName}.mp4"),
+                TrailerPath: Path.Combine(movieFolder, $"{folderName}-trailer.mp4"),
+                NfoPath: Path.Combine(movieFolder, $"{folderName}.nfo"));
+        }
+    }
+}