Plugin.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Reflection;
using System.Runtime.Loader;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using InfiniteDrive.Data;
using InfiniteDrive.Logging;
using InfiniteDrive.Models;
using InfiniteDrive.Services;
using InfiniteDrive.Repositories.Interfaces;
using InfiniteDrive.Repositories;
using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Plugins;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Drawing;
using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Plugins;
using MediaBrowser.Model.Plugins.UI;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Users;
using Microsoft.Extensions.Logging;

[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("InfiniteDrive.Tests")]

namespace InfiniteDrive
{
    /// <summary>
    /// InfiniteDrive plugin entry point.
    /// Inherits <see cref="BasePlugin{TConfiguration}"/> which handles XML config
    /// persistence at {DataPath}/plugins/configurations/InfiniteDrive.xml.
    /// </summary>
    public class Plugin : BasePlugin<PluginConfiguration>, IHasUIPages, IHasWebPages, IHasThumbImage
    {
        /// <summary>Stable plugin GUID — never change this after first release.</summary>
        public static readonly Guid PluginGuid = new Guid("3c45a87e-2b4f-4d1a-9e73-8f12c3456789");

        /// <summary>
        /// Singleton accessor used by scheduled tasks and services to reach
        /// shared plugin state (DatabaseManager, configuration, logger).
        /// </summary>
        public static Plugin Instance { get; private set; } = null!;

        private readonly ILogger<Plugin> _logger;
        private readonly ILogManager _logManager;
        private readonly IApplicationPaths _appPaths;
        /// <summary>
        /// Shared logger for use by auto-discovered providers (e.g. AioMetadataProvider).
        /// </summary>
        public ILogger<Plugin> Logger => _logger;

        /// <summary>
        /// Global synchronization lock for catalog-mutating operations.
        /// Ensures only one catalog sync or Marvin task runs at a time.
        /// (Sprint 100A-10)
        /// </summary>
        public static readonly System.Threading.SemaphoreSlim SyncLock =
            new System.Threading.SemaphoreSlim(1, 1);

        /// <summary>
        /// Shared progress streamer for SSE events.
        /// Singleton accessible via Plugin.Instance.ProgressStreamer.
        /// </summary>
        public static ProgressStreamer ProgressStreamer = new();

        /// <summary>
        /// Manifest state container — single authority for status, fetched timestamp, staleness.
        /// Sprint 360: replaces scattered statics + static methods.
        /// </summary>
        public static ManifestState Manifest { get; } = new();

        /// <summary>
        /// Pipeline phase tracker — shared operational picture for admin UI + diagnostics.
        /// Sprint 361: In-memory snapshot, no DB writes.
        /// </summary>
        public static PipelinePhaseTracker Pipeline { get; } = new();

        /// <summary>
        /// Shared database manager.  Initialised during plugin construction so it
        /// is ready before any scheduled task or service is invoked.
        /// </summary>
        public DatabaseManager DatabaseManager { get; private set; } = null!;

        /// <summary>
        /// Candidate normalizer — parses raw AIOStreams streams into normalized candidates (Sprint 122).
        /// </summary>
        public Services.CandidateNormalizer CandidateNormalizer { get; private set; } = null!;

        /// <summary>
        /// Catalog repository for catalog item operations (Sprint 104D-02).
        /// <summary>
        /// StrmWriterService — unified .strm file writer.
        /// All .strm writes go through this singleton (Sprint 156).
        /// </summary>
        public Services.StrmWriterService StrmWriterService { get; private set; } = null!;

        /// <summary>
        /// StrmFileManager — multi-version .strm file I/O for pre-written CDN URLs.
        /// </summary>
        public Services.StrmFileManager StrmFileManager { get; private set; } = null!;

        /// <summary>
        /// Resolution cache repository interface for stream URL caching.
        /// Delegates to DatabaseManager (Sprint 104A-04).
        /// </summary>
        public IResolutionCacheRepository ResolutionCacheRepository => DatabaseManager;

