using System;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
using MediaBrowser.Model.Logging;

namespace NFOGuard.Emby.Plugin
{
    public class LibraryEventHandler : IDisposable
    {
        private readonly ILibraryManager _libraryManager;
        private readonly IItemRepository _itemRepository;
        private readonly ILogger _logger;
        private readonly LicenseManager _licenseManager;

        public LibraryEventHandler(ILibraryManager libraryManager, IItemRepository itemRepository, ILogger logger)
        {
            _libraryManager = libraryManager;
            _itemRepository = itemRepository;
            _logger = logger;
            _licenseManager = new LicenseManager(_logger);

            // Subscribe to library events
            _libraryManager.ItemAdded += OnItemAdded;
            _libraryManager.ItemUpdated += OnItemUpdated;
        }

        private void OnItemAdded(object sender, ItemChangeEventArgs e)
        {
            ProcessItem(e.Item, "Added");
        }

        private void OnItemUpdated(object sender, ItemChangeEventArgs e)
        {
            ProcessItem(e.Item, "Updated");
        }

        private void ProcessItem(BaseItem item, string eventType)
        {
            try
            {
                // Check if real-time sync is enabled
                if (!Plugin.Instance.Configuration.EnableRealTimeSync)
                    return;

                // TODO: Re-enable licensing when ready for production
                // Check license/trial status
                // if (!_licenseManager.CanUseFeature())
                // {
                //     _logger.Info("NFOGuard :: License expired or invalid. Please purchase a license to continue using NFOGuard.");
                //     return;
                // }

                // Process TV episodes and Movies
                if (item is Episode episode)
                {
                    ProcessEpisode(episode, eventType);
                }
                else if (item is Movie movie)
                {
                    ProcessMovie(movie, eventType);
                }
            }
            catch (Exception ex)
            {
                _logger.ErrorException($"NFOGuard :: Error processing item {item?.Name}", ex);
            }
        }

        private void ProcessEpisode(Episode episode, string eventType)
        {
            try
            {
                if (Plugin.Instance.Configuration.LogVerbose)
                    _logger.Info($"NFOGuard :: Processing {eventType} Episode :: {episode.Name}");

                // Check if PremiereDate exists and differs from DateCreated
                if (episode.PremiereDate.HasValue && 
                    episode.DateCreated != episode.PremiereDate.Value)
                {
                    if (Plugin.Instance.Configuration.LogVerbose)
                        _logger.Info($"NFOGuard :: Syncing PremiereDate to DateCreated :: {episode.Name} :: " +
                                   $"PremiereDate: {episode.PremiereDate.Value}, DateCreated: {episode.DateCreated}");

                    // Update DateCreated to match PremiereDate
                    episode.DateCreated = episode.PremiereDate.Value;

                    try
                    {
                        // Save to repository using ItemUpdateType.MetadataEdit
                        episode.UpdateToRepository(ItemUpdateType.MetadataEdit);
                        _logger.Info($"NFOGuard :: Successfully updated episode :: {episode.Name}");
                    }
                    catch (Exception ex)
                    {
                        _logger.ErrorException($"NFOGuard :: Failed to update episode {episode.Name}", ex);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.ErrorException($"NFOGuard :: Error processing episode {episode?.Name}", ex);
            }
        }

        private void ProcessMovie(Movie movie, string eventType)
        {
            try
            {
                if (Plugin.Instance.Configuration.LogVerbose)
                    _logger.Info($"NFOGuard :: Processing {eventType} Movie :: {movie.Name}");

                // Check if PremiereDate exists and differs from DateCreated
                if (movie.PremiereDate.HasValue && 
                    movie.DateCreated != movie.PremiereDate.Value)
                {
                    if (Plugin.Instance.Configuration.LogVerbose)
                        _logger.Info($"NFOGuard :: Syncing PremiereDate to DateCreated :: {movie.Name} :: " +
                                   $"PremiereDate: {movie.PremiereDate.Value}, DateCreated: {movie.DateCreated}");

                    // Update DateCreated to match PremiereDate
                    movie.DateCreated = movie.PremiereDate.Value;

                    try
                    {
                        // Save to repository using ItemUpdateType.MetadataEdit
                        movie.UpdateToRepository(ItemUpdateType.MetadataEdit);
                        _logger.Info($"NFOGuard :: Successfully updated movie :: {movie.Name}");
                    }
                    catch (Exception ex)
                    {
                        _logger.ErrorException($"NFOGuard :: Failed to update movie {movie.Name}", ex);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.ErrorException($"NFOGuard :: Error processing movie {movie?.Name}", ex);
            }
        }

        public void Dispose()
        {
            if (_libraryManager != null)
            {
                _libraryManager.ItemAdded -= OnItemAdded;
                _libraryManager.ItemUpdated -= OnItemUpdated;
            }
        }
    }
}