jellyLMS/Jellyfin.Plugin.JellyLMS/Services/LmsPlayerManager.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Jellyfin.Plugin.JellyLMS.Models;
using Microsoft.Extensions.Logging;

namespace Jellyfin.Plugin.JellyLMS.Services;

/// <summary>
/// Manages LMS player discovery and state tracking.
/// </summary>
public class LmsPlayerManager
{
    private readonly ILogger<LmsPlayerManager> _logger;
    private readonly ILmsApiClient _lmsClient;
    private readonly ConcurrentDictionary<string, LmsPlayer> _players = new();
    private DateTime _lastRefresh = DateTime.MinValue;
    private readonly TimeSpan _cacheExpiry = TimeSpan.FromSeconds(30);

    /// <summary>
    /// Initializes a new instance of the <see cref="LmsPlayerManager"/> class.
    /// </summary>
    /// <param name="logger">The logger instance.</param>
    /// <param name="lmsClient">The LMS API client.</param>
    public LmsPlayerManager(ILogger<LmsPlayerManager> logger, ILmsApiClient lmsClient)
    {
        _logger = logger;
        _lmsClient = lmsClient;
    }

    /// <summary>
    /// Gets all known LMS players, refreshing if cache is stale.
    /// </summary>
    /// <param name="forceRefresh">Force a refresh from LMS.</param>
    /// <returns>List of LMS players.</returns>
    public async Task<List<LmsPlayer>> GetPlayersAsync(bool forceRefresh = false)
    {
        if (!forceRefresh && DateTime.UtcNow - _lastRefresh < _cacheExpiry && _players.Count > 0)
        {
            return _players.Values.ToList();
        }

        await RefreshPlayersAsync().ConfigureAwait(false);
        return _players.Values.ToList();
    }

    /// <summary>
    /// Gets a specific player by MAC address.
    /// </summary>
    /// <param name="macAddress">The player's MAC address.</param>
    /// <returns>The player, or null if not found.</returns>
    public async Task<LmsPlayer?> GetPlayerAsync(string macAddress)
    {
        if (_players.TryGetValue(macAddress, out var player))
        {
            return player;
        }

        await RefreshPlayersAsync().ConfigureAwait(false);
        return _players.GetValueOrDefault(macAddress);
    }

    /// <summary>
    /// Refreshes the player list from LMS.
    /// </summary>
    /// <returns>A task representing the operation.</returns>
    public async Task RefreshPlayersAsync()
    {
        try
        {
            var players = await _lmsClient.GetPlayersAsync().ConfigureAwait(false);

            _players.Clear();
            foreach (var player in players)
            {
                _players[player.MacAddress] = player;
            }

            _lastRefresh = DateTime.UtcNow;
            _logger.LogDebug("Refreshed {Count} players from LMS", players.Count);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to refresh players from LMS");
        }
    }

    /// <summary>
    /// Gets all current sync groups.
    /// </summary>
    /// <returns>List of sync groups.</returns>
    public async Task<List<SyncGroup>> GetSyncGroupsAsync()
    {
        return await _lmsClient.GetSyncGroupsAsync().ConfigureAwait(false);
    }

    /// <summary>
    /// Creates a sync group with the specified players.
    /// </summary>
    /// <param name="masterMac">The master player's MAC address.</param>
    /// <param name="slaveMacs">The slave players' MAC addresses.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> CreateSyncGroupAsync(string masterMac, IEnumerable<string> slaveMacs)
    {
        var success = true;

        foreach (var slaveMac in slaveMacs)
        {
            if (!await _lmsClient.SyncPlayerAsync(masterMac, slaveMac).ConfigureAwait(false))
            {
                _logger.LogWarning("Failed to sync player {Slave} to master {Master}", slaveMac, masterMac);
                success = false;
            }
        }

        // Refresh player state to update sync info
        await RefreshPlayersAsync().ConfigureAwait(false);

        return success;
    }

    /// <summary>
    /// Removes a player from its sync group.
    /// </summary>
    /// <param name="playerMac">The player's MAC address.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> UnsyncPlayerAsync(string playerMac)
    {
        var result = await _lmsClient.UnsyncPlayerAsync(playerMac).ConfigureAwait(false);
        await RefreshPlayersAsync().ConfigureAwait(false);
        return result;
    }

    /// <summary>
    /// Dissolves an entire sync group (unsyncs all members).
    /// </summary>
    /// <param name="masterMac">The master player's MAC address.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> DissolveSyncGroupAsync(string masterMac)
    {
        var player = await GetPlayerAsync(masterMac).ConfigureAwait(false);
        if (player == null)
        {
            return false;
        }

        var success = true;

        // Unsync all slaves
        foreach (var slaveMac in player.SyncSlaves)
        {
            if (!await _lmsClient.UnsyncPlayerAsync(slaveMac).ConfigureAwait(false))
            {
                success = false;
            }
        }

        await RefreshPlayersAsync().ConfigureAwait(false);
        return success;
    }
}