using System;
using System.IO;
using System.Text.Json;
using LiteDB;
using MediaBrowser.Common.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using Microsoft.Extensions.Logging;

namespace Jellyfin.Plugin.SmartNotify.Services;

/// <summary>
/// Service for managing the local database of known media items.
/// </summary>
public class ItemHistoryService : IDisposable
{
    private readonly ILogger<ItemHistoryService> _logger;
    private readonly LiteDatabase _database;
    private readonly ILiteCollection<KnownMediaItem> _knownItems;
    private readonly ILiteCollection<PendingNotification> _pendingNotifications;
    private bool _disposed;

    /// <summary>
    /// Initializes a new instance of the <see cref="ItemHistoryService"/> class.
    /// </summary>
    /// <param name="applicationPaths">The application paths.</param>
    /// <param name="logger">The logger.</param>
    public ItemHistoryService(
        IApplicationPaths applicationPaths,
        ILogger<ItemHistoryService> logger)
    {
        _logger = logger;

        var pluginDataPath = Path.Combine(applicationPaths.PluginConfigurationsPath, "SmartNotify");
        Directory.CreateDirectory(pluginDataPath);

        var dbPath = Path.Combine(pluginDataPath, "smartnotify.db");
        _logger.LogInformation("SmartNotify database path: {Path}", dbPath);

        _database = new LiteDatabase(dbPath);
        _knownItems = _database.GetCollection<KnownMediaItem>("known_items");
        _pendingNotifications = _database.GetCollection<PendingNotification>("pending_notifications");

        // Create indexes for efficient queries
        _knownItems.EnsureIndex(x => x.ContentKey);
        _knownItems.EnsureIndex(x => x.JellyfinItemId);
        _pendingNotifications.EnsureIndex(x => x.SeriesId);
        _pendingNotifications.EnsureIndex(x => x.QueuedAt);
    }

    /// <summary>
    /// Generates a content key for uniquely identifying media content (regardless of file).
    /// </summary>
    /// <param name="item">The base item.</param>
    /// <returns>A unique content key, or null if insufficient metadata.</returns>
    public string? GenerateContentKey(BaseItem item)
    {
        if (item is Episode episode)
        {
            // For episodes: use series provider IDs + season + episode number
            var series = episode.Series;
            if (series == null)
            {
                _logger.LogDebug("Episode {Name} has no series, cannot generate content key", episode.Name);
                return null;
            }

            var seriesKey = GetProviderKey(series.ProviderIds);
            if (string.IsNullOrEmpty(seriesKey))
            {
                // Fallback to series name if no provider IDs
                seriesKey = series.Name?.ToLowerInvariant().Trim() ?? "unknown";
            }

            var seasonNum = episode.ParentIndexNumber ?? 0;
            var episodeNum = episode.IndexNumber ?? 0;

            if (episodeNum == 0)
            {
                _logger.LogDebug("Episode {Name} has no episode number", episode.Name);
                return null;
            }

            return $"episode|{seriesKey}|S{seasonNum:D2}E{episodeNum:D3}";
        }

        if (item is Movie movie)
        {
            // For movies: use provider IDs
            var movieKey = GetProviderKey(movie.ProviderIds);
            if (string.IsNullOrEmpty(movieKey))
            {
                // Fallback to name + year
                var year = movie.ProductionYear ?? 0;
                movieKey = $"{movie.Name?.ToLowerInvariant().Trim()}|{year}";
            }

            return $"movie|{movieKey}";
        }

        _logger.LogDebug("Item {Name} is not an Episode or Movie, type: {Type}", item.Name, item.GetType().Name);
        return null;
    }

    /// <summary>
    /// Gets a consistent provider key from provider IDs.
    /// </summary>
    private string? GetProviderKey(Dictionary<string, string>? providerIds)
    {
        if (providerIds == null || providerIds.Count == 0)
        {
            return null;
        }

        // Priority order for provider IDs
        string[] priorityOrder = { "AniDB", "AniList", "Tmdb", "Tvdb", "Imdb" };

        foreach (var provider in priorityOrder)
        {
            if (providerIds.TryGetValue(provider, out var id) && !string.IsNullOrEmpty(id))
            {
                return $"{provider.ToLowerInvariant()}:{id}";
            }
        }

        // Fallback: use first available
        foreach (var kvp in providerIds)
        {
            if (!string.IsNullOrEmpty(kvp.Value))
            {
                return $"{kvp.Key.ToLowerInvariant()}:{kvp.Value}";
            }
        }

        return null;
    }

    /// <summary>
    /// Checks if an item is a quality upgrade (content already known).
    /// </summary>
    /// <param name="item">The item to check.</param>
    /// <returns>True if this is an upgrade of existing content.</returns>
    public bool IsQualityUpgrade(BaseItem item)
    {
        var contentKey = GenerateContentKey(item);
        if (contentKey == null)
        {
            _logger.LogDebug("Could not generate content key for {Name}, treating as new", item.Name);
            return false;
        }

        var existing = _knownItems.FindOne(x => x.ContentKey == contentKey);
        if (existing != null)
        {
            _logger.LogInformation(
                "Item {Name} is a quality upgrade (content key: {Key}, first seen: {FirstSeen})",
                item.Name,
                contentKey,
                existing.FirstSeen);
            return true;
        }

        return false;
    }

