jellyfin-srfPlay/Jellyfin.Plugin.SRFPlay/Providers/SRFSeriesProvider.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Providers;
using Microsoft.Extensions.Logging;

namespace Jellyfin.Plugin.SRFPlay.Providers;

/// <summary>
/// Provides metadata for SRF Play series/shows.
/// </summary>
public class SRFSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>
{
    private readonly ILogger<SRFSeriesProvider> _logger;
    private readonly IMediaCompositionFetcher _compositionFetcher;

    /// <summary>
    /// Initializes a new instance of the <see cref="SRFSeriesProvider"/> class.
    /// </summary>
    /// <param name="logger">The logger.</param>
    /// <param name="compositionFetcher">The media composition fetcher.</param>
    public SRFSeriesProvider(
        ILogger<SRFSeriesProvider> logger,
        IMediaCompositionFetcher compositionFetcher)
    {
        _logger = logger;
        _compositionFetcher = compositionFetcher;
    }

    /// <inheritdoc />
    public string Name => "SRF Play";

    /// <inheritdoc />
    public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(SeriesInfo searchInfo, CancellationToken cancellationToken)
    {
        var results = new List<RemoteSearchResult>();

        try
        {
            // Check if we have a URN to search with
            if (searchInfo.ProviderIds.TryGetValue("SRF", out var urn) && !string.IsNullOrEmpty(urn))
            {
                _logger.LogDebug("Searching for series with URN: {Urn}", urn);

                var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);

                if (mediaComposition?.Show != null)
                {
                    var show = mediaComposition.Show;
                    results.Add(new RemoteSearchResult
                    {
                        Name = show.Title,
                        Overview = show.Description ?? show.Lead,
                        ImageUrl = show.ImageUrl,
                        SearchProviderName = Name,
                        ProviderIds = new Dictionary<string, string>
                        {
                            { "SRF", show.Urn ?? urn }
                        }
                    });
                }
            }
            else if (!string.IsNullOrEmpty(searchInfo.Name))
            {
                _logger.LogDebug("Name-based search not yet implemented for: {Name}", searchInfo.Name);
                // TODO: Implement name-based search when SRF provides search API
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error searching for series: {Name}", searchInfo.Name);
        }

        return results;
    }

    /// <inheritdoc />
    public async Task<MetadataResult<Series>> GetMetadata(SeriesInfo info, CancellationToken cancellationToken)
    {
        var result = new MetadataResult<Series>();

        try
        {
            // Check if we have a URN
            if (!info.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
            {
                _logger.LogDebug("No SRF URN found for series: {Name}", info.Name);
                return result;
            }

            _logger.LogDebug("Fetching metadata for series URN: {Urn}", urn);

            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);

            if (mediaComposition?.Show == null)
            {
                _logger.LogWarning("No show information found for URN: {Urn}", urn);
                return result;
            }

            var show = mediaComposition.Show;

            result.Item = new Series
            {
                Name = show.Title,
                Overview = show.Description ?? show.Lead,
                ProviderIds = new Dictionary<string, string>
                {
                    { "SRF", show.Urn ?? urn }
                }
            };

            // Set additional metadata if available
            if (!string.IsNullOrEmpty(show.Vendor))
            {
                result.Item.Studios = new[] { show.Vendor };
            }

            result.HasMetadata = true;
            _logger.LogDebug("Successfully fetched metadata for series: {Title}", show.Title);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error fetching metadata for series: {Name}", info.Name);
        }

        return result;
    }

    /// <inheritdoc />
    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
    {
        throw new NotImplementedException("Image handling is done by SRFImageProvider");
    }
}