        /// <summary>
        /// Cooldown gate for HTTP throttling. Replaces scattered Task.Delay(ApiCallDelayMs).
        /// Initialised during <see cref="InfiniteDriveInitializationService.Run"/>.
        /// </summary>
        public Services.CooldownGate CooldownGate { get; internal set; } = null!;

        /// <summary>
        /// Stream probe service for checking stream availability before serving to users (Sprint 159).
        /// </summary>
        public Services.StreamProbeService StreamProbeService { get; private set; } = null!;

        /// <summary>
        /// ID resolver service for normalising manifest IDs to canonical provider IDs (Sprint 160).
        /// Calls source addon /meta endpoint, then AIOMetadata as fallback.
        /// </summary>
        public Services.IdResolverService IdResolverService { get; private set; } = null!;

        /// <summary>
        /// Certification resolver for fetching MPAA/TV ratings from TMDB (Sprint 209).
        /// Used for parental filtering in Discover browse/search.
        /// </summary>
        public Services.CertificationResolver CertificationResolver { get; private set; } = null!;

        /// <summary>
        /// Shared resolver health tracker with circuit breaker (Sprint 310).
        /// Singleton shared across ResolverService, StreamResolutionHelper, etc.
        /// </summary>
        public Services.ResolverHealthTracker ResolverHealthTracker { get; private set; } = null!;

        /// <summary>
        /// Stream pre-cache service for the cached_streams table.
        /// Singleton shared across AioMediaSourceProvider.
        /// </summary>
        public Services.IStreamCacheService StreamCacheService { get; private set; } = null!;

        /// <summary>Block list management (DB-only, no SDK deps).</summary>
        public Services.BlockListService BlockListService { get; private set; } = null!;

        /// <summary>Playlist management (requires IPlaylistManager, set via InitializePlaylistService).</summary>
        public Services.PlaylistService? PlaylistService { get; private set; }

        /// <summary>BoxSet management for collection sync (requires ICollectionManager).</summary>
        public Services.BoxSetService? BoxSetService { get; private set; }

        /// <summary>Unified add pipeline (requires ILibraryManager, set via InitializePlaylistService).</summary>
        public Services.UnifiedItemService? UnifiedItemService { get; private set; }

        /// <summary>ILibraryManager reference for triggering tasks from UI.</summary>
        public ILibraryManager? LibraryManager { get; private set; }

        /// <summary>Emby user manager (set via InitializePlaylistService). Used for per-user playlist creation and ever-watched prune checks.</summary>
        public MediaBrowser.Controller.Library.IUserManager? UserManager { get; private set; }

        /// <summary>ILogManager reference for triggering tasks from UI.</summary>
        public ILogManager LogManager => _logManager;

        /// <summary>ILocalizationManager for language/country dropdowns from Emby.</summary>
        public ILocalizationManager? LocalizationManager { get; internal set; }

        /// <summary>Library provisioning service (creates Emby libraries from config paths).</summary>
        public Services.LibraryProvisioningService? LibraryProvisioningService { get; private set; }

        /// <summary>
        /// Active provider state for self-healing failover (Sprint 311).
        /// Tracks whether primary or secondary provider is currently active.
        /// </summary>
        public Models.ActiveProviderState ActiveProviderState { get; private set; } = new();

        /// <summary>
        /// Centralized state engine for system health evaluation (Sprint 401).
        /// Initialized during InitialiseDatabaseManager().
        /// </summary>
        public Services.SystemStateService SystemStateService { get; private set; } = null!;

        /// <summary>IProviderManager for targeted metadata refresh (replaces full library scan).</summary>
        public IProviderManager? ProviderManager { get; internal set; }

        /// <summary>IFileSystem for constructing MetadataRefreshOptions.</summary>
        public IFileSystem? FileSystem { get; internal set; }