    /// <summary>
    /// Checks if there's another item with the same content currently in the library.
    /// </summary>
    /// <param name="item">The item to check.</param>
    /// <param name="libraryManager">The library manager to query current items.</param>
    /// <returns>True if duplicate content exists.</returns>
    public bool HasDuplicateContent(BaseItem item, MediaBrowser.Controller.Library.ILibraryManager libraryManager)
    {
        var contentKey = GenerateContentKey(item);
        if (contentKey == null)
        {
            return false;
        }

        // Check if we have another item with the same content key but different Jellyfin ID
        var existing = _knownItems.FindOne(x => 
            x.ContentKey == contentKey && 
            x.JellyfinItemId != item.Id.ToString());

        if (existing != null)
        {
            // Verify the other item still exists in the library
            var otherId = Guid.Parse(existing.JellyfinItemId);
            var otherItem = libraryManager.GetItemById(otherId);
            if (otherItem != null)
            {
                _logger.LogInformation(
                    "Item {Name} has duplicate content already in library: {OtherName}",
                    item.Name,
                    otherItem.Name);
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// Records a known item in the database.
    /// </summary>
    /// <param name="item">The item to record.</param>
    public void RecordItem(BaseItem item)
    {
        var contentKey = GenerateContentKey(item);
        if (contentKey == null)
        {
            return;
        }

        var jellyfinId = item.Id.ToString();

        // Check if we already have this exact Jellyfin item
        var existing = _knownItems.FindOne(x => x.JellyfinItemId == jellyfinId);
        if (existing != null)
        {
            // Update the record
            existing.ContentKey = contentKey;
            existing.FilePath = item.Path;
            _knownItems.Update(existing);
            return;
        }

        // Check if we have this content key already (upgrade scenario)
        var byContentKey = _knownItems.FindOne(x => x.ContentKey == contentKey);
        if (byContentKey != null)
        {
            // Content exists, this is an upgrade - update the record
            byContentKey.JellyfinItemId = jellyfinId;
            byContentKey.FilePath = item.Path;
            _knownItems.Update(byContentKey);
            _logger.LogDebug("Updated existing content record for {Key} with new file", contentKey);
            return;
        }

        // New content - create record
        var record = new KnownMediaItem
        {
            JellyfinItemId = jellyfinId,
            ContentKey = contentKey,
            ItemType = item.GetType().Name,
            Name = item.Name,
            FirstSeen = DateTime.UtcNow,
            FilePath = item.Path,
            ProviderIdsJson = System.Text.Json.JsonSerializer.Serialize(item.ProviderIds ?? new Dictionary<string, string>())
        };

        if (item is Episode ep)
        {
            record.SeriesName = ep.SeriesName;
            record.SeasonNumber = ep.ParentIndexNumber;
            record.EpisodeNumber = ep.IndexNumber;
            record.Year = ep.ProductionYear;
        }
        else if (item is Movie movie)
        {
            record.Year = movie.ProductionYear;
        }

        _knownItems.Insert(record);
        _logger.LogDebug("Recorded new content: {Key}", contentKey);
    }

    /// <summary>
    /// Removes an item from the known items database.
    /// </summary>
    /// <param name="itemId">The Jellyfin item ID.</param>
    public void RemoveItem(Guid itemId)
    {
        var jellyfinId = itemId.ToString();
        _knownItems.DeleteMany(x => x.JellyfinItemId == jellyfinId);
    }

    /// <summary>
    /// Queues a notification for later processing.
    /// </summary>
    /// <param name="notification">The notification to queue.</param>
    public void QueueNotification(PendingNotification notification)
    {
        _pendingNotifications.Insert(notification);
    }

    /// <summary>
    /// Gets all pending notifications older than the specified delay.
    /// </summary>
    /// <param name="olderThan">The cutoff time.</param>
    /// <returns>The pending notifications.</returns>
    public IEnumerable<PendingNotification> GetPendingNotifications(DateTime olderThan)
    {
        return _pendingNotifications.Find(x => x.QueuedAt <= olderThan);
    }

    /// <summary>
    /// Removes processed notifications.
    /// </summary>
    /// <param name="ids">The notification IDs to remove.</param>
    public void RemoveNotifications(IEnumerable<int> ids)
    {
        foreach (var id in ids)
        {
            _pendingNotifications.Delete(id);
        }
    }

    /// <summary>
    /// Gets pending notifications grouped by series.
    /// </summary>
    /// <param name="seriesId">The series ID.</param>
    /// <returns>The notifications for the series.</returns>
    public IEnumerable<PendingNotification> GetNotificationsForSeries(string seriesId)
    {
        return _pendingNotifications.Find(x => x.SeriesId == seriesId);
    }

    /// <inheritdoc />
    public void Dispose()
    {
        if (!_disposed)
        {
            _database.Dispose();
            _disposed = true;
        }
    }
}