first commit

Jellyfin.Plugin.SRFPlay/Api/Models/Chapter.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a chapter (video/episode) in the SRF API response.
+/// </summary>
+public class Chapter
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN (Uniform Resource Name).
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string Urn { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration in milliseconds.
+    /// </summary>
+    [JsonPropertyName("duration")]
+    public long Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("date")]
+    public DateTime? Date { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid from date.
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid to date (expiration).
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of available resources (streams).
+    /// </summary>
+    [JsonPropertyName("resourceList")]
+    public IReadOnlyList<Resource> ResourceList { get; set; } = new List<Resource>();
+
+    /// <summary>
+    /// Gets or sets the episode number.
+    /// </summary>
+    [JsonPropertyName("episodeNumber")]
+    public int? EpisodeNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the season number.
+    /// </summary>
+    [JsonPropertyName("seasonNumber")]
+    public int? SeasonNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the media type.
+    /// </summary>
+    [JsonPropertyName("mediaType")]
+    public string? MediaType { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Episode.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents an episode in the SRF API response.
+/// </summary>
+public class Episode
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the episode number.
+    /// </summary>
+    [JsonPropertyName("episodeNumber")]
+    public int? EpisodeNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the season number.
+    /// </summary>
+    [JsonPropertyName("seasonNumber")]
+    public int? SeasonNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("publishedDate")]
+    public DateTime? PublishedDate { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/MediaComposition.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents the root media composition response from SRF API.
+/// </summary>
+public class MediaComposition
+{
+    /// <summary>
+    /// Gets or sets the list of chapters (videos/episodes).
+    /// </summary>
+    [JsonPropertyName("chapterList")]
+    public IReadOnlyList<Chapter> ChapterList { get; set; } = new List<Chapter>();
+
+    /// <summary>
+    /// Gets or sets the episode information.
+    /// </summary>
+    [JsonPropertyName("episode")]
+    public Episode? Episode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show information.
+    /// </summary>
+    [JsonPropertyName("show")]
+    public Show? Show { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3DataContainer.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents the data container in a Play v3 response.
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3DataContainer<T>
+{
+    /// <summary>
+    /// Gets or sets the list of data items.
+    /// </summary>
+    [JsonPropertyName("data")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<T>? Data { get; set; }
+
+    /// <summary>
+    /// Gets or sets the next page cursor.
+    /// </summary>
+    [JsonPropertyName("next")]
+    public string? Next { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3DirectResponse.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a direct data response (for shows list).
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3DirectResponse<T>
+{
+    /// <summary>
+    /// Gets or sets the list of data items.
+    /// </summary>
+    [JsonPropertyName("data")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<T>? Data { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Response.cs

@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a paginated response from the Play v3 API.
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3Response<T>
+{
+    /// <summary>
+    /// Gets or sets the data container.
+    /// </summary>
+    [JsonPropertyName("data")]
+    public PlayV3DataContainer<T>? Data { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Show.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a show from the Play v3 API.
+/// </summary>
+public class PlayV3Show
+{
+    /// <summary>
+    /// Gets or sets the show ID.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type (TV or Radio).
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+
+    /// <summary>
+    /// Gets or sets the vendor/business unit.
+    /// </summary>
+    [JsonPropertyName("vendor")]
+    public string? Vendor { get; set; }
+
+    /// <summary>
+    /// Gets or sets the lead description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the full description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the poster image URL.
+    /// </summary>
+    [JsonPropertyName("posterImageUrl")]
+    public string? PosterImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of episodes.
+    /// </summary>
+    [JsonPropertyName("numberOfEpisodes")]
+    public int NumberOfEpisodes { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of topic IDs.
+    /// </summary>
+    [JsonPropertyName("topicList")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<string>? TopicList { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Topic.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a topic/category from the Play v3 API.
+/// </summary>
+public class PlayV3Topic
+{
+    /// <summary>
+    /// Gets or sets the topic ID (UUID).
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the topic title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the topic description/lead.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type (TV or Radio).
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Video.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a video/episode from the Play v3 API.
+/// </summary>
+public class PlayV3Video
+{
+    /// <summary>
+    /// Gets or sets the video ID.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the video URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the video title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the episode ID.
+    /// </summary>
+    [JsonPropertyName("episodeId")]
+    public string? EpisodeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the lead description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the full description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration in milliseconds.
+    /// </summary>
+    [JsonPropertyName("duration")]
+    public long Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("date")]
+    public DateTime Date { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid from date.
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid to date (expiration).
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the media type (VIDEO or AUDIO).
+    /// </summary>
+    [JsonPropertyName("mediaType")]
+    public string? MediaType { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether subtitles are available.
+    /// </summary>
+    [JsonPropertyName("subtitlesAvailable")]
+    public bool SubtitlesAvailable { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the content is playable abroad.
+    /// </summary>
+    [JsonPropertyName("playableAbroad")]
+    public bool PlayableAbroad { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of possible block reasons.
+    /// </summary>
+    [JsonPropertyName("possibleBlockReasons")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<string>? PossibleBlockReasons { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content type (EPISODE, CLIP, etc.).
+    /// </summary>
+    [JsonPropertyName("type")]
+    public string? Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the associated show information.
+    /// </summary>
+    [JsonPropertyName("show")]
+    public PlayV3Show? Show { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Resource.cs

@@ -0,0 +1,51 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a streaming resource (URL) in the SRF API response.
+/// </summary>
+public class Resource
+{
+    /// <summary>
+    /// Gets or sets the stream URL.
+    /// </summary>
+    [JsonPropertyName("url")]
+    public string Url { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the streaming protocol (e.g., HLS, DASH).
+    /// </summary>
+    [JsonPropertyName("protocol")]
+    public string? Protocol { get; set; }
+
+    /// <summary>
+    /// Gets or sets the quality level (e.g., HD, SD).
+    /// </summary>
+    [JsonPropertyName("quality")]
+    public string? Quality { get; set; }
+
+    /// <summary>
+    /// Gets or sets the streaming method.
+    /// </summary>
+    [JsonPropertyName("streaming")]
+    public string? Streaming { get; set; }
+
+    /// <summary>
+    /// Gets or sets the MIME type.
+    /// </summary>
+    [JsonPropertyName("mimeType")]
+    public string? MimeType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the encoding.
+    /// </summary>
+    [JsonPropertyName("encoding")]
+    public string? Encoding { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether DRM is required.
+    /// </summary>
+    [JsonPropertyName("drmList")]
+    public object? DrmList { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Show.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a show/program in the SRF API response.
+/// </summary>
+public class Show
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the banner image URL.
+    /// </summary>
+    [JsonPropertyName("bannerImageUrl")]
+    public string? BannerImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the vendor (business unit).
+    /// </summary>
+    [JsonPropertyName("vendor")]
+    public string? Vendor { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type.
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/SRFApiClient.cs

@@ -0,0 +1,507 @@
+using System;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// HTTP client for interacting with the SRF Integration Layer API.
+/// </summary>
+public class SRFApiClient : IDisposable
+{
+    private const string BaseUrl = "https://il.srgssr.ch/integrationlayer/2.0";
+    private const string PlayV3BaseUrlTemplate = "https://www.{0}.ch/play/v3/api/{0}/production/";
+    private static readonly System.Text.CompositeFormat PlayV3UrlFormat = System.Text.CompositeFormat.Parse(PlayV3BaseUrlTemplate);
+    private readonly HttpClient _httpClient;
+    private readonly HttpClient _playV3HttpClient;
+    private readonly ILogger _logger;
+    private readonly JsonSerializerOptions _jsonOptions;
+    private readonly PluginConfiguration _configuration;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFApiClient"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public SRFApiClient(ILoggerFactory loggerFactory)
+    {
+        _logger = loggerFactory.CreateLogger<SRFApiClient>();
+        _configuration = Plugin.Instance?.Configuration ?? new PluginConfiguration();
+
+        // Log proxy configuration status
+        if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+        {
+            _logger.LogInformation(
+                "SRFApiClient initializing with proxy enabled: {ProxyAddress}",
+                _configuration.ProxyAddress);
+        }
+        else
+        {
+            _logger.LogInformation("SRFApiClient initializing without proxy");
+        }
+
+        _httpClient = CreateHttpClient(BaseUrl);
+        _playV3HttpClient = CreateHttpClient(null);
+
+        _jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        };
+    }
+
+    /// <summary>
+    /// Creates an HttpClient with optional proxy configuration.
+    /// </summary>
+    /// <param name="baseAddress">The base address for the HTTP client.</param>
+    /// <returns>Configured HttpClient.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Security", "CA5399:HttpClient is created without enabling CheckCertificateRevocationList", Justification = "CRL check disabled for proxy compatibility")]
+    private HttpClient CreateHttpClient(string? baseAddress)
+    {
+        HttpClientHandler handler = new HttpClientHandler
+        {
+            CheckCertificateRevocationList = false, // Disable CRL check for proxy compatibility
+            AutomaticDecompression = System.Net.DecompressionMethods.All
+        };
+
+        // Configure proxy if enabled
+        if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+        {
+            try
+            {
+                var proxy = new WebProxy(_configuration.ProxyAddress);
+
+                // Add credentials if provided
+                if (!string.IsNullOrWhiteSpace(_configuration.ProxyUsername))
+                {
+                    proxy.Credentials = new NetworkCredential(
+                        _configuration.ProxyUsername,
+                        _configuration.ProxyPassword);
+                }
+
+                handler.Proxy = proxy;
+                handler.UseProxy = true;
+
+                _logger.LogInformation(
+                    "Proxy configured: {ProxyAddress} (Authentication: {HasAuth})",
+                    _configuration.ProxyAddress,
+                    !string.IsNullOrWhiteSpace(_configuration.ProxyUsername));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to configure proxy: {ProxyAddress}", _configuration.ProxyAddress);
+                handler.UseProxy = false;
+            }
+        }
+
+        var client = new HttpClient(handler)
+        {
+            Timeout = TimeSpan.FromSeconds(30),
+            DefaultRequestVersion = HttpVersion.Version11, // Force HTTP/1.1
+            DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact // Ensure HTTP/1.1 is used, not upgraded
+        };
+
+        // Add browser headers - required by SRF API
+        client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+        client.DefaultRequestHeaders.Accept.ParseAdd("*/*");
+        client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-US,en;q=0.9");
+
+        _logger.LogInformation(
+            "HttpClient created with HTTP/1.1 and headers - User-Agent: {UserAgent}, Accept: {Accept}, Accept-Language: {AcceptLanguage}",
+            client.DefaultRequestHeaders.UserAgent.ToString(),
+            client.DefaultRequestHeaders.Accept.ToString(),
+            client.DefaultRequestHeaders.AcceptLanguage.ToString());
+
+        if (!string.IsNullOrWhiteSpace(baseAddress))
+        {
+            client.BaseAddress = new Uri(baseAddress);
+        }
+
+        return client;
+    }
+
+    /// <summary>
+    /// Gets media composition by URN using curl as a fallback.
+    /// </summary>
+    /// <param name="urn">The URN of the content.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition.</returns>
+    public async Task<MediaComposition?> GetMediaCompositionByUrnAsync(string urn, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var url = $"/mediaComposition/byUrn/{urn}.json";
+            var fullUrl = $"{BaseUrl}{url}";
+            _logger.LogInformation("Fetching media composition for URN: {Urn} from {Url}", urn, fullUrl);
+
+            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            // Log response headers to diagnose geo-blocking
+            var xLocation = response.Headers.Contains("x-location")
+                ? string.Join(", ", response.Headers.GetValues("x-location"))
+                : "not present";
+
+            _logger.LogInformation(
+                "Media composition response for URN {Urn}: StatusCode={StatusCode}, x-location={XLocation}",
+                urn,
+                response.StatusCode,
+                xLocation);
+
+            // If HttpClient fails, try curl as fallback
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogWarning("HttpClient failed with {StatusCode}, trying curl fallback", response.StatusCode);
+                return await FetchWithCurlAsync(fullUrl, cancellationToken).ConfigureAwait(false);
+            }
+
+            response.EnsureSuccessStatusCode();
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
+
+            if (result?.ChapterList != null && result.ChapterList.Count > 0)
+            {
+                _logger.LogInformation(
+                    "Successfully fetched media composition for URN: {Urn} - Chapters: {ChapterCount}",
+                    urn,
+                    result.ChapterList.Count);
+            }
+            else
+            {
+                _logger.LogWarning("Media composition for URN {Urn} has no chapters", urn);
+            }
+
+            return result;
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogError(
+                ex,
+                "HTTP error fetching media composition for URN: {Urn} - StatusCode: {StatusCode}, trying curl fallback",
+                urn,
+                ex.StatusCode);
+
+            var fullUrl = $"{BaseUrl}/mediaComposition/byUrn/{urn}.json";
+            return await FetchWithCurlAsync(fullUrl, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching media composition for URN: {Urn}", urn);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Fetches content using curl command as a fallback.
+    /// </summary>
+    /// <param name="url">The full URL to fetch.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The deserialized media composition.</returns>
+    private async Task<MediaComposition?> FetchWithCurlAsync(string url, CancellationToken cancellationToken)
+    {
+        try
+        {
+            _logger.LogInformation("Using curl to fetch: {Url}", url);
+
+            var curlArgs = $"-s -H \"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\"";
+
+            // Add proxy if configured
+            if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+            {
+                curlArgs += $" -x {_configuration.ProxyAddress}";
+
+                if (!string.IsNullOrWhiteSpace(_configuration.ProxyUsername))
+                {
+                    curlArgs += $" -U {_configuration.ProxyUsername}:{_configuration.ProxyPassword}";
+                }
+
+                _logger.LogInformation("curl using proxy: {ProxyAddress}", _configuration.ProxyAddress);
+            }
+
+            curlArgs += $" \"{url}\"";
+
+            var processStartInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "curl",
+                Arguments = curlArgs,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
+
+            using var process = new System.Diagnostics.Process { StartInfo = processStartInfo };
+            process.Start();
+
+            var output = await process.StandardOutput.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+            var error = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+
+            await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
+
+            if (process.ExitCode != 0)
+            {
+                _logger.LogError("curl failed with exit code {ExitCode}: {Error}", process.ExitCode, error);
+                return null;
+            }
+
+            if (string.IsNullOrWhiteSpace(output))
+            {
+                _logger.LogWarning("curl returned empty response");
+                return null;
+            }
+
+            _logger.LogInformation("curl succeeded, response length: {Length}", output.Length);
+
+            var result = JsonSerializer.Deserialize<MediaComposition>(output, _jsonOptions);
+
+            if (result?.ChapterList != null && result.ChapterList.Count > 0)
+            {
+                _logger.LogInformation("Successfully fetched media composition via curl - Chapters: {ChapterCount}", result.ChapterList.Count);
+            }
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error using curl to fetch URL: {Url}", url);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets the latest videos for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition containing latest videos.</returns>
+    public async Task<MediaComposition?> GetLatestVideosAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var url = $"/video/{businessUnit}/latest.json";
+            _logger.LogInformation("Fetching latest videos for business unit: {BusinessUnit} from URL: {Url}", businessUnit, url);
+
+            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogInformation("Latest videos API response: {StatusCode}", response.StatusCode);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("Latest videos response length: {Length}", content.Length);
+
+            var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched latest videos for business unit: {BusinessUnit}", businessUnit);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching latest videos for business unit: {BusinessUnit}", businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets the trending videos for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition containing trending videos.</returns>
+    public async Task<MediaComposition?> GetTrendingVideosAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var url = $"/video/{businessUnit}/trending.json";
+            _logger.LogInformation("Fetching trending videos for business unit: {BusinessUnit} from URL: {Url}", businessUnit, url);
+
+            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogInformation("Trending videos API response: {StatusCode}", response.StatusCode);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("Trending videos response length: {Length}", content.Length);
+
+            var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched trending videos for business unit: {BusinessUnit}", businessUnit);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching trending videos for business unit: {BusinessUnit}", businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets raw JSON response from a URL.
+    /// </summary>
+    /// <param name="url">The relative URL.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The JSON string.</returns>
+    public async Task<string?> GetJsonAsync(string url, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            _logger.LogDebug("Fetching JSON from URL: {Url}", url);
+
+            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+            response.EnsureSuccessStatusCode();
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            return content;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching JSON from URL: {Url}", url);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets all shows from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of shows.</returns>
+    public async Task<System.Collections.Generic.List<PlayV3Show>?> GetAllShowsAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl = string.Format(CultureInfo.InvariantCulture, PlayV3UrlFormat, businessUnit);
+            var url = $"{baseUrl}shows";
+            _logger.LogInformation("Fetching all shows for business unit: {BusinessUnit} from URL: {Url}", businessUnit, url);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<PlayV3DirectResponse<PlayV3Show>>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched {Count} shows for business unit: {BusinessUnit}", result?.Data?.Count ?? 0, businessUnit);
+            return result?.Data;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching shows for business unit: {BusinessUnit}", businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets all topics from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of topics.</returns>
+    public async Task<System.Collections.Generic.List<PlayV3Topic>?> GetAllTopicsAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl = string.Format(CultureInfo.InvariantCulture, PlayV3UrlFormat, businessUnit);
+            var url = $"{baseUrl}topics";
+            _logger.LogInformation("Fetching all topics for business unit: {BusinessUnit} from URL: {Url}", businessUnit, url);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<PlayV3DirectResponse<PlayV3Topic>>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched {Count} topics for business unit: {BusinessUnit}", result?.Data?.Count ?? 0, businessUnit);
+            return result?.Data;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching topics for business unit: {BusinessUnit}", businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets videos for a specific show from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="showId">The show ID.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of videos.</returns>
+    public async Task<System.Collections.Generic.List<PlayV3Video>?> GetVideosForShowAsync(string businessUnit, string showId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl = string.Format(CultureInfo.InvariantCulture, PlayV3UrlFormat, businessUnit);
+            var url = $"{baseUrl}videos-by-show-id?showId={showId}";
+            _logger.LogDebug("Fetching videos for show {ShowId} from business unit: {BusinessUnit}", showId, businessUnit);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<PlayV3Response<PlayV3Video>>(content, _jsonOptions);
+
+            _logger.LogDebug("Successfully fetched {Count} videos for show {ShowId}", result?.Data?.Data?.Count ?? 0, showId);
+            return result?.Data?.Data;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching videos for show {ShowId} from business unit: {BusinessUnit}", showId, businessUnit);
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases the unmanaged resources and optionally releases the managed resources.
+    /// </summary>
+    /// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _httpClient?.Dispose();
+            _playV3HttpClient?.Dispose();
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Channels/SRFPlayChannel.cs

@@ -0,0 +1,463 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Channels;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// SRF Play channel for browsing and playing content.
+/// </summary>
+public class SRFPlayChannel : IChannel, IHasCacheKey
+{
+    private readonly ILogger<SRFPlayChannel> _logger;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly ContentRefreshService _contentRefreshService;
+    private readonly StreamUrlResolver _streamResolver;
+    private readonly CategoryService? _categoryService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFPlayChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="categoryService">The category service (optional).</param>
+    public SRFPlayChannel(
+        ILoggerFactory loggerFactory,
+        ContentRefreshService contentRefreshService,
+        StreamUrlResolver streamResolver,
+        CategoryService? categoryService = null)
+    {
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<SRFPlayChannel>();
+        _contentRefreshService = contentRefreshService;
+        _streamResolver = streamResolver;
+        _categoryService = categoryService;
+
+        if (_categoryService == null)
+        {
+            _logger.LogWarning("CategoryService not available - category folders will be disabled");
+        }
+
+        _logger.LogInformation("=== SRFPlayChannel constructor called! Channel is being instantiated ===");
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public string Description => "Swiss Radio and Television video-on-demand content";
+
+    /// <inheritdoc />
+    public string DataVersion => "1.0";
+
+    /// <inheritdoc />
+    public string HomePageUrl => "https://www.srf.ch/play";
+
+    /// <inheritdoc />
+    public ChannelParentalRating ParentalRating => ChannelParentalRating.GeneralAudience;
+
+    /// <inheritdoc />
+    public InternalChannelFeatures GetChannelFeatures()
+    {
+        _logger.LogInformation("=== GetChannelFeatures called for SRF Play channel ===");
+
+        return new InternalChannelFeatures
+        {
+            ContentTypes = new List<ChannelMediaContentType>
+            {
+                ChannelMediaContentType.Episode,
+                ChannelMediaContentType.Movie
+            },
+            MediaTypes = new List<ChannelMediaType>
+            {
+                ChannelMediaType.Video
+            },
+            SupportsSortOrderToggle = false,
+            DefaultSortFields = new List<ChannelItemSortField>
+            {
+                ChannelItemSortField.DateCreated,
+                ChannelItemSortField.Name
+            },
+            MaxPageSize = 50
+        };
+    }
+
+    /// <inheritdoc />
+    public Task<DynamicImageResponse> GetChannelImage(ImageType type, CancellationToken cancellationToken)
+    {
+        // Could provide a channel logo here
+        return Task.FromResult(new DynamicImageResponse
+        {
+            HasImage = false
+        });
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<ImageType> GetSupportedChannelImages()
+    {
+        return new List<ImageType>
+        {
+            ImageType.Primary,
+            ImageType.Thumb
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<ChannelItemResult> GetChannelItems(InternalChannelItemQuery query, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("=== GetChannelItems called! FolderId: {FolderId} ===", query.FolderId);
+
+        var items = new List<ChannelItemInfo>();
+        var config = Plugin.Instance?.Configuration;
+
+        try
+        {
+            // Root level - show categories
+            if (string.IsNullOrEmpty(query.FolderId))
+            {
+                items.Add(new ChannelItemInfo
+                {
+                    Id = "latest",
+                    Name = "Latest Videos",
+                    Type = ChannelItemType.Folder,
+                    FolderType = ChannelFolderType.Container,
+                    ImageUrl = null
+                });
+
+                items.Add(new ChannelItemInfo
+                {
+                    Id = "trending",
+                    Name = "Trending Videos",
+                    Type = ChannelItemType.Folder,
+                    FolderType = ChannelFolderType.Container,
+                    ImageUrl = null
+                });
+
+                // Add category folders if enabled and CategoryService is available
+                if (config?.EnableCategoryFolders == true && _categoryService != null)
+                {
+                    try
+                    {
+                        var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
+                        var topics = await _categoryService.GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+                        foreach (var topic in topics.Where(t => !string.IsNullOrEmpty(t.Id)))
+                        {
+                            // Filter by enabled topics if configured
+                            if (config.EnabledTopics != null && config.EnabledTopics.Count > 0 && !config.EnabledTopics.Contains(topic.Id!))
+                            {
+                                continue;
+                            }
+
+                            items.Add(new ChannelItemInfo
+                            {
+                                Id = $"category_{topic.Id}",
+                                Name = topic.Title ?? topic.Id!,
+                                Type = ChannelItemType.Folder,
+                                FolderType = ChannelFolderType.Container,
+                                ImageUrl = null,
+                                Overview = topic.Lead
+                            });
+                        }
+
+                        _logger.LogInformation("Added {Count} category folders", topics.Count);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Failed to load category folders - continuing without categories");
+                    }
+                }
+
+                return new ChannelItemResult
+                {
+                    Items = items,
+                    TotalRecordCount = items.Count
+                };
+            }
+
+            // Latest videos
+            if (query.FolderId == "latest")
+            {
+                var urns = await _contentRefreshService.RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
+                items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+            }
+
+            // Trending videos
+            else if (query.FolderId == "trending")
+            {
+                var urns = await _contentRefreshService.RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
+                items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+            }
+
+            // Category folder - show videos for this category
+            else if (query.FolderId?.StartsWith("category_", StringComparison.Ordinal) == true)
+            {
+                if (_categoryService == null)
+                {
+                    _logger.LogWarning("CategoryService not available - cannot display category folder");
+                }
+                else
+                {
+                    try
+                    {
+                        var topicId = query.FolderId.Substring("category_".Length);
+                        var businessUnit = config?.BusinessUnit.ToString().ToLowerInvariant() ?? "srf";
+
+                        var shows = await _categoryService.GetShowsByTopicAsync(topicId, businessUnit, 20, cancellationToken).ConfigureAwait(false);
+                        var urns = new List<string>();
+
+                        using var apiClient = new Api.SRFApiClient(_loggerFactory);
+
+                        foreach (var show in shows)
+                        {
+                            if (show.Id == null)
+                            {
+                                continue;
+                            }
+
+                            try
+                            {
+                                var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
+                                if (videos != null && videos.Count > 0)
+                                {
+                                    _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): Found {Count} videos", topicId, show.Title, show.Id, videos.Count);
+
+                                    // Filter to videos that are actually published and not expired
+                                    var now = DateTime.UtcNow;
+                                    var availableVideos = videos.Where(v =>
+                                        (v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now) &&
+                                        (v.ValidTo == null || v.ValidTo.Value.ToUniversalTime() > now)).ToList();
+
+                                    _logger.LogDebug("Category {TopicId}, Show {Show}: {AvailableCount} available out of {TotalCount} videos", topicId, show.Title, availableVideos.Count, videos.Count);
+
+                                    if (availableVideos.Count > 0)
+                                    {
+                                        // Get most recent available video from this show
+                                        var latestVideo = availableVideos.OrderByDescending(v => v.Date).FirstOrDefault();
+                                        if (latestVideo?.Urn != null)
+                                        {
+                                            urns.Add(latestVideo.Urn);
+                                            _logger.LogInformation(
+                                                "Category {TopicId}: Added video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
+                                                topicId,
+                                                show.Title,
+                                                latestVideo.Title,
+                                                latestVideo.Urn,
+                                                latestVideo.Date,
+                                                latestVideo.ValidFrom,
+                                                latestVideo.ValidTo);
+                                        }
+                                        else
+                                        {
+                                            _logger.LogWarning("Category {TopicId}, Show {Show}: Latest available video has null URN", topicId, show.Title);
+                                        }
+                                    }
+                                    else
+                                    {
+                                        _logger.LogDebug("Category {TopicId}, Show {Show}: No available videos (all expired or not yet published)", topicId, show.Title);
+                                    }
+                                }
+                                else
+                                {
+                                    _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): No videos returned from API", topicId, show.Title, show.Id);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                _logger.LogWarning(ex, "Error fetching videos for show {ShowId} in category {TopicId}", show.Id, topicId);
+                            }
+
+                            if (cancellationToken.IsCancellationRequested)
+                            {
+                                break;
+                            }
+                        }
+
+                        items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+                        _logger.LogInformation("Found {Count} videos for category {TopicId}", items.Count, topicId);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Failed to load category videos");
+                    }
+                }
+            }
+
+            _logger.LogInformation("Returning {Count} channel items for folder {FolderId}", items.Count, query.FolderId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting channel items for folder {FolderId}", query.FolderId);
+        }
+
+        return new ChannelItemResult
+        {
+            Items = items,
+            TotalRecordCount = items.Count
+        };
+    }
+
+    /// <inheritdoc />
+    public string? GetCacheKey(string? userId)
+    {
+        var config = Plugin.Instance?.Configuration;
+        var enabledTopics = config?.EnabledTopics != null && config.EnabledTopics.Count > 0
+            ? string.Join(",", config.EnabledTopics)
+            : "all";
+        return $"{config?.BusinessUnit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}";
+    }
+
+    private async Task<List<ChannelItemInfo>> ConvertUrnsToChannelItems(List<string> urns, CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>();
+        var config = Plugin.Instance?.Configuration;
+
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration is null");
+            return items;
+        }
+
+        _logger.LogInformation("Converting {Count} URNs to channel items", urns.Count);
+
+        using var apiClient = new Api.SRFApiClient(_loggerFactory);
+        int successCount = 0;
+        int failedCount = 0;
+        int expiredCount = 0;
+        int noStreamCount = 0;
+
+        foreach (var urn in urns.Take(50)) // Limit to 50 items per request
+        {
+            try
+            {
+                _logger.LogDebug("Processing URN: {Urn}", urn);
+                var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
+                {
+                    _logger.LogWarning("URN {Urn}: No media composition or chapters found", urn);
+                    failedCount++;
+                    continue;
+                }
+
+                var chapter = mediaComposition.ChapterList[0];
+
+                // Check if content is expired
+                if (_streamResolver.IsContentExpired(chapter))
+                {
+                    _logger.LogDebug("URN {Urn}: Content expired (ValidTo: {ValidTo})", urn, chapter.ValidTo);
+                    expiredCount++;
+                    continue;
+                }
+
+                // Check if content has playable streams
+                if (!_streamResolver.HasPlayableContent(chapter))
+                {
+                    _logger.LogWarning("URN {Urn}: No playable content (likely DRM protected)", urn);
+                    noStreamCount++;
+                    continue;
+                }
+
+                // Generate deterministic GUID from URN
+                var itemId = UrnToGuid(urn);
+
+                var item = new ChannelItemInfo
+                {
+                    Id = itemId,
+                    Name = chapter.Title,
+                    Overview = chapter.Description ?? chapter.Lead,
+                    ImageUrl = chapter.ImageUrl,
+                    Type = ChannelItemType.Media,
+                    ContentType = ChannelMediaContentType.Episode,
+                    MediaType = ChannelMediaType.Video,
+                    DateCreated = chapter.Date?.ToUniversalTime(),
+                    PremiereDate = chapter.Date?.ToUniversalTime(),
+                    ProductionYear = chapter.Date?.Year,
+                    RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
+                    ProviderIds = new Dictionary<string, string>
+                    {
+                        { "SRF", urn }
+                    },
+                    MediaSources = new List<MediaSourceInfo>
+                    {
+                        new MediaSourceInfo
+                        {
+                            Id = itemId,
+                            Name = chapter.Title,
+                            Path = _streamResolver.GetStreamUrl(chapter, config.QualityPreference),
+                            Protocol = MediaBrowser.Model.MediaInfo.MediaProtocol.Http,
+                            Container = "m3u8",
+                            SupportsDirectStream = true,
+                            SupportsDirectPlay = true,
+                            SupportsTranscoding = true,
+                            IsRemote = true,
+                            Type = MediaBrowser.Model.Dto.MediaSourceType.Default,
+                            VideoType = VideoType.VideoFile
+                        }
+                    }
+                };
+
+                // Add series info if available
+                if (mediaComposition.Show != null)
+                {
+                    item.SeriesName = mediaComposition.Show.Title;
+                }
+
+                items.Add(item);
+                successCount++;
+                _logger.LogInformation("URN {Urn}: Successfully converted to channel item - {Title}", urn, chapter.Title);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error converting URN {Urn} to channel item", urn);
+                failedCount++;
+            }
+        }
+
+        _logger.LogInformation(
+            "Conversion complete: {Success} successful, {Failed} failed, {Expired} expired, {NoStream} no stream",
+            successCount,
+            failedCount,
+            expiredCount,
+            noStreamCount);
+
+        return items;
+    }
+
+    /// <summary>
+    /// Generates a deterministic GUID from a URN.
+    /// This ensures the same URN always produces the same GUID.
+    /// MD5 is used for non-cryptographic purposes only (generating IDs).
+    /// </summary>
+    /// <param name="urn">The URN to convert.</param>
+    /// <returns>A deterministic GUID.</returns>
+#pragma warning disable CA5351 // MD5 is used for non-cryptographic purposes (ID generation)
+    private static string UrnToGuid(string urn)
+    {
+        // Use MD5 to generate a deterministic hash from the URN
+        var hash = MD5.HashData(Encoding.UTF8.GetBytes(urn));
+
+        // Convert the first 16 bytes to a GUID
+        var guid = new Guid(hash);
+        return guid.ToString();
+    }
+#pragma warning restore CA5351
+
+    /// <inheritdoc />
+    public bool IsEnabledFor(string userId)
+    {
+        return true;
+    }
+}

Jellyfin.Plugin.SRFPlay/Configuration/PluginConfiguration.cs

@@ -0,0 +1,145 @@
+using MediaBrowser.Model.Plugins;
+
+namespace Jellyfin.Plugin.SRFPlay.Configuration;
+
+/// <summary>
+/// Business unit options for SRF content.
+/// </summary>
+public enum BusinessUnit
+{
+    /// <summary>
+    /// SRF (Swiss Radio and Television - German).
+    /// </summary>
+    SRF,
+
+    /// <summary>
+    /// RTS (Radio Télévision Suisse - French).
+    /// </summary>
+    RTS,
+
+    /// <summary>
+    /// RSI (Radiotelevisione svizzera - Italian).
+    /// </summary>
+    RSI,
+
+    /// <summary>
+    /// RTR (Radiotelevisiun Svizra Rumantscha - Romansh).
+    /// </summary>
+    RTR,
+
+    /// <summary>
+    /// SWI (Swiss World International).
+    /// </summary>
+    SWI
+}
+
+/// <summary>
+/// Quality preference for video streams.
+/// </summary>
+public enum QualityPreference
+{
+    /// <summary>
+    /// Automatic quality selection.
+    /// </summary>
+    Auto,
+
+    /// <summary>
+    /// Standard definition.
+    /// </summary>
+    SD,
+
+    /// <summary>
+    /// High definition.
+    /// </summary>
+    HD
+}
+
+/// <summary>
+/// Plugin configuration.
+/// </summary>
+public class PluginConfiguration : BasePluginConfiguration
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PluginConfiguration"/> class.
+    /// </summary>
+    public PluginConfiguration()
+    {
+        // Set default options
+        BusinessUnit = BusinessUnit.SRF;
+        QualityPreference = QualityPreference.Auto;
+        ContentRefreshIntervalHours = 6;
+        ExpirationCheckIntervalHours = 24;
+        CacheDurationMinutes = 60;
+        EnableLatestContent = true;
+        EnableTrendingContent = true;
+        EnableCategoryFolders = true;
+        EnabledTopics = new System.Collections.Generic.List<string>();
+    }
+
+    /// <summary>
+    /// Gets or sets the business unit to fetch content from.
+    /// </summary>
+    public BusinessUnit BusinessUnit { get; set; }
+
+    /// <summary>
+    /// Gets or sets the preferred video quality.
+    /// </summary>
+    public QualityPreference QualityPreference { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content refresh interval in hours.
+    /// </summary>
+    public int ContentRefreshIntervalHours { get; set; }
+
+    /// <summary>
+    /// Gets or sets the expiration check interval in hours.
+    /// </summary>
+    public int ExpirationCheckIntervalHours { get; set; }
+
+    /// <summary>
+    /// Gets or sets the metadata cache duration in minutes.
+    /// </summary>
+    public int CacheDurationMinutes { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable latest content discovery.
+    /// </summary>
+    public bool EnableLatestContent { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable trending content discovery.
+    /// </summary>
+    public bool EnableTrendingContent { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to use a proxy for API requests.
+    /// </summary>
+    public bool UseProxy { get; set; }
+
+    /// <summary>
+    /// Gets or sets the proxy server address (e.g., http://proxy.example.com:8080).
+    /// </summary>
+    public string ProxyAddress { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the proxy username (optional).
+    /// </summary>
+    public string ProxyUsername { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the proxy password (optional).
+    /// </summary>
+    public string ProxyPassword { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable category/topic folders in the channel.
+    /// </summary>
+    public bool EnableCategoryFolders { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of enabled topic IDs. If empty, all topics are shown.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for configuration serialization")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "Configuration DTO")]
+    public System.Collections.Generic.List<string> EnabledTopics { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Configuration/configPage.html

@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>SRF Play</title>
+</head>
+<body>
+    <div id="SRFPlayConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
+        <div data-role="content">
+            <div class="content-primary">
+                <form id="SRFPlayConfigForm">
+                    <div class="selectContainer">
+                        <label class="selectLabel" for="BusinessUnit">Business Unit</label>
+                        <select is="emby-select" id="BusinessUnit" name="BusinessUnit" class="emby-select-withcolor emby-select">
+                            <option id="optSRF" value="SRF">SRF (German)</option>
+                            <option id="optRTS" value="RTS">RTS (French)</option>
+                            <option id="optRSI" value="RSI">RSI (Italian)</option>
+                            <option id="optRTR" value="RTR">RTR (Romansh)</option>
+                            <option id="optSWI" value="SWI">SWI (International)</option>
+                        </select>
+                        <div class="fieldDescription">Select the Swiss broadcasting unit to fetch content from</div>
+                    </div>
+                    <div class="selectContainer">
+                        <label class="selectLabel" for="QualityPreference">Quality Preference</label>
+                        <select is="emby-select" id="QualityPreference" name="QualityPreference" class="emby-select-withcolor emby-select">
+                            <option id="optAuto" value="Auto">Automatic</option>
+                            <option id="optSD" value="SD">Standard Definition</option>
+                            <option id="optHD" value="HD">High Definition</option>
+                        </select>
+                        <div class="fieldDescription">Preferred video quality for playback</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ContentRefreshIntervalHours">Content Refresh Interval (hours)</label>
+                        <input id="ContentRefreshIntervalHours" name="ContentRefreshIntervalHours" type="number" is="emby-input" min="1" max="168" />
+                        <div class="fieldDescription">How often to check for new content (1-168 hours)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ExpirationCheckIntervalHours">Expiration Check Interval (hours)</label>
+                        <input id="ExpirationCheckIntervalHours" name="ExpirationCheckIntervalHours" type="number" is="emby-input" min="1" max="168" />
+                        <div class="fieldDescription">How often to check for expired content (1-168 hours)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="CacheDurationMinutes">Cache Duration (minutes)</label>
+                        <input id="CacheDurationMinutes" name="CacheDurationMinutes" type="number" is="emby-input" min="5" max="1440" />
+                        <div class="fieldDescription">How long to cache metadata (5-1440 minutes)</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="EnableLatestContent" name="EnableLatestContent" type="checkbox" is="emby-checkbox" />
+                            <span>Enable Latest Content</span>
+                        </label>
+                        <div class="fieldDescription">Automatically discover and add latest videos</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="EnableTrendingContent" name="EnableTrendingContent" type="checkbox" is="emby-checkbox" />
+                            <span>Enable Trending Content</span>
+                        </label>
+                        <div class="fieldDescription">Automatically discover and add trending videos</div>
+                    </div>
+                    <br />
+                    <h2>Proxy Settings</h2>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="UseProxy" name="UseProxy" type="checkbox" is="emby-checkbox" />
+                            <span>Use Proxy</span>
+                        </label>
+                        <div class="fieldDescription">Route all SRF API requests through a proxy server</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyAddress">Proxy Address</label>
+                        <input id="ProxyAddress" name="ProxyAddress" type="text" is="emby-input" />
+                        <div class="fieldDescription">Proxy server address (e.g., http://proxy.example.com:8080 or socks5://proxy.example.com:1080)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyUsername">Proxy Username (Optional)</label>
+                        <input id="ProxyUsername" name="ProxyUsername" type="text" is="emby-input" autocomplete="off" />
+                        <div class="fieldDescription">Username for proxy authentication (leave empty if not required)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyPassword">Proxy Password (Optional)</label>
+                        <input id="ProxyPassword" name="ProxyPassword" type="password" is="emby-input" autocomplete="off" />
+                        <div class="fieldDescription">Password for proxy authentication (leave empty if not required)</div>
+                    </div>
+                    <div>
+                        <button is="emby-button" type="submit" class="raised button-submit block emby-button">
+                            <span>Save</span>
+                        </button>
+                    </div>
+                </form>
+            </div>
+        </div>
+        <script type="text/javascript">
+            var SRFPlayConfig = {
+                pluginUniqueId: 'a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f'
+            };
+
+            document.querySelector('#SRFPlayConfigPage')
+                .addEventListener('pageshow', function() {
+                    Dashboard.showLoadingMsg();
+                    ApiClient.getPluginConfiguration(SRFPlayConfig.pluginUniqueId).then(function (config) {
+                        document.querySelector('#BusinessUnit').value = config.BusinessUnit;
+                        document.querySelector('#QualityPreference').value = config.QualityPreference;
+                        document.querySelector('#ContentRefreshIntervalHours').value = config.ContentRefreshIntervalHours;
+                        document.querySelector('#ExpirationCheckIntervalHours').value = config.ExpirationCheckIntervalHours;
+                        document.querySelector('#CacheDurationMinutes').value = config.CacheDurationMinutes;
+                        document.querySelector('#EnableLatestContent').checked = config.EnableLatestContent;
+                        document.querySelector('#EnableTrendingContent').checked = config.EnableTrendingContent;
+                        document.querySelector('#UseProxy').checked = config.UseProxy || false;
+                        document.querySelector('#ProxyAddress').value = config.ProxyAddress || '';
+                        document.querySelector('#ProxyUsername').value = config.ProxyUsername || '';
+                        document.querySelector('#ProxyPassword').value = config.ProxyPassword || '';
+                        Dashboard.hideLoadingMsg();
+                    });
+                });
+
+            document.querySelector('#SRFPlayConfigForm')
+                .addEventListener('submit', function(e) {
+                Dashboard.showLoadingMsg();
+                ApiClient.getPluginConfiguration(SRFPlayConfig.pluginUniqueId).then(function (config) {
+                    config.BusinessUnit = document.querySelector('#BusinessUnit').value;
+                    config.QualityPreference = document.querySelector('#QualityPreference').value;
+                    config.ContentRefreshIntervalHours = parseInt(document.querySelector('#ContentRefreshIntervalHours').value);
+                    config.ExpirationCheckIntervalHours = parseInt(document.querySelector('#ExpirationCheckIntervalHours').value);
+                    config.CacheDurationMinutes = parseInt(document.querySelector('#CacheDurationMinutes').value);
+                    config.EnableLatestContent = document.querySelector('#EnableLatestContent').checked;
+                    config.EnableTrendingContent = document.querySelector('#EnableTrendingContent').checked;
+                    config.UseProxy = document.querySelector('#UseProxy').checked;
+                    config.ProxyAddress = document.querySelector('#ProxyAddress').value;
+                    config.ProxyUsername = document.querySelector('#ProxyUsername').value;
+                    config.ProxyPassword = document.querySelector('#ProxyPassword').value;
+                    ApiClient.updatePluginConfiguration(SRFPlayConfig.pluginUniqueId, config).then(function (result) {
+                        Dashboard.processPluginConfigurationUpdateResult(result);
+                    });
+                });
+
+                e.preventDefault();
+                return false;
+            });
+        </script>
+    </div>
+</body>
+</html>

Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>Jellyfin.Plugin.SRFPlay</RootNamespace>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Nullable>enable</Nullable>
+    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+    <CodeAnalysisRuleSet>../jellyfin.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Jellyfin.Controller" Version="10.9.11" />
+    <PackageReference Include="Jellyfin.Model" Version="10.9.11" />
+    <PackageReference Include="Socks5" Version="1.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Remove="Configuration\configPage.html" />
+    <EmbeddedResource Include="Configuration\configPage.html" />
+  </ItemGroup>
+
+</Project>

Jellyfin.Plugin.SRFPlay/Plugin.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Plugins;
+using MediaBrowser.Model.Plugins;
+using MediaBrowser.Model.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay;
+
+/// <summary>
+/// The main plugin.
+/// </summary>
+public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Plugin"/> class.
+    /// </summary>
+    /// <param name="applicationPaths">Instance of the <see cref="IApplicationPaths"/> interface.</param>
+    /// <param name="xmlSerializer">Instance of the <see cref="IXmlSerializer"/> interface.</param>
+    public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer)
+        : base(applicationPaths, xmlSerializer)
+    {
+        Instance = this;
+    }
+
+    /// <inheritdoc />
+    public override string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public override Guid Id => Guid.Parse("a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f");
+
+    /// <summary>
+    /// Gets the current plugin instance.
+    /// </summary>
+    public static Plugin? Instance { get; private set; }
+
+    /// <inheritdoc />
+    public IEnumerable<PluginPageInfo> GetPages()
+    {
+        return
+        [
+            new PluginPageInfo
+            {
+                Name = Name,
+                EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Configuration.configPage.html", GetType().Namespace)
+            }
+        ];
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFEpisodeProvider.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides metadata for SRF Play episodes.
+/// </summary>
+public class SRFEpisodeProvider : IRemoteMetadataProvider<Episode, EpisodeInfo>
+{
+    private readonly ILogger<SRFEpisodeProvider> _logger;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly MetadataCache _metadataCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFEpisodeProvider"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    public SRFEpisodeProvider(
+        ILoggerFactory loggerFactory,
+        IHttpClientFactory httpClientFactory,
+        MetadataCache metadataCache)
+    {
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<SRFEpisodeProvider>();
+        _httpClientFactory = httpClientFactory;
+        _metadataCache = metadataCache;
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(EpisodeInfo 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 episode with URN: {Urn}", urn);
+
+                var config = Plugin.Instance?.Configuration;
+                if (config == null)
+                {
+                    return results;
+                }
+
+                // 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 = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                    if (mediaComposition != null)
+                    {
+                        _metadataCache.SetMediaComposition(urn, mediaComposition);
+                    }
+                }
+
+                if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Count > 0)
+                {
+                    var chapter = mediaComposition.ChapterList[0];
+                    results.Add(new RemoteSearchResult
+                    {
+                        Name = chapter.Title,
+                        Overview = chapter.Description ?? chapter.Lead,
+                        ImageUrl = chapter.ImageUrl,
+                        SearchProviderName = Name,
+                        ProviderIds = new Dictionary<string, string>
+                        {
+                            { "SRF", chapter.Urn }
+                        }
+                    });
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error searching for episode: {Name}", searchInfo.Name);
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc />
+    public async Task<MetadataResult<Episode>> GetMetadata(EpisodeInfo info, CancellationToken cancellationToken)
+    {
+        var result = new MetadataResult<Episode>();
+
+        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 episode: {Name}", info.Name);
+                return result;
+            }
+
+            _logger.LogDebug("Fetching metadata for episode URN: {Urn}", urn);
+
+            var config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                return result;
+            }
+
+            // 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 = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition != null)
+                {
+                    _metadataCache.SetMediaComposition(urn, mediaComposition);
+                }
+            }
+
+            if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
+            {
+                _logger.LogWarning("No chapter information found for URN: {Urn}", urn);
+                return result;
+            }
+
+            // Get the first chapter (main video)
+            var chapter = mediaComposition.ChapterList[0];
+
+            result.Item = new Episode
+            {
+                Name = chapter.Title,
+                Overview = chapter.Description ?? chapter.Lead,
+                ProviderIds = new Dictionary<string, string>
+                {
+                    { "SRF", chapter.Urn }
+                }
+            };
+
+            // Set episode and season numbers if available
+            if (chapter.EpisodeNumber.HasValue)
+            {
+                result.Item.IndexNumber = chapter.EpisodeNumber;
+            }
+
+            if (chapter.SeasonNumber.HasValue)
+            {
+                result.Item.ParentIndexNumber = chapter.SeasonNumber;
+            }
+
+            // Set premiere date if available
+            if (chapter.Date.HasValue)
+            {
+                result.Item.PremiereDate = chapter.Date;
+            }
+
+            // Set runtime (convert from milliseconds to ticks)
+            if (chapter.Duration > 0)
+            {
+                result.Item.RunTimeTicks = TimeSpan.FromMilliseconds(chapter.Duration).Ticks;
+            }
+
+            // Set series information if available
+            if (mediaComposition.Show != null)
+            {
+                result.Item.SeriesName = mediaComposition.Show.Title;
+
+                // Set series provider ID on the episode
+                if (!string.IsNullOrEmpty(mediaComposition.Show.Urn))
+                {
+                    result.Item.SetProviderId("SRF_Series", mediaComposition.Show.Urn);
+                }
+            }
+
+            result.HasMetadata = true;
+            _logger.LogDebug("Successfully fetched metadata for episode: {Title}", chapter.Title);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching metadata for episode: {Name}", info.Name);
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException("Image handling is done by SRFImageProvider");
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFImageProvider.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides images for SRF Play content.
+/// </summary>
+public class SRFImageProvider : IRemoteImageProvider, IHasOrder
+{
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly ILogger<SRFImageProvider> _logger;
+    private readonly ILoggerFactory _loggerFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFImageProvider"/> class.
+    /// </summary>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public SRFImageProvider(IHttpClientFactory httpClientFactory, ILoggerFactory loggerFactory)
+    {
+        _httpClientFactory = httpClientFactory;
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<SRFImageProvider>();
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public int Order => 0;
+
+    /// <inheritdoc />
+    public bool Supports(BaseItem item)
+    {
+        // Support movies and episodes for now
+        return item is MediaBrowser.Controller.Entities.Movies.Movie ||
+               item is MediaBrowser.Controller.Entities.TV.Episode ||
+               item is MediaBrowser.Controller.Entities.TV.Series;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<ImageType> GetSupportedImages(BaseItem item)
+    {
+        return new List<ImageType>
+        {
+            ImageType.Primary,
+            ImageType.Backdrop,
+            ImageType.Thumb
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<RemoteImageInfo>> GetImages(BaseItem item, CancellationToken cancellationToken)
+    {
+        var list = new List<RemoteImageInfo>();
+
+        try
+        {
+            // Check if item has SRF URN in provider IDs
+            if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("No SRF URN found for item: {ItemName}", item.Name);
+                return list;
+            }
+
+            _logger.LogDebug("Fetching images for SRF URN: {Urn}", urn);
+
+            // Fetch media composition to get image URLs
+            using var apiClient = new SRFApiClient(_loggerFactory);
+            var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+            if (mediaComposition == null)
+            {
+                _logger.LogWarning("Failed to fetch media composition for URN: {Urn}", urn);
+                return list;
+            }
+
+            // Extract images from chapters
+            if (mediaComposition.ChapterList != null && mediaComposition.ChapterList.Count > 0)
+            {
+                var chapter = mediaComposition.ChapterList[0];
+                if (!string.IsNullOrEmpty(chapter.ImageUrl))
+                {
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = chapter.ImageUrl,
+                        Type = ImageType.Primary,
+                        ProviderName = Name
+                    });
+
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = chapter.ImageUrl,
+                        Type = ImageType.Thumb,
+                        ProviderName = Name
+                    });
+                }
+            }
+
+            // Extract images from show
+            if (mediaComposition.Show != null)
+            {
+                if (!string.IsNullOrEmpty(mediaComposition.Show.ImageUrl))
+                {
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = mediaComposition.Show.ImageUrl,
+                        Type = ImageType.Primary,
+                        ProviderName = Name
+                    });
+                }
+
+                if (!string.IsNullOrEmpty(mediaComposition.Show.BannerImageUrl))
+                {
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = mediaComposition.Show.BannerImageUrl,
+                        Type = ImageType.Backdrop,
+                        ProviderName = Name
+                    });
+                }
+            }
+
+            _logger.LogDebug("Found {Count} images for URN: {Urn}", list.Count, urn);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching images for item: {ItemName}", item.Name);
+        }
+
+        return list;
+    }
+
+    /// <inheritdoc />
+    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    {
+        var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+        return httpClient.GetAsync(new Uri(url), cancellationToken);
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -0,0 +1,184 @@
+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();
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFSeriesProvider.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+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 ILoggerFactory _loggerFactory;
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly MetadataCache _metadataCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFSeriesProvider"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    public SRFSeriesProvider(
+        ILogger<SRFSeriesProvider> logger,
+        ILoggerFactory loggerFactory,
+        IHttpClientFactory httpClientFactory,
+        MetadataCache metadataCache)
+    {
+        _logger = logger;
+        _loggerFactory = loggerFactory;
+        _httpClientFactory = httpClientFactory;
+        _metadataCache = metadataCache;
+    }
+
+    /// <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 config = Plugin.Instance?.Configuration;
+                if (config == null)
+                {
+                    return results;
+                }
+
+                // 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 = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                    if (mediaComposition != null)
+                    {
+                        _metadataCache.SetMediaComposition(urn, mediaComposition);
+                    }
+                }
+
+                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 config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                return result;
+            }
+
+            // 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 = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition != null)
+                {
+                    _metadataCache.SetMediaComposition(urn, mediaComposition);
+                }
+            }
+
+            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");
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ContentRefreshTask.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task for refreshing SRF Play content.
+/// </summary>
+public class ContentRefreshTask : IScheduledTask
+{
+    private readonly ILogger<ContentRefreshTask> _logger;
+    private readonly ContentRefreshService _contentRefreshService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentRefreshTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    public ContentRefreshTask(
+        ILogger<ContentRefreshTask> logger,
+        ContentRefreshService contentRefreshService)
+    {
+        _logger = logger;
+        _contentRefreshService = contentRefreshService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Refresh SRF Play Content";
+
+    /// <inheritdoc />
+    public string Description => "Refreshes latest and trending content from SRF Play";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayContentRefresh";
+
+    /// <inheritdoc />
+    public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play content refresh task");
+        progress?.Report(0);
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                _logger.LogWarning("Plugin configuration not available");
+                return;
+            }
+
+            if (!config.EnableLatestContent && !config.EnableTrendingContent)
+            {
+                _logger.LogInformation("Content refresh is disabled in configuration");
+                progress?.Report(100);
+                return;
+            }
+
+            // Refresh latest content
+            if (config.EnableLatestContent)
+            {
+                _logger.LogInformation("Refreshing latest content");
+                progress?.Report(25);
+                await _contentRefreshService.RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            // Refresh trending content
+            if (config.EnableTrendingContent)
+            {
+                _logger.LogInformation("Refreshing trending content");
+                progress?.Report(75);
+                await _contentRefreshService.RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            progress?.Report(100);
+            _logger.LogInformation("SRF Play content refresh task completed successfully");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play content refresh task");
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        var config = Plugin.Instance?.Configuration;
+        var intervalHours = config?.ContentRefreshIntervalHours ?? 6;
+
+        // Run every X hours as configured
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromHours(intervalHours).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ExpirationCheckTask.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task for checking and removing expired SRF Play content.
+/// </summary>
+public class ExpirationCheckTask : IScheduledTask
+{
+    private readonly ILogger<ExpirationCheckTask> _logger;
+    private readonly ContentExpirationService _expirationService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExpirationCheckTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="expirationService">The content expiration service.</param>
+    public ExpirationCheckTask(
+        ILogger<ExpirationCheckTask> logger,
+        ContentExpirationService expirationService)
+    {
+        _logger = logger;
+        _expirationService = expirationService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Check SRF Play Content Expiration";
+
+    /// <inheritdoc />
+    public string Description => "Checks for expired SRF Play content and removes it from the library";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayExpirationCheck";
+
+    /// <inheritdoc />
+    public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play expiration check task");
+        progress?.Report(0);
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                _logger.LogWarning("Plugin configuration not available");
+                return;
+            }
+
+            // Get expiration statistics first
+            progress?.Report(25);
+            var (total, expired, expiringSoon) = await _expirationService.GetExpirationStatisticsAsync(cancellationToken).ConfigureAwait(false);
+
+            _logger.LogInformation(
+                "Expiration statistics - Total: {Total}, Expired: {Expired}, Expiring Soon: {ExpiringSoon}",
+                total,
+                expired,
+                expiringSoon);
+
+            if (expired == 0)
+            {
+                _logger.LogInformation("No expired content found");
+                progress?.Report(100);
+                return;
+            }
+
+            // Remove expired content
+            progress?.Report(50);
+            var removedCount = await _expirationService.CheckAndRemoveExpiredContentAsync(cancellationToken).ConfigureAwait(false);
+
+            progress?.Report(100);
+            _logger.LogInformation("SRF Play expiration check task completed. Removed {Count} expired items", removedCount);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play expiration check task");
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        var config = Plugin.Instance?.Configuration;
+        var intervalHours = config?.ExpirationCheckIntervalHours ?? 24;
+
+        // Run daily at 3 AM or every X hours as configured
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerDaily,
+                TimeOfDayTicks = TimeSpan.FromHours(3).Ticks
+            },
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromHours(intervalHours).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ServiceRegistrator.cs

@@ -0,0 +1,44 @@
+using Jellyfin.Plugin.SRFPlay.Channels;
+using Jellyfin.Plugin.SRFPlay.Providers;
+using Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay;
+
+/// <summary>
+/// Service registrator for dependency injection.
+/// </summary>
+public class ServiceRegistrator : IPluginServiceRegistrator
+{
+    /// <inheritdoc />
+    public void RegisterServices(IServiceCollection serviceCollection, IServerApplicationHost applicationHost)
+    {
+        // Register services as singletons
+        serviceCollection.AddSingleton<MetadataCache>();
+        serviceCollection.AddSingleton<StreamUrlResolver>();
+        serviceCollection.AddSingleton<ContentExpirationService>();
+        serviceCollection.AddSingleton<ContentRefreshService>();
+        serviceCollection.AddSingleton<CategoryService>();
+
+        // Register metadata providers
+        serviceCollection.AddSingleton<SRFSeriesProvider>();
+        serviceCollection.AddSingleton<SRFEpisodeProvider>();
+        serviceCollection.AddSingleton<SRFImageProvider>();
+
+        // Register media source provider
+        serviceCollection.AddSingleton<SRFMediaProvider>();
+
+        // Register scheduled tasks
+        serviceCollection.AddSingleton<IScheduledTask, ContentRefreshTask>();
+        serviceCollection.AddSingleton<IScheduledTask, ExpirationCheckTask>();
+
+        // Register channel - must register as IChannel interface for Jellyfin to discover it
+        serviceCollection.AddSingleton<IChannel, SRFPlayChannel>();
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/CategoryService.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for managing topic/category data and filtering.
+/// </summary>
+public class CategoryService
+{
+    private readonly ILogger _logger;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly TimeSpan _topicsCacheDuration = TimeSpan.FromHours(24);
+    private Dictionary<string, PlayV3Topic>? _topicsCache;
+    private DateTime _topicsCacheExpiry = DateTime.MinValue;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CategoryService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public CategoryService(ILoggerFactory loggerFactory)
+    {
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<CategoryService>();
+    }
+
+    /// <summary>
+    /// Gets all topics for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of topics.</returns>
+    public async Task<List<PlayV3Topic>> GetTopicsAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        // Return cached topics if still valid
+        if (_topicsCache != null && DateTime.UtcNow < _topicsCacheExpiry)
+        {
+            _logger.LogDebug("Returning cached topics for business unit: {BusinessUnit}", businessUnit);
+            return _topicsCache.Values.ToList();
+        }
+
+        _logger.LogInformation("Fetching topics for business unit: {BusinessUnit}", businessUnit);
+        using var apiClient = new SRFApiClient(_loggerFactory);
+        var topics = await apiClient.GetAllTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+        if (topics != null && topics.Count > 0)
+        {
+            // Cache topics by ID for quick lookups
+            _topicsCache = topics
+                .Where(t => !string.IsNullOrEmpty(t.Id))
+                .ToDictionary(t => t.Id!, t => t);
+            _topicsCacheExpiry = DateTime.UtcNow.Add(_topicsCacheDuration);
+
+            _logger.LogInformation("Cached {Count} topics for business unit: {BusinessUnit}", _topicsCache.Count, businessUnit);
+        }
+
+        return topics ?? new List<PlayV3Topic>();
+    }
+
+    /// <summary>
+    /// Gets a topic by ID.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The topic, or null if not found.</returns>
+    public async Task<PlayV3Topic?> GetTopicByIdAsync(string topicId, string businessUnit, CancellationToken cancellationToken = default)
+    {
+        // Ensure topics are loaded
+        if (_topicsCache == null || DateTime.UtcNow >= _topicsCacheExpiry)
+        {
+            await GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+        }
+
+        return _topicsCache?.GetValueOrDefault(topicId);
+    }
+
+    /// <summary>
+    /// Filters shows by topic ID.
+    /// </summary>
+    /// <param name="shows">The shows to filter.</param>
+    /// <param name="topicId">The topic ID to filter by.</param>
+    /// <returns>Filtered list of shows.</returns>
+    public IReadOnlyList<PlayV3Show> FilterShowsByTopic(IReadOnlyList<PlayV3Show> shows, string topicId)
+    {
+        if (string.IsNullOrEmpty(topicId))
+        {
+            return shows;
+        }
+
+        return shows
+            .Where(s => s.TopicList != null && s.TopicList.Contains(topicId))
+            .ToList();
+    }
+
+    /// <summary>
+    /// Groups shows by their topics.
+    /// </summary>
+    /// <param name="shows">The shows to group.</param>
+    /// <returns>Dictionary mapping topic IDs to shows.</returns>
+    public IReadOnlyDictionary<string, List<PlayV3Show>> GroupShowsByTopics(IReadOnlyList<PlayV3Show> shows)
+    {
+        var groupedShows = new Dictionary<string, List<PlayV3Show>>();
+
+        foreach (var show in shows)
+        {
+            if (show.TopicList == null || show.TopicList.Count == 0)
+            {
+                continue;
+            }
+
+            foreach (var topicId in show.TopicList)
+            {
+                if (!groupedShows.TryGetValue(topicId, out var showList))
+                {
+                    showList = new List<PlayV3Show>();
+                    groupedShows[topicId] = showList;
+                }
+
+                showList.Add(show);
+            }
+        }
+
+        return groupedShows;
+    }
+
+    /// <summary>
+    /// Gets shows for a specific topic, sorted by number of episodes.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="maxResults">Maximum number of results to return.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of shows for the topic.</returns>
+    public async Task<List<PlayV3Show>> GetShowsByTopicAsync(
+        string topicId,
+        string businessUnit,
+        int maxResults = 50,
+        CancellationToken cancellationToken = default)
+    {
+        using var apiClient = new SRFApiClient(_loggerFactory);
+        var allShows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+        if (allShows == null || allShows.Count == 0)
+        {
+            _logger.LogWarning("No shows available for business unit: {BusinessUnit}", businessUnit);
+            return new List<PlayV3Show>();
+        }
+
+        var filteredShows = FilterShowsByTopic(allShows, topicId)
+            .Where(s => s.NumberOfEpisodes > 0)
+            .OrderByDescending(s => s.NumberOfEpisodes)
+            .Take(maxResults)
+            .ToList();
+
+        _logger.LogDebug("Found {Count} shows for topic {TopicId}", filteredShows.Count, topicId);
+        return filteredShows;
+    }
+
+    /// <summary>
+    /// Gets video count for each topic.
+    /// </summary>
+    /// <param name="shows">The shows to analyze.</param>
+    /// <returns>Dictionary mapping topic IDs to video counts.</returns>
+    public IReadOnlyDictionary<string, int> GetVideoCountByTopic(IReadOnlyList<PlayV3Show> shows)
+    {
+        var topicCounts = new Dictionary<string, int>();
+
+        foreach (var show in shows)
+        {
+            if (show.TopicList == null || show.TopicList.Count == 0)
+            {
+                continue;
+            }
+
+            foreach (var topicId in show.TopicList)
+            {
+                if (!topicCounts.TryGetValue(topicId, out var count))
+                {
+                    count = 0;
+                }
+
+                topicCounts[topicId] = count + show.NumberOfEpisodes;
+            }
+        }
+
+        return topicCounts;
+    }
+
+    /// <summary>
+    /// Clears the topics cache.
+    /// </summary>
+    public void ClearCache()
+    {
+        _topicsCache = null;
+        _topicsCacheExpiry = DateTime.MinValue;
+        _logger.LogInformation("Topics cache cleared");
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/ContentExpirationService.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for managing content expiration.
+/// </summary>
+public class ContentExpirationService
+{
+    private readonly ILogger<ContentExpirationService> _logger;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly ILibraryManager _libraryManager;
+    private readonly StreamUrlResolver _streamResolver;
+    private readonly MetadataCache _metadataCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentExpirationService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    public ContentExpirationService(
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager,
+        StreamUrlResolver streamResolver,
+        MetadataCache metadataCache)
+    {
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<ContentExpirationService>();
+        _libraryManager = libraryManager;
+        _streamResolver = streamResolver;
+        _metadataCache = metadataCache;
+    }
+
+    /// <summary>
+    /// Checks for expired content and removes it from the library.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The number of items removed.</returns>
+    public async Task<int> CheckAndRemoveExpiredContentAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting content expiration check");
+        var removedCount = 0;
+
+        try
+        {
+            // Get all items with SRF provider ID
+            var query = new InternalItemsQuery
+            {
+                HasAnyProviderId = new Dictionary<string, string> { { "SRF", string.Empty } },
+                IsVirtualItem = false
+            };
+
+            var items = _libraryManager.GetItemList(query);
+            _logger.LogDebug("Found {Count} SRF items to check for expiration", items.Count);
+
+            foreach (var item in items)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+
+                try
+                {
+                    if (await IsItemExpiredAsync(item, cancellationToken).ConfigureAwait(false))
+                    {
+                        _logger.LogInformation("Removing expired item: {Name} (URN: {Urn})", item.Name, item.ProviderIds.GetValueOrDefault("SRF"));
+
+                        // Delete the item from library
+                        _libraryManager.DeleteItem(
+                            item,
+                            new DeleteOptions
+                            {
+                                DeleteFileLocation = false
+                            },
+                            false);
+
+                        removedCount++;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error checking expiration for item: {Name}", item.Name);
+                }
+            }
+
+            _logger.LogInformation("Content expiration check completed. Removed {Count} expired items", removedCount);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during content expiration check");
+        }
+
+        return removedCount;
+    }
+
+    /// <summary>
+    /// Checks if an item is expired.
+    /// </summary>
+    /// <param name="item">The item to check.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>True if the item is expired.</returns>
+    private async Task<bool> IsItemExpiredAsync(BaseItem item, CancellationToken cancellationToken)
+    {
+        var urn = item.ProviderIds.GetValueOrDefault("SRF");
+        if (string.IsNullOrEmpty(urn))
+        {
+            return false;
+        }
+
+        var config = Plugin.Instance?.Configuration;
+        if (config == null)
+        {
+            return false;
+        }
+
+        // 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 = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+            if (mediaComposition != null)
+            {
+                _metadataCache.SetMediaComposition(urn, mediaComposition);
+            }
+        }
+
+        if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
+        {
+            // If we can't fetch the content, consider it expired
+            _logger.LogWarning("Could not fetch media composition for URN: {Urn}, treating as expired", urn);
+            return true;
+        }
+
+        var chapter = mediaComposition.ChapterList[0];
+        var isExpired = _streamResolver.IsContentExpired(chapter);
+
+        if (isExpired)
+        {
+            _logger.LogDebug("Item {Name} is expired (ValidTo: {ValidTo})", item.Name, chapter.ValidTo);
+        }
+
+        return isExpired;
+    }
+
+    /// <summary>
+    /// Gets statistics about content expiration.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Tuple with total count, expired count, and items expiring soon.</returns>
+    public async Task<(int Total, int Expired, int ExpiringSoon)> GetExpirationStatisticsAsync(CancellationToken cancellationToken)
+    {
+        var total = 0;
+        var expired = 0;
+        var expiringSoon = 0;
+        var soonThreshold = DateTime.UtcNow.AddDays(7); // Items expiring within 7 days
+
+        try
+        {
+            var query = new InternalItemsQuery
+            {
+                HasAnyProviderId = new Dictionary<string, string> { { "SRF", string.Empty } },
+                IsVirtualItem = false
+            };
+
+            var items = _libraryManager.GetItemList(query);
+            total = items.Count;
+
+            foreach (var item in items)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+
+                try
+                {
+                    var urn = item.ProviderIds.GetValueOrDefault("SRF");
+                    if (string.IsNullOrEmpty(urn))
+                    {
+                        continue;
+                    }
+
+                    var config = Plugin.Instance?.Configuration;
+                    if (config == null)
+                    {
+                        continue;
+                    }
+
+                    var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
+
+                    if (mediaComposition == null)
+                    {
+                        using var apiClient = new SRFApiClient(_loggerFactory);
+                        mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                        if (mediaComposition != null)
+                        {
+                            _metadataCache.SetMediaComposition(urn, mediaComposition);
+                        }
+                    }
+
+                    if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Count > 0)
+                    {
+                        var chapter = mediaComposition.ChapterList[0];
+
+                        if (_streamResolver.IsContentExpired(chapter))
+                        {
+                            expired++;
+                        }
+                        else if (chapter.ValidTo.HasValue && chapter.ValidTo.Value.ToUniversalTime() <= soonThreshold)
+                        {
+                            expiringSoon++;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error checking expiration statistics for item: {Name}", item.Name);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting expiration statistics");
+        }
+
+        return (total, expired, expiringSoon);
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/ContentRefreshService.cs

@@ -0,0 +1,306 @@
+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.Api.Models;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for refreshing content from SRF API.
+/// </summary>
+public class ContentRefreshService
+{
+    private readonly ILogger<ContentRefreshService> _logger;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MetadataCache _metadataCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentRefreshService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    public ContentRefreshService(
+        ILoggerFactory loggerFactory,
+        MetadataCache metadataCache)
+    {
+        _loggerFactory = loggerFactory;
+        _logger = loggerFactory.CreateLogger<ContentRefreshService>();
+        _metadataCache = metadataCache;
+    }
+
+    /// <summary>
+    /// Refreshes latest content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for new content.</returns>
+    public async Task<List<string>> RefreshLatestContentAsync(CancellationToken cancellationToken)
+    {
+        var urns = new List<string>();
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null || !config.EnableLatestContent)
+            {
+                _logger.LogDebug("Latest content refresh is disabled");
+                return urns;
+            }
+
+            _logger.LogInformation("Refreshing latest content for business unit: {BusinessUnit}", config.BusinessUnit);
+
+            using var apiClient = new SRFApiClient(_loggerFactory);
+            var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
+
+            // Get all shows from Play v3 API
+            var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+            if (shows == null || shows.Count == 0)
+            {
+                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
+                return urns;
+            }
+
+            _logger.LogInformation("Found {Count} shows, fetching latest episodes from each", shows.Count);
+
+            // Get latest episodes from each show (limit to 20 shows to avoid overwhelming)
+            var showsToFetch = shows.Where(s => s.NumberOfEpisodes > 0)
+                .OrderByDescending(s => s.NumberOfEpisodes)
+                .Take(20)
+                .ToList();
+
+            foreach (var show in showsToFetch)
+            {
+                if (show.Id == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
+                    if (videos != null && videos.Count > 0)
+                    {
+                        _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos", show.Title, show.Id, videos.Count);
+
+                        // Filter to videos that are actually published (validFrom in the past)
+                        var now = DateTime.UtcNow;
+                        var publishedVideos = videos.Where(v =>
+                            v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
+
+                        _logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos", show.Title, publishedVideos.Count, videos.Count);
+
+                        if (publishedVideos.Count > 0)
+                        {
+                            // Take only the most recent published video from each show
+                            var latestVideo = publishedVideos.OrderByDescending(v => v.Date).FirstOrDefault();
+                            if (latestVideo?.Urn != null)
+                            {
+                                urns.Add(latestVideo.Urn);
+                                _logger.LogInformation(
+                                    "Added latest video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
+                                    show.Title,
+                                    latestVideo.Title,
+                                    latestVideo.Urn,
+                                    latestVideo.Date,
+                                    latestVideo.ValidFrom,
+                                    latestVideo.ValidTo);
+                            }
+                            else
+                            {
+                                _logger.LogWarning("Show {Show}: Latest video has null URN", show.Title);
+                            }
+                        }
+                        else
+                        {
+                            _logger.LogDebug("Show {Show} has no published videos yet", show.Title);
+                        }
+                    }
+                    else
+                    {
+                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API", show.Title, show.Id);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
+                }
+
+                // Respect cancellation
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+            }
+
+            _logger.LogInformation("Refreshed {Count} latest content items from {ShowCount} shows", urns.Count, showsToFetch.Count);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error refreshing latest content");
+        }
+
+        return urns;
+    }
+
+    /// <summary>
+    /// Refreshes trending content from SRF API using Play v3.
+    /// Gets videos from shows with the most episodes.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for trending content.</returns>
+    public async Task<List<string>> RefreshTrendingContentAsync(CancellationToken cancellationToken)
+    {
+        var urns = new List<string>();
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null || !config.EnableTrendingContent)
+            {
+                _logger.LogDebug("Trending content refresh is disabled");
+                return urns;
+            }
+
+            _logger.LogInformation("Refreshing trending content for business unit: {BusinessUnit}", config.BusinessUnit);
+
+            using var apiClient = new SRFApiClient(_loggerFactory);
+            var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
+
+            // Get all shows from Play v3 API
+            var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+            if (shows == null || shows.Count == 0)
+            {
+                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
+                return urns;
+            }
+
+            _logger.LogInformation("Found {Count} shows, fetching popular content", shows.Count);
+
+            // Get videos from popular shows (those with many episodes)
+            var popularShows = shows.Where(s => s.NumberOfEpisodes > 10)
+                .OrderByDescending(s => s.NumberOfEpisodes)
+                .Take(15)
+                .ToList();
+
+            foreach (var show in popularShows)
+            {
+                if (show.Id == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
+                    if (videos != null && videos.Count > 0)
+                    {
+                        _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos for trending", show.Title, show.Id, videos.Count);
+
+                        // Filter to videos that are actually published (validFrom in the past)
+                        var now = DateTime.UtcNow;
+                        var publishedVideos = videos.Where(v =>
+                            v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
+
+                        _logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos for trending", show.Title, publishedVideos.Count, videos.Count);
+
+                        if (publishedVideos.Count > 0)
+                        {
+                            // Take 2 recent published videos from each popular show
+                            var recentVideos = publishedVideos.OrderByDescending(v => v.Date).Take(2);
+                            foreach (var video in recentVideos)
+                            {
+                                if (video.Urn != null)
+                                {
+                                    urns.Add(video.Urn);
+                                    _logger.LogInformation(
+                                        "Added trending video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
+                                        show.Title,
+                                        video.Title,
+                                        video.Urn,
+                                        video.Date,
+                                        video.ValidFrom,
+                                        video.ValidTo);
+                                }
+                                else
+                                {
+                                    _logger.LogWarning("Show {Show}: Trending video has null URN - {Title}", show.Title, video.Title);
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API for trending", show.Title, show.Id);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
+                }
+
+                // Respect cancellation
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+            }
+
+            _logger.LogInformation("Refreshed {Count} trending content items from {ShowCount} shows", urns.Count, popularShows.Count);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error refreshing trending content");
+        }
+
+        return urns;
+    }
+
+    /// <summary>
+    /// Refreshes all content (latest and trending).
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Tuple with counts of latest and trending items.</returns>
+    public async Task<(int LatestCount, int TrendingCount)> RefreshAllContentAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting full content refresh");
+
+        var latestUrns = await RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
+        var trendingUrns = await RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
+
+        var latestCount = latestUrns.Count;
+        var trendingCount = trendingUrns.Count;
+
+        _logger.LogInformation(
+            "Content refresh completed. Latest: {LatestCount}, Trending: {TrendingCount}",
+            latestCount,
+            trendingCount);
+
+        return (latestCount, trendingCount);
+    }
+
+    /// <summary>
+    /// Gets content recommendations (combines latest and trending).
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of recommended URNs.</returns>
+    public async Task<List<string>> GetRecommendedContentAsync(CancellationToken cancellationToken)
+    {
+        var recommendations = new HashSet<string>();
+
+        var latestUrns = await RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
+        var trendingUrns = await RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
+
+        foreach (var urn in latestUrns.Concat(trendingUrns))
+        {
+            recommendations.Add(urn);
+        }
+
+        _logger.LogInformation("Generated {Count} content recommendations", recommendations.Count);
+        return recommendations.ToList();
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/MetadataCache.cs

@@ -0,0 +1,236 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for caching metadata from SRF API.
+/// </summary>
+public sealed class MetadataCache : IDisposable
+{
+    private readonly ILogger<MetadataCache> _logger;
+    private readonly ConcurrentDictionary<string, CacheEntry<MediaComposition>> _mediaCompositionCache;
+    private readonly ReaderWriterLockSlim _lock;
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MetadataCache"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    public MetadataCache(ILogger<MetadataCache> logger)
+    {
+        _logger = logger;
+        _mediaCompositionCache = new ConcurrentDictionary<string, CacheEntry<MediaComposition>>();
+        _lock = new ReaderWriterLockSlim();
+    }
+
+    /// <summary>
+    /// Disposes resources.
+    /// </summary>
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            _lock?.Dispose();
+            _disposed = true;
+        }
+    }
+
+    /// <summary>
+    /// Gets cached media composition by URN.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+    /// <returns>The cached media composition, or null if not found or expired.</returns>
+    public MediaComposition? GetMediaComposition(string urn, int cacheDurationMinutes)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            return null;
+        }
+
+        try
+        {
+            _lock.EnterReadLock();
+            try
+            {
+                if (_mediaCompositionCache.TryGetValue(urn, out var entry))
+                {
+                    if (entry.IsValid(cacheDurationMinutes))
+                    {
+                        _logger.LogDebug("Cache hit for URN: {Urn}", urn);
+                        return entry.Value;
+                    }
+
+                    _logger.LogDebug("Cache entry expired for URN: {Urn}", urn);
+                }
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            return null;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Sets media composition in cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="mediaComposition">The media composition to cache.</param>
+    public void SetMediaComposition(string urn, MediaComposition mediaComposition)
+    {
+        if (string.IsNullOrEmpty(urn) || mediaComposition == null)
+        {
+            return;
+        }
+
+        try
+        {
+            _lock.EnterWriteLock();
+            try
+            {
+                var entry = new CacheEntry<MediaComposition>(mediaComposition);
+                _mediaCompositionCache.AddOrUpdate(urn, entry, (key, oldValue) => entry);
+                _logger.LogDebug("Cached media composition for URN: {Urn}", urn);
+            }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            // Cache is disposed, ignore
+        }
+    }
+
+    /// <summary>
+    /// Removes media composition from cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    public void RemoveMediaComposition(string urn)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            return;
+        }
+
+        try
+        {
+            _lock.EnterWriteLock();
+            try
+            {
+                if (_mediaCompositionCache.TryRemove(urn, out _))
+                {
+                    _logger.LogDebug("Removed cached media composition for URN: {Urn}", urn);
+                }
+            }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            // Cache is disposed, ignore
+        }
+    }
+
+    /// <summary>
+    /// Clears all cached data.
+    /// </summary>
+    public void Clear()
+    {
+        try
+        {
+            _lock.EnterWriteLock();
+            try
+            {
+                _mediaCompositionCache.Clear();
+                _logger.LogInformation("Cleared metadata cache");
+            }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            // Cache is disposed, ignore
+        }
+    }
+
+    /// <summary>
+    /// Gets the cache statistics.
+    /// </summary>
+    /// <returns>A tuple with cache count and size estimate.</returns>
+    public (int Count, long SizeEstimate) GetStatistics()
+    {
+        try
+        {
+            _lock.EnterReadLock();
+            try
+            {
+                var count = _mediaCompositionCache.Count;
+                // Rough estimate: average 50KB per entry
+                var sizeEstimate = count * 50L * 1024;
+                return (count, sizeEstimate);
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            return (0, 0);
+        }
+    }
+
+    /// <summary>
+    /// Represents a cached entry with timestamp.
+    /// </summary>
+    /// <typeparam name="T">The type of cached value.</typeparam>
+    private sealed class CacheEntry<T>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CacheEntry{T}"/> class.
+        /// </summary>
+        /// <param name="value">The value to cache.</param>
+        public CacheEntry(T value)
+        {
+            Value = value;
+            Timestamp = DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Gets the cached value.
+        /// </summary>
+        public T Value { get; }
+
+        /// <summary>
+        /// Gets the timestamp when the entry was created.
+        /// </summary>
+        public DateTime Timestamp { get; }
+
+        /// <summary>
+        /// Checks if the cache entry is still valid.
+        /// </summary>
+        /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+        /// <returns>True if the entry is still valid.</returns>
+        public bool IsValid(int cacheDurationMinutes)
+        {
+            var expirationTime = Timestamp.AddMinutes(cacheDurationMinutes);
+            return DateTime.UtcNow < expirationTime;
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/StreamUrlResolver.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Linq;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for resolving stream URLs from media composition resources.
+/// </summary>
+public class StreamUrlResolver
+{
+    private readonly ILogger<StreamUrlResolver> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamUrlResolver"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    public StreamUrlResolver(ILogger<StreamUrlResolver> logger)
+    {
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Gets the best stream URL from a chapter based on quality preference.
+    /// </summary>
+    /// <param name="chapter">The chapter containing resources.</param>
+    /// <param name="qualityPreference">The quality preference.</param>
+    /// <returns>The stream URL, or null if no suitable stream found.</returns>
+    public string? GetStreamUrl(Chapter chapter, QualityPreference qualityPreference)
+    {
+        if (chapter?.ResourceList == null || chapter.ResourceList.Count == 0)
+        {
+            _logger.LogWarning("No resources found for chapter: {ChapterId}", chapter?.Id);
+            return null;
+        }
+
+        _logger.LogInformation(
+            "Processing chapter {ChapterId} with {ResourceCount} resources",
+            chapter.Id,
+            chapter.ResourceList.Count);
+
+        // Filter out DRM-protected content
+        var nonDrmResources = chapter.ResourceList
+            .Where(r => r.DrmList == null || r.DrmList.ToString() == "[]")
+            .ToList();
+
+        _logger.LogInformation(
+            "Chapter {ChapterId}: Total resources={Total}, Non-DRM resources={NonDrm}",
+            chapter.Id,
+            chapter.ResourceList.Count,
+            nonDrmResources.Count);
+
+        if (nonDrmResources.Count == 0)
+        {
+            _logger.LogWarning("All resources for chapter {ChapterId} require DRM", chapter.Id);
+            // Log what DRM types are present
+            foreach (var resource in chapter.ResourceList)
+            {
+                _logger.LogDebug(
+                    "DRM resource: Protocol={Protocol}, Streaming={Streaming}, DRM={Drm}",
+                    resource.Protocol,
+                    resource.Streaming,
+                    resource.DrmList);
+            }
+
+            return null;
+        }
+
+        // Prefer HLS protocol
+        var hlsResources = nonDrmResources
+            .Where(r => string.Equals(r.Protocol, "HLS", StringComparison.OrdinalIgnoreCase) ||
+                       string.Equals(r.Streaming, "HLS", StringComparison.OrdinalIgnoreCase) ||
+                       r.Url.Contains(".m3u8", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        _logger.LogInformation(
+            "Chapter {ChapterId}: HLS resources found={HlsCount}",
+            chapter.Id,
+            hlsResources.Count);
+
+        if (hlsResources.Count == 0)
+        {
+            _logger.LogWarning("No HLS resources found for chapter: {ChapterId}", chapter.Id);
+            // Log available protocols
+            foreach (var resource in nonDrmResources)
+            {
+                _logger.LogDebug(
+                    "Non-HLS resource: Protocol={Protocol}, Streaming={Streaming}, URL={Url}",
+                    resource.Protocol,
+                    resource.Streaming,
+                    resource.Url);
+            }
+
+            // Fallback to any available non-DRM resource
+            var fallbackResource = nonDrmResources.FirstOrDefault();
+            if (fallbackResource != null)
+            {
+                _logger.LogInformation(
+                    "Using fallback resource for chapter {ChapterId}: {Url}",
+                    chapter.Id,
+                    fallbackResource.Url);
+            }
+
+            return fallbackResource?.Url;
+        }
+
+        // Select based on quality preference
+        Resource? selectedResource = qualityPreference switch
+        {
+            QualityPreference.HD => SelectHDResource(hlsResources) ?? SelectBestAvailableResource(hlsResources),
+            QualityPreference.SD => SelectSDResource(hlsResources) ?? SelectBestAvailableResource(hlsResources),
+            QualityPreference.Auto => SelectBestAvailableResource(hlsResources),
+            _ => SelectBestAvailableResource(hlsResources)
+        };
+
+        if (selectedResource != null)
+        {
+            _logger.LogDebug(
+                "Selected stream for chapter {ChapterId}: Quality={Quality}, Protocol={Protocol}, URL={Url}",
+                chapter.Id,
+                selectedResource.Quality,
+                selectedResource.Protocol,
+                selectedResource.Url);
+            return selectedResource.Url;
+        }
+
+        _logger.LogWarning("Could not select appropriate stream for chapter: {ChapterId}", chapter.Id);
+        return null;
+    }
+
+    /// <summary>
+    /// Checks if a chapter has non-DRM playable content.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if playable content is available.</returns>
+    public bool HasPlayableContent(Chapter chapter)
+    {
+        if (chapter?.ResourceList == null || chapter.ResourceList.Count == 0)
+        {
+            return false;
+        }
+
+        return chapter.ResourceList.Any(r => r.DrmList == null || r.DrmList.ToString() == "[]");
+    }
+
+    /// <summary>
+    /// Checks if content is expired based on ValidTo date.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if the content is expired.</returns>
+    public bool IsContentExpired(Chapter chapter)
+    {
+        if (chapter?.ValidTo == null)
+        {
+            return false;
+        }
+
+        return DateTime.UtcNow > chapter.ValidTo.Value.ToUniversalTime();
+    }
+
+    private Resource? SelectHDResource(System.Collections.Generic.List<Resource> resources)
+    {
+        return resources.FirstOrDefault(r =>
+            string.Equals(r.Quality, "HD", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "1080", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "720", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private Resource? SelectSDResource(System.Collections.Generic.List<Resource> resources)
+    {
+        return resources.FirstOrDefault(r =>
+            string.Equals(r.Quality, "SD", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "480", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "360", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private Resource? SelectBestAvailableResource(System.Collections.Generic.List<Resource> resources)
+    {
+        // Try HD first
+        var hdResource = SelectHDResource(resources);
+        if (hdResource != null)
+        {
+            return hdResource;
+        }
+
+        // Fall back to SD
+        var sdResource = SelectSDResource(resources);
+        if (sdResource != null)
+        {
+            return sdResource;
+        }
+
+        // Return first available
+        return resources.FirstOrDefault();
+    }
+}