        /// <summary>
        /// Plugin constructor — lightweight only per Emby conventions.
        /// Heavy initialization (database, repositories, PluginSecret) is deferred to
        /// InfiniteDriveInitializationService.Run() via IServerEntryPoint.
        /// </summary>
        public Plugin(
            IApplicationPaths appPaths,
            IXmlSerializer xmlSerializer,
            ILogManager logManager)
            : base(appPaths, xmlSerializer)
        {
            Instance = this;
            _appPaths = appPaths;
            _logManager = logManager;
            _logger = new EmbyLoggerAdapter<Plugin>(logManager.GetLogger("InfiniteDrive"));
            //
            // NOTE (Sprint 152): DatabaseManager.Initialise() and PluginSecret generation
            // are now called from InfiniteDriveInitializationService.Run() (IServerEntryPoint),
            // not from this constructor. IServerEntryPoint.Run() is called before any
            // scheduled tasks fire, so this is safe.
            //
        }

        /// <inheritdoc/>
        public override string Name => "InfiniteDrive";

        /// <inheritdoc/>
        public override Guid Id => PluginGuid;

        /// <inheritdoc/>
        public override string Description =>
            "Real-Debrid streaming via AIOStreams — paste URL, press Play, done. (The answer is 42.)";

        /// <summary>
        /// Plugin version read from plugin.json manifest.
        /// Returns the version string or "unknown" if unavailable.
        /// Note: Named PluginVersion to avoid conflict with BasePlugin.Version.
        /// </summary>
        public string PluginVersion
        {
            get
            {
                try
                {
                    // Assembly.Location returns empty string in .NET Core load contexts
                    // DataPath is ~/emby-dev-data/data, plugins are at ~/emby-dev-data/plugins
                    // So we need to go up one level from DataPath
                    if (_appPaths?.DataPath == null)
                        return "unknown";

                    // Get parent directory of DataPath, then add "plugins"
                    var basePath = Directory.GetParent(_appPaths.DataPath)?.FullName ?? _appPaths.DataPath;
                    var pluginsDir = Path.Combine(basePath, "plugins");
                    var jsonPath = Path.Combine(pluginsDir, "plugin.json");

                    if (!File.Exists(jsonPath))
                        return "unknown";

                    var json = File.ReadAllText(jsonPath);
                    using var doc = JsonDocument.Parse(json);
                    if (doc.RootElement.TryGetProperty("version", out var versionProp))
                        return versionProp.GetString() ?? "unknown";
                }
                catch (Exception ex)
                {
                    _logger?.LogWarning(ex, "[InfiniteDrive] Failed to read version from plugin.json");
                }
                return "unknown";
            }
        }


        // ── IHasUIPages ────────────────────────────────────────────────────────

        private IReadOnlyCollection<IPluginUIPageController> _uiPages;

        /// <inheritdoc/>
        public IReadOnlyCollection<IPluginUIPageController> UIPageControllers
        {
            get
            {
                if (_uiPages == null)
                {
                    var id = Id.ToString();
                    _uiPages = new List<IPluginUIPageController>
                    {
                        new UI.Settings.SettingsController(id),
                    }.AsReadOnly();
                }
                return _uiPages;
            }
        }

        // ── IHasWebPages ────────────────────────────────────────────────────────

        /// <inheritdoc/>
        public IEnumerable<PluginPageInfo> GetPages()
        {
            return new[]
            {
                new PluginPageInfo
                {
                    Name = "InfiniteDiscover",
                    EmbeddedResourcePath = GetType().Namespace + ".Configuration.discoverpage.html",
                    EnableInMainMenu = true,
                    EnableInUserMenu = true,
                    MenuIcon = "explore",
                    MenuSection = "server",
                    DisplayName = "Discover"
                },
                new PluginPageInfo
                {
                    Name = "InfiniteDiscoverJS",
                    EmbeddedResourcePath = GetType().Namespace + ".Configuration.discoverpage.js"
                },
            };
        }

        // ── IHasThumbImage ───────────────────────────────────────────────────────

        /// <inheritdoc/>
        public Stream GetThumbImage()
        {
            var type = GetType();
            return type.Assembly.GetManifestResourceStream(type.Namespace + ".thumb.png")!;
        }

