using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Jellyfin.Plugin.SRFPlay.Api;
using Jellyfin.Plugin.SRFPlay.Services;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.MediaInfo;
using Microsoft.Extensions.Logging;

namespace Jellyfin.Plugin.SRFPlay.Providers;

/// <summary>
/// Provides media sources (playback URLs) for SRF Play content.
/// </summary>
public class SRFMediaProvider : IMediaSourceProvider
{
    private readonly ILogger<SRFMediaProvider> _logger;
    private readonly ILoggerFactory _loggerFactory;
    private readonly MetadataCache _metadataCache;
    private readonly StreamUrlResolver _streamResolver;

    /// <summary>
    /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
    /// </summary>
    /// <param name="loggerFactory">The logger factory.</param>
    /// <param name="metadataCache">The metadata cache.</param>
    /// <param name="streamResolver">The stream URL resolver.</param>
    public SRFMediaProvider(
        ILoggerFactory loggerFactory,
        MetadataCache metadataCache,
        StreamUrlResolver streamResolver)
    {
        _loggerFactory = loggerFactory;
        _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
        _metadataCache = metadataCache;
        _streamResolver = streamResolver;
    }

    /// <summary>
    /// Gets the provider name.
    /// </summary>
    public string Name => "SRF Play";

    /// <summary>
    /// Gets media sources for the specified item.
    /// </summary>
    /// <param name="item">The item.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>List of media sources.</returns>
    public Task<IEnumerable<MediaSourceInfo>> GetMediaSources(BaseItem item, CancellationToken cancellationToken)
    {
        var sources = new List<MediaSourceInfo>();

        try
        {
            // Check if this is an SRF item
            if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
            {
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            _logger.LogDebug("Getting media sources for URN: {Urn}", urn);

            var config = Plugin.Instance?.Configuration;
            if (config == null)
            {
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            // Try cache first
            var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);

            // If not in cache, fetch from API
            if (mediaComposition == null)
            {
                using var apiClient = new SRFApiClient(_loggerFactory);
                mediaComposition = apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).GetAwaiter().GetResult();

                if (mediaComposition != null)
                {
                    _metadataCache.SetMediaComposition(urn, mediaComposition);
                }
            }

            if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
            {
                _logger.LogWarning("No chapters found for URN: {Urn}", urn);
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            // Get the first chapter (main video)
            var chapter = mediaComposition.ChapterList[0];

            // Check if content is expired
            if (_streamResolver.IsContentExpired(chapter))
            {
                _logger.LogWarning("Content expired for URN: {Urn}, ValidTo: {ValidTo}", urn, chapter.ValidTo);
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            // Check if content has playable streams
            if (!_streamResolver.HasPlayableContent(chapter))
            {
                _logger.LogWarning("No playable content found for URN: {Urn}", urn);
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            // Get stream URL based on quality preference
            var streamUrl = _streamResolver.GetStreamUrl(chapter, config.QualityPreference);

            if (string.IsNullOrEmpty(streamUrl))
            {
                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
            }

            // Create media source
            var mediaSource = new MediaSourceInfo
            {
                Id = urn,
                Name = chapter.Title,
                Path = streamUrl,
                Protocol = MediaProtocol.Http,
                Container = "m3u8",
                SupportsDirectStream = true,
                SupportsDirectPlay = true,
                SupportsTranscoding = true,
                IsRemote = true,
                Type = MediaSourceType.Default,
                RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
                VideoType = VideoType.VideoFile,
                IsInfiniteStream = false,
                RequiresOpening = false,
                RequiresClosing = false,
                SupportsProbing = true
            };

            // Add video stream info
            mediaSource.MediaStreams = new List<MediaStream>
            {
                new MediaStream
                {
                    Type = MediaStreamType.Video,
                    Codec = "h264",
                    IsInterlaced = false,
                    IsDefault = true
                }
            };

            sources.Add(mediaSource);
            _logger.LogInformation("Resolved stream URL for {Title}: {Url}", chapter.Title, streamUrl);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting media sources for item: {Name}", item.Name);
        }

        return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
    }

    /// <summary>
    /// Gets direct stream provider by unique ID.
    /// </summary>
    /// <param name="uniqueId">The unique ID.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>The direct stream provider.</returns>
    public Task<IDirectStreamProvider?> GetDirectStreamProviderByUniqueId(string uniqueId, CancellationToken cancellationToken)
    {
        // Not needed for HTTP streams
        return Task.FromResult<IDirectStreamProvider?>(null);
    }

    /// <inheritdoc />
    public Task<ILiveStream> OpenMediaSource(string openToken, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
    {
        // Not needed for static HTTP streams
        throw new NotImplementedException();
    }
}