TrailerTask.cs

using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Tasks;
using Microsoft.Extensions.Logging;
using System.Text.RegularExpressions;
using System.Text.Json;
using System.Text.Json.Nodes;
using Jellyfin.Data.Enums;

namespace TrailerFinPlugin
{
    public class TrailerTask : IScheduledTask
    {
        private readonly ILibraryManager _libraryManager;
        private readonly ILogger<TrailerTask> _logger;
        private readonly HttpClient _httpClient;
        private readonly MediaBrowser.Controller.MediaEncoding.IMediaEncoder _mediaEncoder;
        private const string LogPath = @"C:\Users\pinae\Documents\TrailerFin_Log.txt";

        private void LogToFile(string message)
        {
            try
            {
                File.AppendAllText(LogPath, $"{DateTime.Now}: {message}{Environment.NewLine}");
            }
            catch { /* Ignore logging errors */ }
        }

        public string Name => "Scan IMDb Trailers";
        public string Key => "TrailerFinScan";
        public string Description => "Scrapes IMDb for trailers and downloads trailer.mp4 via FFmpeg.";
        public string Category => "Library";

        public TrailerTask(ILibraryManager libraryManager, ILogger<TrailerTask> logger, MediaBrowser.Controller.MediaEncoding.IMediaEncoder mediaEncoder)
        {
            _libraryManager = libraryManager;
            _logger = logger;
            _mediaEncoder = mediaEncoder;
            _httpClient = new HttpClient();
            _httpClient.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)");
            _httpClient.DefaultRequestHeaders.Add("Accept-Language", "en-US,en;q=0.9");
        }

        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
        {
            return Enumerable.Empty<TaskTriggerInfo>();
        }

        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
        {
            try
            {
                LogToFile("Starting TrailerFin Download Task...");
                var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
                {
                    IncludeItemTypes = new[] { BaseItemKind.Movie },
                    Recursive = true
                });

                if (itemIds == null || itemIds.Count == 0)
                {
                    LogToFile("No movies found.");
                    return;
                }

                var total = itemIds.Count;
                var current = 0;

                foreach (var id in itemIds)
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        LogToFile("Scan cancelled.");
                        return;
                    }

                    var item = _libraryManager.GetItemById(id);
                    if (item is Movie movie)
                    {
                        if (movie.ProviderIds.TryGetValue("Imdb", out var imdbId) && !string.IsNullOrEmpty(imdbId))
                        {
                            await ProcessMovie(movie, imdbId);
                        }
                    }

                    current++;
                    progress.Report((double)current / total * 100);
                }
                LogToFile("TrailerFin Download Completed.");
            }
            catch (Exception ex)
            {
                LogToFile($"CRITICAL ERROR: {ex}");
                _logger.LogError(ex, "Critical error in TrailerFin task.");
            }
        }

        private async Task ProcessMovie(Movie movie, string imdbId)
        {
            try
            {
                var folderPath = movie.ContainingFolderPath;
                if (string.IsNullOrEmpty(folderPath)) return;

                // Standard Jellyfin local trailer naming
                var trailerPath = Path.Combine(folderPath, "trailer.mp4");

                // Skip if exists
                if (File.Exists(trailerPath)) return;

                LogToFile($"Downloading trailer for {movie.Name} [{imdbId}]");
                
                var videoUrl = await GetImdbVideoUrl(imdbId);
                if (string.IsNullOrEmpty(videoUrl))
                {
                    LogToFile($"No trailer URL found for {movie.Name}");
                    return;
                }

                await DownloadTrailer(videoUrl, trailerPath);
            }
            catch (Exception ex)
            {
                LogToFile($"Error processing {movie.Name}: {ex.Message}");
            }
        }

        private async Task DownloadTrailer(string url, string outputPath)
        {
            try
            {
                var ffmpegPath = _mediaEncoder.EncoderPath;
                if (string.IsNullOrEmpty(ffmpegPath))
                {
                    LogToFile("FFmpeg path not found!");
                    return;
                }

                var args = $"-i \"{url}\" -c copy -y \"{outputPath}\"";
                
                var process = new System.Diagnostics.Process
                {
                    StartInfo = new System.Diagnostics.ProcessStartInfo
                    {
                        FileName = ffmpegPath,
                        Arguments = args,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        UseShellExecute = false,
                        CreateNoWindow = true
                    }
                };

                process.Start();
                // Wait for exit with timeout (e.g. 5 minutes per trailer)
                await process.WaitForExitAsync().WaitAsync(TimeSpan.FromMinutes(5));
                
                if (process.ExitCode != 0)
                {
                    LogToFile($"FFmpeg failed with exit code {process.ExitCode}");
                    // Clean up failed file
                    if (File.Exists(outputPath)) File.Delete(outputPath);
                }
                else
                {
                    LogToFile($"Successfully downloaded to {outputPath}");
                }
            }
            catch (Exception ex)
            {
                LogToFile($"Download failed: {ex.Message}");
            }
        }

        private bool IsExpired(string url)
        {
            // Simple check for 'Expires' query param usually found in IMDb video links
            var match = Regex.Match(url, @"Expires=(\d+)");
            if (match.Success && long.TryParse(match.Groups[1].Value, out long expireTime))
            {
                 var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
                 return now >= expireTime;
            }
            return true; 
        }

        private async Task<string?> GetImdbVideoUrl(string imdbId)
        {
            try 
            {
                var galleryUrl = $"https://www.imdb.com/title/{imdbId}/videogallery/?sort=date,desc";
                var html = await _httpClient.GetStringAsync(galleryUrl);
                
                var linkMatch = Regex.Match(html, @"/video/vi\d+");
                if (!linkMatch.Success) return null;

                var videoPageUrl = $"https://www.imdb.com{linkMatch.Value}";
                var videoHtml = await _httpClient.GetStringAsync(videoPageUrl);

                var jsonMatch = Regex.Match(videoHtml, @"<script id=""__NEXT_DATA__"" type=""application/json"">(.*?)</script>");
                if (!jsonMatch.Success) return null;

                var json = jsonMatch.Groups[1].Value;
                using var doc = JsonDocument.Parse(json);
                var root = doc.RootElement;
                
                if (root.TryGetProperty("props", out var props) && 
                    props.TryGetProperty("pageProps", out var pageProps) &&
                    pageProps.TryGetProperty("videoPlaybackData", out var playbackData) &&
                    playbackData.TryGetProperty("video", out var video) &&
                    video.TryGetProperty("playbackURLs", out var urls))
                {
                    foreach (var urlItem in urls.EnumerateArray())
                    {
                        if (urlItem.GetProperty("videoMimeType").GetString() == "MP4")
                        {
                            return urlItem.GetProperty("url").GetString();
                        }
                    }
                }
            }
            catch 
            { 
                return null; 
            }
            return null;
        }
    }
}