        /// <inheritdoc/>
        public ImageFormat ThumbImageFormat => ImageFormat.Png;

        // ── Public helpers ─────────────────────────────────────────────────────

        /// <summary>
        /// Checks whether the Emby Anime Plugin is installed by scanning
        /// the plugins directory for its assembly folder.
        /// The plugin typically lives at {DataPath}/plugins/Emby.Plugins.Anime/.
        /// </summary>
        public static bool IsAnimePluginInstalled()
        {
            try
            {
                var instance = Instance;
                if (instance == null) return false;

                var pluginsDir = Path.Combine(instance._appPaths.DataPath, "plugins");
                if (!Directory.Exists(pluginsDir)) return false;

                foreach (var dir in Directory.EnumerateDirectories(pluginsDir))
                {
                    var dirName = Path.GetFileName(dir);
                    if (dirName.IndexOf("anime", StringComparison.OrdinalIgnoreCase) >= 0)
                    {
                        if (Directory.GetFiles(dir, "*.dll").Length > 0)
                            return true;
                    }
                }

                return false;
            }
            catch
            {
                return false;
            }
        }

        // ── Private helpers ─────────────────────────────────────────────────────

        public void InitialiseDatabaseManager()
        {
            try
            {
                var dbDirectory = Path.Combine(_appPaths.DataPath, "InfiniteDrive");
                DatabaseManager = new DatabaseManager(dbDirectory, _logger);
                DatabaseManager.Initialise();
                _logger.LogInformation("[InfiniteDrive] Database initialised at {DbDir}", dbDirectory);

                // Initialise SystemStateService (Sprint 401: State Engine)
                SystemStateService = new Services.SystemStateService(DatabaseManager);
                _logger.LogInformation("[InfiniteDrive] SystemStateService initialised");

                _logger.LogInformation("[InfiniteDrive] Repository layer initialised");

                // Initialise candidate normalizer (Sprint 122)
                CandidateNormalizer = new Services.CandidateNormalizer(_logger);
                _logger.LogInformation("[InfiniteDrive] Candidate normalizer initialised");

                // Initialise StrmWriterService (Sprint 156: Unified Write Path)
                StrmWriterService = new Services.StrmWriterService(_logManager, DatabaseManager);
                _logger.LogInformation("[InfiniteDrive] StrmWriterService initialised");

                // Initialise StrmFileManager (multi-version .strm prewriting)
                StrmFileManager = new Services.StrmFileManager(_logManager);
                _logger.LogInformation("[InfiniteDrive] StrmFileManager initialised");

                // Initialise StreamProbeService (Sprint 159: Stream Availability Probe)
                StreamProbeService = new Services.StreamProbeService(
                    new EmbyLoggerAdapter<Services.StreamProbeService>(_logManager.GetLogger("StreamProbeService")));
                _logger.LogInformation("[InfiniteDrive] StreamProbeService initialised");

                // Initialise IdResolverService (Sprint 160: Robust ID Normalisation)
                IdResolverService = new Services.IdResolverService(_logManager);
                _logger.LogInformation("[InfiniteDrive] IdResolverService initialised");

                // Initialise CertificationResolver (Sprint 209: Parental Filtering)
                CertificationResolver = new Services.CertificationResolver(
                    new HttpClient(new SocketsHttpHandler { PooledConnectionLifetime = TimeSpan.FromMinutes(5) }),
                    new EmbyLoggerAdapter<Services.CertificationResolver>(_logManager.GetLogger("CertificationResolver")));
                _logger.LogInformation("[InfiniteDrive] CertificationResolver initialised");

                // Initialise ResolverHealthTracker (Sprint 310: Shared singleton)
                ResolverHealthTracker = new Services.ResolverHealthTracker(
                    new EmbyLoggerAdapter<Services.ResolverHealthTracker>(_logManager.GetLogger("ResolverHealthTracker")),
                    DatabaseManager);
                ResolverHealthTracker.RestoreState();
                _logger.LogInformation("[InfiniteDrive] ResolverHealthTracker initialised");

                // Initialise StreamCacheService (pre-cache singleton)
                StreamCacheService = new Services.StreamCacheService(
                    new EmbyLoggerAdapter<Services.StreamCacheService>(_logManager.GetLogger("StreamCacheService")),
                    _logManager);
                _logger.LogInformation("[InfiniteDrive] StreamCacheService initialised");

                // Initialise BlockListService (DB-only, no SDK deps)
                BlockListService = new Services.BlockListService(
                    DatabaseManager,
                    new EmbyLoggerAdapter<Services.BlockListService>(_logManager.GetLogger("BlockListService")));
                _logger.LogInformation("[InfiniteDrive] BlockListService initialised");

                // Sprint 350: Restore active provider state from database
                try
                {
                    var savedProvider = DatabaseManager.GetActiveProvider();
                    if (savedProvider == "Secondary")
                    {
                        ActiveProviderState.Current = Models.ActiveProvider.Secondary;
                        _logger.LogInformation("[InfiniteDrive] Restored ActiveProvider=Secondary from database");
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogDebug(ex, "[InfiniteDrive] Could not restore active provider state");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "[InfiniteDrive] Failed to initialise database — plugin may not function correctly");
            }
        }

        /// <summary>
        /// Initializes PlaylistService with SDK-provided interfaces.
        /// Called from an IServerEntryPoint that has IPlaylistManager/ILibraryManager injected.
        /// </summary>
        public void InitializePlaylistService(
            MediaBrowser.Controller.Playlists.IPlaylistManager playlistManager,
            MediaBrowser.Controller.Library.ILibraryManager libraryManager,
            MediaBrowser.Controller.Collections.ICollectionManager? collectionManager = null,
            MediaBrowser.Controller.Library.IUserManager? userManager = null)
        {
            LibraryManager = libraryManager;
            UserManager = userManager;

            LibraryProvisioningService = new Services.LibraryProvisioningService(
                libraryManager,
                new Logging.EmbyLoggerAdapter<Services.LibraryProvisioningService>(_logManager.GetLogger("InfiniteDrive")));

            if (collectionManager != null)
            {
                BoxSetService = new Services.BoxSetService(
                    collectionManager,
                    libraryManager,
                    new Logging.EmbyLoggerAdapter<Services.BoxSetService>(_logManager.GetLogger("BoxSetService")));
                _logger.LogInformation("[InfiniteDrive] BoxSetService initialised");
            }

            PlaylistService = new Services.PlaylistService(
                playlistManager,
                libraryManager,
                new Logging.EmbyLoggerAdapter<Services.PlaylistService>(_logManager.GetLogger("PlaylistService")),
                userManager);
            _logger.LogInformation("[InfiniteDrive] PlaylistService initialised");

            UnifiedItemService = new Services.UnifiedItemService(
                new Logging.EmbyLoggerAdapter<Services.UnifiedItemService>(_logManager.GetLogger("UnifiedItemService")),
                DatabaseManager,
                StrmWriterService,
                BlockListService,
                libraryManager);
            _logger.LogInformation("[InfiniteDrive] UnifiedItemService initialised");
        }

        /// <summary>
        /// Fire-and-forget background sync via MarvinTask. Safe to call from any UI save handler.
        /// </summary>
        public void TriggerBackgroundSync()
        {
            if (LibraryManager == null) return;

            _ = System.Threading.Tasks.Task.Run(async () =>
            {
                try
                {
                    _logger.LogInformation("[InfiniteDrive] Post-save sync triggered");
                    var marvin = new Tasks.MarvinTask(_logManager, LibraryManager, UserManager!);
                    await marvin.Execute(CancellationToken.None, new Progress<double>()).ConfigureAwait(false);
                    _logger.LogInformation("[InfiniteDrive] Post-save sync complete");
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "[InfiniteDrive] Post-save sync failed");
                }
            });
        }

    }
}