diff --git a/.env.example b/.env.example index de90e3a..9c95d01 100644 --- a/.env.example +++ b/.env.example @@ -2,14 +2,50 @@ # Choose which media server backend to use: Subsonic or Jellyfin BACKEND_TYPE=Subsonic -# ===== REDIS CACHE ===== -# Enable Redis caching for metadata and images (default: true) -REDIS_ENABLED=true +# ===== REDIS CACHE (REQUIRED) ===== +# Redis is the primary cache for all runtime data (search results, playlists, lyrics, etc.) +# File cache (/app/cache) acts as a persistence layer for cold starts +# Redis snapshots to disk every 60 seconds + AOF for durability # Redis data persistence directory (default: ./redis-data) -# Redis will save snapshots and append-only logs here to persist cache across restarts +# Contains Redis RDB snapshots and AOF logs for crash recovery REDIS_DATA_PATH=./redis-data +# ===== CACHE TTL SETTINGS ===== +# Configure how long different types of data are cached +# Longer durations reduce API calls but may show stale data +# All values are configurable via Web UI (Configuration tab > Cache Settings) +# Changes require container restart to apply + +# Search results cache duration in minutes (default: 120 = 2 hours) +CACHE_SEARCH_RESULTS_MINUTES=120 + +# Playlist cover images cache duration in hours (default: 168 = 1 week) +CACHE_PLAYLIST_IMAGES_HOURS=168 + +# Spotify playlist items cache duration in hours (default: 168 = 1 week) +CACHE_SPOTIFY_PLAYLIST_ITEMS_HOURS=168 + +# Spotify matched tracks cache duration in days (default: 30 days) +# This is the mapping of Spotify IDs to local/external tracks +CACHE_SPOTIFY_MATCHED_TRACKS_DAYS=30 + +# Lyrics cache duration in days (default: 14 = 2 weeks) +CACHE_LYRICS_DAYS=14 + +# Genre data cache duration in days (default: 30 days) +CACHE_GENRE_DAYS=30 + +# External metadata (SquidWTF/Deezer/Qobuz) cache duration in days (default: 7 days) +CACHE_METADATA_DAYS=7 + +# Odesli URL conversion cache duration in days (default: 60 days) +CACHE_ODESLI_LOOKUP_DAYS=60 + +# Jellyfin proxy images cache duration in days (default: 14 = 2 weeks) +CACHE_PROXY_IMAGES_DAYS=14 + + # ===== SUBSONIC/NAVIDROME CONFIGURATION ===== # Server URL (required if using Subsonic backend) SUBSONIC_URL=http://localhost:4533 @@ -40,11 +76,16 @@ MUSIC_SERVICE=SquidWTF # - downloads/permanent/ - Permanently downloaded tracks (STORAGE_MODE=Permanent) # - downloads/cache/ - Temporarily cached tracks (STORAGE_MODE=Cache) # - downloads/kept/ - Favorited external tracks (always permanent) -DOWNLOAD_PATH=./downloads +Library__DownloadPath=./downloads # ===== SQUIDWTF CONFIGURATION ===== -# Different quality options for SquidWTF. Only FLAC supported right now -SQUIDWTF_QUALITY=FLAC +# Preferred audio quality (optional, default: LOSSLESS) +# - HI_RES or HI_RES_LOSSLESS: 24-bit/192kHz FLAC (highest quality) +# - FLAC or LOSSLESS: 16-bit/44.1kHz FLAC (CD quality, recommended) +# - HIGH: 320kbps AAC (high quality, smaller files) +# - LOW: 96kbps AAC (low quality, smallest files) +# If not specified, LOSSLESS (16-bit FLAC) will be used +SQUIDWTF_QUALITY=LOSSLESS # ===== DEEZER CONFIGURATION ===== # Deezer ARL token (required if using Deezer) @@ -95,12 +136,12 @@ EXPLICIT_FILTER=All # The played track is downloaded first, remaining tracks are queued DOWNLOAD_MODE=Track -# Storage mode (optional, default: Permanent) +# Storage mode (optional, default: Cache) # - Permanent: Files are saved to the library permanently and registered in the media server # - Cache: Files are stored in /tmp and automatically cleaned up after CACHE_DURATION_HOURS # Not registered in media server, ideal for streaming without library bloat # Note: On Linux/Docker, you can customize cache location by setting TMPDIR environment variable -STORAGE_MODE=Permanent +STORAGE_MODE=Cache # Cache duration in hours (optional, default: 1) # Files older than this duration will be automatically deleted when STORAGE_MODE=Cache @@ -143,13 +184,6 @@ SPOTIFY_IMPORT_PLAYLISTS=[] # Enable direct Spotify API access (default: false) SPOTIFY_API_ENABLED=false -# Spotify Client ID from https://developer.spotify.com/dashboard -# Create an app in the Spotify Developer Dashboard to get this -SPOTIFY_API_CLIENT_ID= - -# Spotify Client Secret (optional - only needed for certain OAuth flows) -SPOTIFY_API_CLIENT_SECRET= - # Spotify session cookie (sp_dc) - REQUIRED for editorial playlists # Editorial playlists (Release Radar, Discover Weekly, etc.) require authentication # via session cookie because they're not accessible through the official API. diff --git a/.gitignore b/.gitignore index 89a880d..9a48698 100644 --- a/.gitignore +++ b/.gitignore @@ -83,21 +83,9 @@ cache/ # Docker volumes redis-data/ -# API keys and specs (ignore markdown docs, keep OpenAPI spec) -apis/steering/ -apis/api-calls/*.json -!apis/api-calls/jellyfin-openapi-stable.json -apis/temp.json - -# Temporary documentation files -apis/*.md - -# Log files for debugging -apis/api-calls/*.log - -# Endpoint usage tracking -apis/api-calls/endpoint-usage.json -/app/cache/endpoint-usage/ +# Ignore everything in apis folder except jellyfin-openapi-stable.json +apis/* +!apis/jellyfin-openapi-stable.json # Original source code for reference originals/ diff --git a/README.md b/README.md index 82f82ca..a432515 100644 --- a/README.md +++ b/README.md @@ -37,6 +37,8 @@ The proxy will be available at `http://localhost:5274`. ## Web Dashboard Allstarr includes a web UI for easy configuration and playlist management, accessible at `http://localhost:5275` +image + ### Features @@ -74,8 +76,6 @@ There's an environment variable to modify this. **Recommended workflow**: Use the `sp_dc` cookie method alongside the [Spotify Import Plugin](https://github.com/Viperinius/jellyfin-plugin-spotify-import?tab=readme-ov-file). - - ### Nginx Proxy Setup (Required) This service only exposes ports internally. You can use nginx to proxy to it, however PLEASE take significant precautions before exposing this! Everyone decides their own level of risk, but this is currently untested, potentially dangerous software, with almost unfettered access to your Jellyfin server. My recommendation is use Tailscale or something similar! @@ -139,8 +139,14 @@ This project brings together all the music streaming providers into one unified **Compatible Jellyfin clients:** - [Feishin](https://github.com/jeffvli/feishin) (Mac/Windows/Linux) -- [Musiver](https://music.aqzscn.cn/en/) (Android/IOS/Windows/Android) -- [Finamp](https://github.com/jmshrv/finamp) () +image + + +- [Musiver](https://music.aqzscn.cn/en/) (Android/iOS/Windows/Android) +image + + +- [Finamp](https://github.com/jmshrv/finamp) (Android/iOS) _Working on getting more currently_ @@ -336,6 +342,9 @@ Subsonic__EnableExternalPlaylists=false Allstarr automatically fills your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service. +image + + #### Prerequisites 1. **Install the Jellyfin Spotify Import Plugin** @@ -914,4 +923,4 @@ GPL-3.0 - [Deezer](https://www.deezer.com/) - Music streaming service - [Qobuz](https://www.qobuz.com/) - Hi-Res music streaming service - [spotify-lyrics-api](https://github.com/akashrchandran/spotify-lyrics-api) - Thank them for the fact that we have access to Spotify's lyrics! -- [LRCLIB](https://github.com/tranxuanthang/lrclib) - The GOATS for giving us a free api for lyrics! They power LRCGET, which I'm sure some of you have heard of \ No newline at end of file +- [LRCLIB](https://github.com/tranxuanthang/lrclib) - The GOATS for giving us a free api for lyrics! They power LRCGET, which I'm sure some of you have heard of diff --git a/allstarr.Tests/FuzzyMatcherTests.cs b/allstarr.Tests/FuzzyMatcherTests.cs new file mode 100644 index 0000000..f8d3082 --- /dev/null +++ b/allstarr.Tests/FuzzyMatcherTests.cs @@ -0,0 +1,162 @@ +using Xunit; +using allstarr.Services.Common; + +namespace allstarr.Tests; + +public class FuzzyMatcherTests +{ + + [Theory] + [InlineData("Mr. Brightside", "Mr. Brightside", 100)] + [InlineData("Mr Brightside", "Mr. Brightside", 100)] + [InlineData("Mr. Brightside", "Mr Brightside", 100)] + [InlineData("The Killers", "Killers", 85)] + [InlineData("Dua Lipa", "Dua-Lipa", 100)] + public void CalculateSimilarity_ExactAndNearMatches_ReturnsHighScore(string str1, string str2, int expectedMin) + { + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= expectedMin, $"Expected score >= {expectedMin}, got {score}"); + } + + [Theory] + [InlineData("Mr. Brightside", "Somebody Told Me", 20)] + [InlineData("The Killers", "The Beatles", 40)] + [InlineData("Hot Fuss", "Sam's Town", 20)] + public void CalculateSimilarity_DifferentStrings_ReturnsLowScore(string str1, string str2, int expectedMax) + { + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score <= expectedMax, $"Expected score <= {expectedMax}, got {score}"); + } + + [Fact] + public void CalculateSimilarity_IgnoresPunctuation() + { + // Arrange + var str1 = "Don't Stop Believin'"; + var str2 = "Dont Stop Believin"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 95, $"Expected high score for punctuation differences, got {score}"); + } + + [Fact] + public void CalculateSimilarity_IgnoresCase() + { + // Arrange + var str1 = "Mr. Brightside"; + var str2 = "mr. brightside"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.Equal(100, score); + } + + [Fact] + public void CalculateSimilarity_HandlesArticles() + { + // Arrange + var str1 = "The Killers"; + var str2 = "Killers"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 80, $"Expected high score when 'The' is removed, got {score}"); + } + + [Fact] + public void CalculateSimilarity_HandlesFeaturedArtists() + { + // Arrange + var str1 = "Song Title (feat. Artist)"; + var str2 = "Song Title"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 70, $"Expected decent score for featured artist variations, got {score}"); + } + + [Fact] + public void CalculateSimilarity_HandlesRemixes() + { + // Arrange + var str1 = "Song Title - Radio Edit"; + var str2 = "Song Title"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 70, $"Expected decent score for remix/edit variations, got {score}"); + } + + [Theory] + [InlineData("", "", 0)] + [InlineData("Test", "", 0)] + [InlineData("", "Test", 0)] + public void CalculateSimilarity_EmptyStrings_ReturnsZero(string str1, string str2, int expected) + { + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.Equal(expected, score); + } + + [Fact] + public void CalculateSimilarity_TokenOrder_DoesNotMatter() + { + // Arrange + var str1 = "Bright Side Mr"; + var str2 = "Mr Bright Side"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 90, $"Expected high score regardless of token order, got {score}"); + } + + [Fact] + public void CalculateSimilarity_PartialTokenMatch_ReturnsModerateScore() + { + // Arrange + var str1 = "Mr. Brightside"; + var str2 = "Mr. Brightside (Live)"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 70 && score < 100, $"Expected moderate score for partial match, got {score}"); + } + + [Fact] + public void CalculateSimilarity_SpecialCharacters_AreNormalized() + { + // Arrange + var str1 = "Café del Mar"; + var str2 = "Cafe del Mar"; + + // Act + var score = FuzzyMatcher.CalculateSimilarity(str1, str2); + + // Assert + Assert.True(score >= 90, $"Expected high score for accented characters, got {score}"); + } + +} diff --git a/allstarr.Tests/JellyfinProxyServiceTests.cs b/allstarr.Tests/JellyfinProxyServiceTests.cs index 89179f1..af9b89c 100644 --- a/allstarr.Tests/JellyfinProxyServiceTests.cs +++ b/allstarr.Tests/JellyfinProxyServiceTests.cs @@ -2,6 +2,7 @@ using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; +using Microsoft.Extensions.DependencyInjection; using Moq; using Moq.Protected; using allstarr.Models.Settings; @@ -40,13 +41,19 @@ public class JellyfinProxyServiceTests ClientName = "TestClient", DeviceName = "TestDevice", DeviceId = "test-device-id", - ClientVersion = "1.0.0" + ClientVersion = "1.0.1" }; var httpContext = new DefaultHttpContext(); var httpContextAccessor = new HttpContextAccessor { HttpContext = httpContext }; var mockLogger = new Mock>(); + // Initialize cache settings for tests + var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); + serviceCollection.Configure(options => { }); // Use defaults + var serviceProvider = serviceCollection.BuildServiceProvider(); + CacheExtensions.InitializeCacheSettings(serviceProvider); + _service = new JellyfinProxyService( _mockHttpClientFactory.Object, Options.Create(_settings), diff --git a/allstarr.Tests/LrclibServiceTests.cs b/allstarr.Tests/LrclibServiceTests.cs new file mode 100644 index 0000000..7c37eca --- /dev/null +++ b/allstarr.Tests/LrclibServiceTests.cs @@ -0,0 +1,96 @@ +using Xunit; +using Moq; +using Microsoft.Extensions.Logging; +using allstarr.Services.Lyrics; +using allstarr.Services.Common; +using Microsoft.Extensions.Options; +using allstarr.Models.Settings; + +namespace allstarr.Tests; + +public class LrclibServiceTests +{ + private readonly Mock> _mockLogger; + private readonly Mock _mockHttpClientFactory; + private readonly Mock _mockCache; + private readonly HttpClient _httpClient; + + public LrclibServiceTests() + { + _mockLogger = new Mock>(); + _mockHttpClientFactory = new Mock(); + + // Create mock Redis cache + var mockRedisLogger = new Mock>(); + var mockRedisSettings = Options.Create(new RedisSettings { Enabled = false }); + _mockCache = new Mock(mockRedisSettings, mockRedisLogger.Object); + + _httpClient = new HttpClient + { + BaseAddress = new Uri("https://lrclib.net") + }; + + _mockHttpClientFactory.Setup(f => f.CreateClient(It.IsAny())).Returns(_httpClient); + } + + [Fact] + public void Constructor_InitializesWithDependencies() + { + // Act + var service = new LrclibService(_mockHttpClientFactory.Object, _mockCache.Object, _mockLogger.Object); + + // Assert + Assert.NotNull(service); + } + + [Fact] + public void GetLyricsAsync_RequiresValidParameters() + { + // Arrange + var service = new LrclibService(_mockHttpClientFactory.Object, _mockCache.Object, _mockLogger.Object); + + // Act & Assert - Should handle empty parameters gracefully + var result = service.GetLyricsAsync("", "Artist", "Album", 180); + Assert.NotNull(result); + } + + [Fact] + public void GetLyricsAsync_SupportsMultipleArtists() + { + // Arrange + var service = new LrclibService(_mockHttpClientFactory.Object, _mockCache.Object, _mockLogger.Object); + var artists = new[] { "Artist 1", "Artist 2", "Artist 3" }; + + // Act + var result = service.GetLyricsAsync("Track Name", artists, "Album", 180); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetLyricsByIdAsync_AcceptsValidId() + { + // Arrange + var service = new LrclibService(_mockHttpClientFactory.Object, _mockCache.Object, _mockLogger.Object); + + // Act + var result = service.GetLyricsByIdAsync(123456); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetLyricsCachedAsync_UsesCache() + { + // Arrange + var service = new LrclibService(_mockHttpClientFactory.Object, _mockCache.Object, _mockLogger.Object); + + // Act + var result = service.GetLyricsCachedAsync("Track", "Artist", "Album", 180); + + // Assert + Assert.NotNull(result); + } +} diff --git a/allstarr.Tests/QobuzDownloadServiceTests.cs b/allstarr.Tests/QobuzDownloadServiceTests.cs index f20bc7a..1cf840f 100644 --- a/allstarr.Tests/QobuzDownloadServiceTests.cs +++ b/allstarr.Tests/QobuzDownloadServiceTests.cs @@ -151,7 +151,7 @@ public class QobuzDownloadServiceTests : IDisposable var mockResponse = new HttpResponseMessage { StatusCode = HttpStatusCode.OK, - Content = new StringContent(@"") + Content = new StringContent(@"") }; _httpMessageHandlerMock.Protected() diff --git a/allstarr.Tests/RedisCacheServiceTests.cs b/allstarr.Tests/RedisCacheServiceTests.cs new file mode 100644 index 0000000..10b374f --- /dev/null +++ b/allstarr.Tests/RedisCacheServiceTests.cs @@ -0,0 +1,260 @@ +using Xunit; +using Moq; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using allstarr.Services.Common; +using allstarr.Models.Settings; + +namespace allstarr.Tests; + +public class RedisCacheServiceTests +{ + private readonly Mock> _mockLogger; + private readonly IOptions _settings; + + public RedisCacheServiceTests() + { + _mockLogger = new Mock>(); + _settings = Options.Create(new RedisSettings + { + Enabled = false, // Disabled for unit tests to avoid requiring actual Redis + ConnectionString = "localhost:6379" + }); + } + + [Fact] + public void Constructor_InitializesWithSettings() + { + // Act + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Assert + Assert.NotNull(service); + Assert.False(service.IsEnabled); // Should be disabled in tests + } + + [Fact] + public void Constructor_WithEnabledSettings_AttemptsConnection() + { + // Arrange + var enabledSettings = Options.Create(new RedisSettings + { + Enabled = true, + ConnectionString = "localhost:6379" + }); + + // Act - Constructor will try to connect but should handle failure gracefully + var service = new RedisCacheService(enabledSettings, _mockLogger.Object); + + // Assert - Service should be created even if connection fails + Assert.NotNull(service); + } + + [Fact] + public async Task GetStringAsync_WhenDisabled_ReturnsNull() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.GetStringAsync("test:key"); + + // Assert + Assert.Null(result); + } + + [Fact] + public async Task GetAsync_WhenDisabled_ReturnsNull() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.GetAsync("test:key"); + + // Assert + Assert.Null(result); + } + + [Fact] + public async Task SetStringAsync_WhenDisabled_ReturnsFalse() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.SetStringAsync("test:key", "test value"); + + // Assert + Assert.False(result); + } + + [Fact] + public async Task SetAsync_WhenDisabled_ReturnsFalse() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + var testObj = new TestObject { Id = 1, Name = "Test" }; + + // Act + var result = await service.SetAsync("test:key", testObj); + + // Assert + Assert.False(result); + } + + [Fact] + public async Task DeleteAsync_WhenDisabled_ReturnsFalse() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.DeleteAsync("test:key"); + + // Assert + Assert.False(result); + } + + [Fact] + public async Task ExistsAsync_WhenDisabled_ReturnsFalse() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.ExistsAsync("test:key"); + + // Assert + Assert.False(result); + } + + [Fact] + public async Task DeleteByPatternAsync_WhenDisabled_ReturnsZero() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.DeleteByPatternAsync("test:*"); + + // Assert + Assert.Equal(0, result); + } + + [Fact] + public async Task SetStringAsync_WithExpiry_AcceptsTimeSpan() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + var expiry = TimeSpan.FromHours(1); + + // Act + var result = await service.SetStringAsync("test:key", "value", expiry); + + // Assert - Should return false when disabled, but not throw + Assert.False(result); + } + + [Fact] + public async Task SetAsync_WithExpiry_AcceptsTimeSpan() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + var testObj = new TestObject { Id = 1, Name = "Test" }; + var expiry = TimeSpan.FromDays(30); + + // Act + var result = await service.SetAsync("test:key", testObj, expiry); + + // Assert - Should return false when disabled, but not throw + Assert.False(result); + } + + [Fact] + public void IsEnabled_ReflectsSettings() + { + // Arrange + var disabledService = new RedisCacheService(_settings, _mockLogger.Object); + + var enabledSettings = Options.Create(new RedisSettings + { + Enabled = true, + ConnectionString = "localhost:6379" + }); + var enabledService = new RedisCacheService(enabledSettings, _mockLogger.Object); + + // Assert + Assert.False(disabledService.IsEnabled); + // enabledService.IsEnabled may be false if connection fails, which is expected + } + + [Fact] + public async Task GetAsync_DeserializesComplexObjects() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + + // Act + var result = await service.GetAsync("test:complex"); + + // Assert + Assert.Null(result); // Null when disabled + } + + [Fact] + public async Task SetAsync_SerializesComplexObjects() + { + // Arrange + var service = new RedisCacheService(_settings, _mockLogger.Object); + var complexObj = new ComplexTestObject + { + Id = 1, + Name = "Test", + Items = new System.Collections.Generic.List { "Item1", "Item2" }, + Metadata = new System.Collections.Generic.Dictionary + { + { "Key1", "Value1" }, + { "Key2", "Value2" } + } + }; + + // Act + var result = await service.SetAsync("test:complex", complexObj, TimeSpan.FromHours(1)); + + // Assert + Assert.False(result); // False when disabled + } + + [Fact] + public void ConnectionString_IsConfigurable() + { + // Arrange + var customSettings = Options.Create(new RedisSettings + { + Enabled = false, + ConnectionString = "redis-server:6380,password=secret,ssl=true" + }); + + // Act + var service = new RedisCacheService(customSettings, _mockLogger.Object); + + // Assert + Assert.NotNull(service); + } + + private class TestObject + { + public int Id { get; set; } + public string Name { get; set; } = string.Empty; + } + + private class ComplexTestObject + { + public int Id { get; set; } + public string Name { get; set; } = string.Empty; + public System.Collections.Generic.List Items { get; set; } = new(); + public System.Collections.Generic.Dictionary Metadata { get; set; } = new(); + } +} diff --git a/allstarr.Tests/SpotifyApiClientTests.cs b/allstarr.Tests/SpotifyApiClientTests.cs new file mode 100644 index 0000000..d9d5d3f --- /dev/null +++ b/allstarr.Tests/SpotifyApiClientTests.cs @@ -0,0 +1,82 @@ +using Xunit; +using Moq; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using allstarr.Services.Spotify; +using allstarr.Models.Settings; + +namespace allstarr.Tests; + +public class SpotifyApiClientTests +{ + private readonly Mock> _mockLogger; + private readonly IOptions _settings; + + public SpotifyApiClientTests() + { + _mockLogger = new Mock>(); + _settings = Options.Create(new SpotifyApiSettings + { + Enabled = true, + SessionCookie = "test_session_cookie_value", + CacheDurationMinutes = 60, + RateLimitDelayMs = 100, + PreferIsrcMatching = true + }); + } + + [Fact] + public void Constructor_InitializesWithSettings() + { + // Act + var client = new SpotifyApiClient(_mockLogger.Object, _settings); + + // Assert + Assert.NotNull(client); + } + + [Fact] + public void Settings_AreConfiguredCorrectly() + { + // Arrange & Act + var client = new SpotifyApiClient(_mockLogger.Object, _settings); + + // Assert - Constructor should not throw + Assert.NotNull(client); + } + + [Fact] + public void SessionCookie_IsRequired_ForWebApiAccess() + { + // Arrange + var settingsWithoutCookie = Options.Create(new SpotifyApiSettings + { + Enabled = true, + SessionCookie = "" // Empty cookie + }); + + // Act + var client = new SpotifyApiClient(_mockLogger.Object, settingsWithoutCookie); + + // Assert - Constructor should not throw, but GetWebAccessTokenAsync will return null + Assert.NotNull(client); + } + + [Fact] + public void RateLimitSettings_AreRespected() + { + // Arrange + var customSettings = Options.Create(new SpotifyApiSettings + { + Enabled = true, + SessionCookie = "test_cookie", + RateLimitDelayMs = 500 + }); + + // Act + var client = new SpotifyApiClient(_mockLogger.Object, customSettings); + + // Assert + Assert.NotNull(client); + } +} diff --git a/allstarr.Tests/SquidWTFMetadataServiceTests.cs b/allstarr.Tests/SquidWTFMetadataServiceTests.cs new file mode 100644 index 0000000..09a6d4c --- /dev/null +++ b/allstarr.Tests/SquidWTFMetadataServiceTests.cs @@ -0,0 +1,342 @@ +using Xunit; +using Moq; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using allstarr.Services.SquidWTF; +using allstarr.Services.Common; +using allstarr.Models.Settings; +using System.Collections.Generic; + +namespace allstarr.Tests; + +public class SquidWTFMetadataServiceTests +{ + private readonly Mock> _mockLogger; + private readonly Mock _mockHttpClientFactory; + private readonly IOptions _subsonicSettings; + private readonly IOptions _squidwtfSettings; + private readonly Mock _mockCache; + private readonly List _apiUrls; + + public SquidWTFMetadataServiceTests() + { + _mockLogger = new Mock>(); + _mockHttpClientFactory = new Mock(); + + _subsonicSettings = Options.Create(new SubsonicSettings + { + ExplicitFilter = ExplicitFilter.All + }); + + _squidwtfSettings = Options.Create(new SquidWTFSettings + { + Quality = "FLAC" + }); + + // Create mock Redis cache + var mockRedisLogger = new Mock>(); + var mockRedisSettings = Options.Create(new RedisSettings { Enabled = false }); + _mockCache = new Mock(mockRedisSettings, mockRedisLogger.Object); + + _apiUrls = new List + { + "https://squid.wtf", + "https://mirror1.squid.wtf", + "https://mirror2.squid.wtf" + }; + + var httpClient = new System.Net.Http.HttpClient(); + _mockHttpClientFactory.Setup(f => f.CreateClient(It.IsAny())).Returns(httpClient); + } + + [Fact] + public void Constructor_InitializesWithDependencies() + { + // Act + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Assert + Assert.NotNull(service); + } + + [Fact] + public void Constructor_AcceptsOptionalGenreEnrichment() + { + // Arrange - GenreEnrichmentService is optional, just pass null + + // Act + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls, + null); // GenreEnrichmentService is optional + + // Assert + Assert.NotNull(service); + } + + [Fact] + public void SearchSongsAsync_AcceptsQueryAndLimit() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.SearchSongsAsync("Mr. Brightside", 20); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void SearchAlbumsAsync_AcceptsQueryAndLimit() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.SearchAlbumsAsync("Hot Fuss", 20); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void SearchArtistsAsync_AcceptsQueryAndLimit() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.SearchArtistsAsync("The Killers", 20); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void SearchPlaylistsAsync_AcceptsQueryAndLimit() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.SearchPlaylistsAsync("Rock Classics", 20); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetSongAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetSongAsync("squidwtf", "123456"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetAlbumAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetAlbumAsync("squidwtf", "789012"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetArtistAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetArtistAsync("squidwtf", "345678"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetArtistAlbumsAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetArtistAlbumsAsync("squidwtf", "345678"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetPlaylistAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetPlaylistAsync("squidwtf", "playlist123"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void GetPlaylistTracksAsync_RequiresProviderAndId() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.GetPlaylistTracksAsync("squidwtf", "playlist123"); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void SearchAllAsync_CombinesAllSearchTypes() + { + // Arrange + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Act + var result = service.SearchAllAsync("The Killers", 20, 20, 20); + + // Assert + Assert.NotNull(result); + } + + [Fact] + public void ExplicitFilter_RespectsSettings() + { + // Arrange - Test with CleanOnly filter + var cleanOnlySettings = Options.Create(new SubsonicSettings + { + ExplicitFilter = ExplicitFilter.CleanOnly + }); + + // Act + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + cleanOnlySettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + _apiUrls); + + // Assert + Assert.NotNull(service); + } + + [Fact] + public void MultipleApiUrls_EnablesRoundRobinFallback() + { + // Arrange + var multipleUrls = new List + { + "https://primary.squid.wtf", + "https://backup1.squid.wtf", + "https://backup2.squid.wtf", + "https://backup3.squid.wtf" + }; + + // Act + var service = new SquidWTFMetadataService( + _mockHttpClientFactory.Object, + _subsonicSettings, + _squidwtfSettings, + _mockLogger.Object, + _mockCache.Object, + multipleUrls); + + // Assert + Assert.NotNull(service); + } +} diff --git a/allstarr/Controllers/AdminController.cs b/allstarr/Controllers/AdminController.cs index ea60104..b879d94 100644 --- a/allstarr/Controllers/AdminController.cs +++ b/allstarr/Controllers/AdminController.cs @@ -150,7 +150,7 @@ public class AdminController : ControllerBase return Ok(new { - version = "1.0.0", + version = "1.0.1", backendType = _configuration.GetValue("Backend:Type") ?? "Jellyfin", jellyfinUrl = _jellyfinSettings.Url, spotify = new @@ -207,6 +207,10 @@ public class AdminController : ControllerBase return Ok(new { baseUrl }); } + /// + /// Get current configuration including cache settings + /// + /// /// Get list of configured playlists with their current data /// @@ -232,17 +236,17 @@ public class AdminController : ControllerBase } else { - _logger.LogDebug("🔄 Cache expired (age: {Age:F1}m), refreshing...", age.TotalMinutes); + _logger.LogWarning("🔄 Cache expired (age: {Age:F1}m), refreshing...", age.TotalMinutes); } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to read cached playlist summary"); + _logger.LogError(ex, "Failed to read cached playlist summary"); } } else if (refresh) { - _logger.LogInformation("🔄 Force refresh requested for playlist summary"); + _logger.LogDebug("🔄 Force refresh requested for playlist summary"); } var playlists = new List(); @@ -259,6 +263,7 @@ public class AdminController : ControllerBase ["id"] = config.Id, ["jellyfinId"] = config.JellyfinId, ["localTracksPosition"] = config.LocalTracksPosition.ToString(), + ["syncSchedule"] = config.SyncSchedule ?? "0 8 * * 1", ["trackCount"] = 0, ["localTracks"] = 0, ["externalTracks"] = 0, @@ -296,7 +301,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to read cache for playlist {Name}", config.Name); + _logger.LogError(ex, "Failed to read cache for playlist {Name}", config.Name); } } @@ -363,7 +368,7 @@ public class AdminController : ControllerBase _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", config.Name); } - _logger.LogInformation("Checking cache for {Playlist}: {CacheKey}, Found: {Found}, Count: {Count}", + _logger.LogDebug("Checking cache for {Playlist}: {CacheKey}, Found: {Found}, Count: {Count}", config.Name, playlistItemsCacheKey, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0); if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0) @@ -376,6 +381,7 @@ public class AdminController : ControllerBase { // Check if it's external by looking for external provider in ProviderIds // External providers: SquidWTF, Deezer, Qobuz, Tidal + // Local tracks: Have Jellyfin ID OR no external provider keys var isExternal = false; if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null) @@ -398,7 +404,7 @@ public class AdminController : ControllerBase if (providerIds != null) { - // Check for external provider keys (not MusicBrainz, ISRC, Spotify, etc) + // Check for external provider keys (not MusicBrainz, ISRC, Spotify, Jellyfin, etc) isExternal = providerIds.Keys.Any(k => k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase) || k.Equals("Deezer", StringComparison.OrdinalIgnoreCase) || @@ -413,6 +419,7 @@ public class AdminController : ControllerBase } else { + // Local track (has Jellyfin ID or no external provider) localCount++; } } @@ -427,7 +434,7 @@ public class AdminController : ControllerBase playlistInfo["totalInJellyfin"] = cachedPlaylistItems.Count; playlistInfo["totalPlayable"] = localCount + externalCount; // Total tracks that will be served - _logger.LogInformation("Playlist {Name} (from cache): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", + _logger.LogDebug("Playlist {Name} (from cache): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", config.Name, spotifyTracks.Count, localCount, externalCount, externalMissingCount, localCount + externalCount); } else @@ -544,7 +551,7 @@ public class AdminController : ControllerBase playlistInfo["totalInJellyfin"] = localCount + externalMatchedCount; playlistInfo["totalPlayable"] = localCount + externalMatchedCount; // Total tracks that will be served - _logger.LogDebug("Playlist {Name} (fallback): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", + _logger.LogWarning("Playlist {Name} (fallback): {Total} Spotify tracks, {Local} local, {ExtMatched} external matched, {ExtMissing} external missing, {Playable} total playable", config.Name, spotifyTracks.Count, localCount, externalMatchedCount, externalMissingCount, localCount + externalMatchedCount); } } @@ -555,19 +562,19 @@ public class AdminController : ControllerBase } else { - _logger.LogWarning("Failed to get Jellyfin playlist {Name}: {StatusCode}", + _logger.LogError("Failed to get Jellyfin playlist {Name}: {StatusCode}", config.Name, response.StatusCode); } } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to get Jellyfin playlist tracks for {Name}", config.Name); + _logger.LogError(ex, "Failed to get Jellyfin playlist tracks for {Name}", config.Name); } } else { - _logger.LogWarning("Playlist {Name} has no JellyfinId configured", config.Name); + _logger.LogInformation("Playlist {Name} has no JellyfinId configured", config.Name); } playlists.Add(playlistInfo); @@ -588,7 +595,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to save playlist summary cache"); + _logger.LogError(ex, "Failed to save playlist summary cache"); } return Ok(new { playlists }); @@ -621,7 +628,7 @@ public class AdminController : ControllerBase _logger.LogWarning(cacheEx, "Failed to deserialize playlist cache for {Playlist}", decodedName); } - _logger.LogInformation("GetPlaylistTracks for {Playlist}: Cache found: {Found}, Count: {Count}", + _logger.LogDebug("GetPlaylistTracks for {Playlist}: Cache found: {Found}, Count: {Count}", decodedName, cachedPlaylistItems != null, cachedPlaylistItems?.Count ?? 0); if (cachedPlaylistItems != null && cachedPlaylistItems.Count > 0) @@ -629,8 +636,15 @@ public class AdminController : ControllerBase // Build a map of Spotify ID -> cached item for quick lookup var spotifyIdToItem = new Dictionary>(); - foreach (var item in cachedPlaylistItems) + // Also track items by position for fallback matching + var itemsByPosition = new Dictionary>(); + + for (int i = 0; i < cachedPlaylistItems.Count; i++) { + var item = cachedPlaylistItems[i]; + + // Try to get Spotify ID from ProviderIds (works for both local and external) + bool hasSpotifyId = false; if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null) { Dictionary? providerIds = null; @@ -651,8 +665,15 @@ public class AdminController : ControllerBase if (providerIds != null && providerIds.TryGetValue("Spotify", out var spotifyId) && !string.IsNullOrEmpty(spotifyId)) { spotifyIdToItem[spotifyId] = item; + hasSpotifyId = true; } } + + // If no Spotify ID found, use position-based matching as fallback + if (!hasSpotifyId) + { + itemsByPosition[i] = item; + } } // Match each Spotify track to its cached item @@ -664,7 +685,20 @@ public class AdminController : ControllerBase string? manualMappingType = null; string? manualMappingId = null; - if (spotifyIdToItem.TryGetValue(track.SpotifyId, out var cachedItem)) + Dictionary? cachedItem = null; + + // First try to match by Spotify ID + if (spotifyIdToItem.TryGetValue(track.SpotifyId, out cachedItem)) + { + _logger.LogDebug("Matched track {Title} by Spotify ID", track.Title); + } + // Fallback: Try position-based matching for items without Spotify ID + else if (itemsByPosition.TryGetValue(track.Position, out cachedItem)) + { + _logger.LogDebug("Matched track {Title} by position {Position}", track.Title, track.Position); + } + + if (cachedItem != null) { // Track is in the cache - determine if it's local or external if (cachedItem.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj != null) @@ -688,31 +722,29 @@ public class AdminController : ControllerBase { _logger.LogDebug("Track {Title} has ProviderIds: {Keys}", track.Title, string.Join(", ", providerIds.Keys)); - // Check for external provider keys (case-insensitive) - // External providers: squidwtf, deezer, qobuz, tidal (lowercase) - var providerKey = providerIds.Keys.FirstOrDefault(k => + // Check for external provider keys (SquidWTF, Deezer, Qobuz, Tidal) + // If found, it's an external track + if (providerIds.Keys.Any(k => k.Equals("squidwtf", StringComparison.OrdinalIgnoreCase) || - k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase)); - - if (providerKey != null) + k.Equals("SquidWTF", StringComparison.OrdinalIgnoreCase))) { isLocal = false; externalProvider = "SquidWTF"; _logger.LogDebug("✓ Track {Title} identified as SquidWTF", track.Title); } - else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("deezer", StringComparison.OrdinalIgnoreCase))) != null) + else if (providerIds.Keys.Any(k => k.Equals("deezer", StringComparison.OrdinalIgnoreCase))) { isLocal = false; externalProvider = "Deezer"; _logger.LogDebug("✓ Track {Title} identified as Deezer", track.Title); } - else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("qobuz", StringComparison.OrdinalIgnoreCase))) != null) + else if (providerIds.Keys.Any(k => k.Equals("qobuz", StringComparison.OrdinalIgnoreCase))) { isLocal = false; externalProvider = "Qobuz"; _logger.LogDebug("✓ Track {Title} identified as Qobuz", track.Title); } - else if ((providerKey = providerIds.Keys.FirstOrDefault(k => k.Equals("tidal", StringComparison.OrdinalIgnoreCase))) != null) + else if (providerIds.Keys.Any(k => k.Equals("tidal", StringComparison.OrdinalIgnoreCase))) { isLocal = false; externalProvider = "Tidal"; @@ -720,22 +752,25 @@ public class AdminController : ControllerBase } else { - // No external provider key found - it's a local track - // Local tracks have MusicBrainz, ISRC, Spotify IDs but no external provider + // No external provider key found - it's a local Jellyfin track + // Local tracks may have: Jellyfin ID, MusicBrainz IDs, ISRC, etc. isLocal = true; _logger.LogDebug("✓ Track {Title} identified as LOCAL (has ProviderIds but no external provider)", track.Title); } } else { - _logger.LogWarning("Track {Title} has ProviderIds object but it's null after parsing", track.Title); + // ProviderIds exists but is null after parsing - treat as local + isLocal = true; + _logger.LogDebug("✓ Track {Title} identified as LOCAL (ProviderIds null)", track.Title); } } else { - _logger.LogWarning("Track {Title} in cache but has NO ProviderIds - treating as missing", track.Title); - isLocal = null; - externalProvider = null; + // Track is in cache but has NO ProviderIds property at all + // This is typical for local Jellyfin tracks - treat as local + isLocal = true; + _logger.LogDebug("✓ Track {Title} identified as LOCAL (in cache, no ProviderIds)", track.Title); } // Check if this is a manual mapping @@ -861,7 +896,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to process external manual mapping for {Title}", track.Title); + _logger.LogError(ex, "Failed to process external manual mapping for {Title}", track.Title); } } else if (fallbackMatchedSpotifyIds.Contains(track.SpotifyId)) @@ -916,13 +951,14 @@ public class AdminController : ControllerBase } /// - /// Trigger track matching for a specific playlist + /// Re-match tracks when LOCAL library has changed (checks if Jellyfin playlist changed). + /// This is a lightweight operation that reuses cached Spotify data. /// [HttpPost("playlists/{name}/match")] public async Task MatchPlaylistTracks(string name) { var decodedName = Uri.UnescapeDataString(name); - _logger.LogInformation("Manual track matching triggered for playlist: {Name}", decodedName); + _logger.LogInformation("Re-match tracks triggered for playlist: {Name} (checking for local changes)", decodedName); if (_matchingService == null) { @@ -931,12 +967,31 @@ public class AdminController : ControllerBase try { + // Clear the Jellyfin playlist signature cache to force re-checking if local tracks changed + var jellyfinSignatureCacheKey = $"spotify:playlist:jellyfin-signature:{decodedName}"; + await _cache.DeleteAsync(jellyfinSignatureCacheKey); + _logger.LogDebug("Cleared Jellyfin signature cache to force change detection"); + + // Clear the matched results cache to force re-matching + var matchedTracksKey = $"spotify:matched:ordered:{decodedName}"; + await _cache.DeleteAsync(matchedTracksKey); + _logger.LogDebug("Cleared matched tracks cache"); + + // Clear the playlist items cache + var playlistItemsCacheKey = $"spotify:playlist:items:{decodedName}"; + await _cache.DeleteAsync(playlistItemsCacheKey); + _logger.LogDebug("Cleared playlist items cache"); + + // Trigger matching (will use cached Spotify data if still valid) await _matchingService.TriggerMatchingForPlaylistAsync(decodedName); // Invalidate playlist summary cache InvalidatePlaylistSummaryCache(); - return Ok(new { message = $"Track matching triggered for {decodedName}", timestamp = DateTime.UtcNow }); + return Ok(new { + message = $"Re-matching tracks for {decodedName} (checking local changes)", + timestamp = DateTime.UtcNow + }); } catch (Exception ex) { @@ -946,13 +1001,14 @@ public class AdminController : ControllerBase } /// - /// Clear cache and rebuild for a specific playlist + /// Rebuild playlist from scratch when REMOTE (Spotify) playlist has changed. + /// Clears all caches including Spotify data and forces fresh fetch. /// [HttpPost("playlists/{name}/clear-cache")] public async Task ClearPlaylistCache(string name) { var decodedName = Uri.UnescapeDataString(name); - _logger.LogInformation("Clear cache & rebuild triggered for playlist: {Name}", decodedName); + _logger.LogInformation("Rebuild from scratch triggered for playlist: {Name} (clearing Spotify cache)", decodedName); if (_matchingService == null) { @@ -961,13 +1017,15 @@ public class AdminController : ControllerBase try { - // Clear all cache keys for this playlist + // Clear ALL cache keys for this playlist (including Spotify data) var cacheKeys = new[] { - $"spotify:playlist:items:{decodedName}", // Pre-built items cache - $"spotify:matched:ordered:{decodedName}", // Ordered matched tracks - $"spotify:matched:{decodedName}", // Legacy matched tracks - $"spotify:missing:{decodedName}" // Missing tracks + $"spotify:playlist:items:{decodedName}", // Pre-built items cache + $"spotify:matched:ordered:{decodedName}", // Ordered matched tracks + $"spotify:matched:{decodedName}", // Legacy matched tracks + $"spotify:missing:{decodedName}", // Missing tracks + $"spotify:playlist:jellyfin-signature:{decodedName}", // Jellyfin signature + $"spotify:playlist:{decodedName}" // Spotify playlist data }; foreach (var key in cacheKeys) @@ -993,9 +1051,9 @@ public class AdminController : ControllerBase } } - _logger.LogInformation("✓ Cleared all caches for playlist: {Name}", decodedName); + _logger.LogInformation("✓ Cleared all caches for playlist: {Name} (including Spotify data)", decodedName); - // Trigger rebuild + // Trigger rebuild (will fetch fresh Spotify data) await _matchingService.TriggerMatchingForPlaylistAsync(decodedName); // Invalidate playlist summary cache @@ -1003,10 +1061,10 @@ public class AdminController : ControllerBase return Ok(new { - message = $"Cache cleared and rebuild triggered for {decodedName}", + message = $"Rebuilding {decodedName} from scratch (fetching fresh Spotify data)", timestamp = DateTime.UtcNow, clearedKeys = cacheKeys.Length, - clearedFiles = filesToDelete.Count(System.IO.File.Exists) + clearedFiles = filesToDelete.Count(f => System.IO.File.Exists(f)) }); } catch (Exception ex) @@ -1047,7 +1105,7 @@ public class AdminController : ControllerBase if (!response.IsSuccessStatusCode) { var errorBody = await response.Content.ReadAsStringAsync(); - _logger.LogWarning("Jellyfin search failed: {StatusCode} - {Error}", response.StatusCode, errorBody); + _logger.LogError("Jellyfin search failed: {StatusCode} - {Error}", response.StatusCode, errorBody); return StatusCode((int)response.StatusCode, new { error = "Failed to search Jellyfin" }); } @@ -1063,7 +1121,7 @@ public class AdminController : ControllerBase var type = item.TryGetProperty("Type", out var typeEl) ? typeEl.GetString() : ""; if (type != "Audio") { - _logger.LogDebug("Skipping non-audio item: {Type}", type); + _logger.LogWarning("Skipping non-audio item: {Type}", type); continue; } @@ -1124,7 +1182,7 @@ public class AdminController : ControllerBase if (!response.IsSuccessStatusCode) { var errorBody = await response.Content.ReadAsStringAsync(); - _logger.LogWarning("Failed to fetch Jellyfin track {Id}: {StatusCode} - {Error}", + _logger.LogError("Failed to fetch Jellyfin track {Id}: {StatusCode} - {Error}", id, response.StatusCode, errorBody); return StatusCode((int)response.StatusCode, new { error = "Track not found in Jellyfin" }); } @@ -1245,7 +1303,7 @@ public class AdminController : ControllerBase if (System.IO.File.Exists(matchedFile)) { System.IO.File.Delete(matchedFile); - _logger.LogDebug("Deleted matched tracks file cache for {Playlist}", decodedName); + _logger.LogInformation("Deleted matched tracks file cache for {Playlist}", decodedName); } if (System.IO.File.Exists(itemsFile)) @@ -1256,7 +1314,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to delete file caches for {Playlist}", decodedName); + _logger.LogError(ex, "Failed to delete file caches for {Playlist}", decodedName); } _logger.LogInformation("Cleared playlist caches for {Playlist} to force rebuild", decodedName); @@ -1282,13 +1340,13 @@ public class AdminController : ControllerBase } else { - _logger.LogWarning("Failed to fetch external track metadata for {Provider} ID {Id}", + _logger.LogError("Failed to fetch external track metadata for {Provider} ID {Id}", normalizedProvider, request.ExternalId); } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to fetch external track metadata, but mapping was saved"); + _logger.LogError(ex, "Failed to fetch external track metadata, but mapping was saved"); } } @@ -1379,6 +1437,12 @@ public class AdminController : ControllerBase { return Ok(new { + backendType = _configuration.GetValue("Backend:Type") ?? "Jellyfin", + musicService = _configuration.GetValue("MusicService") ?? "SquidWTF", + explicitFilter = _configuration.GetValue("ExplicitFilter") ?? "All", + enableExternalPlaylists = _configuration.GetValue("EnableExternalPlaylists", false), + playlistsDirectory = _configuration.GetValue("PlaylistsDirectory") ?? "(not set)", + redisEnabled = _configuration.GetValue("Redis:Enabled", false), spotifyApi = new { enabled = _spotifyApiSettings.Enabled, @@ -1454,7 +1518,7 @@ public class AdminController : ControllerBase return BadRequest(new { error = "No updates provided" }); } - _logger.LogInformation("Config update requested: {Count} changes", request.Updates.Count); + _logger.LogDebug("Config update requested: {Count} changes", request.Updates.Count); try { @@ -1483,7 +1547,7 @@ public class AdminController : ControllerBase envContent[key] = value; } } - _logger.LogInformation("Loaded {Count} existing env vars from {Path}", envContent.Count, _envFilePath); + _logger.LogDebug("Loaded {Count} existing env vars from {Path}", envContent.Count, _envFilePath); } // Apply updates with validation @@ -1519,7 +1583,13 @@ public class AdminController : ControllerBase var newContent = string.Join("\n", envContent.Select(kv => $"{kv.Key}={kv.Value}")); await System.IO.File.WriteAllTextAsync(_envFilePath, newContent + "\n"); - _logger.LogInformation("Config file updated successfully at {Path}", _envFilePath); + _logger.LogDebug("Config file updated successfully at {Path}", _envFilePath); + + // Invalidate playlist summary cache if playlists were updated + if (appliedUpdates.Contains("SPOTIFY_IMPORT_PLAYLISTS")) + { + InvalidatePlaylistSummaryCache(); + } return Ok(new { @@ -1641,7 +1711,7 @@ public class AdminController : ControllerBase [HttpPost("cache/clear")] public async Task ClearCache() { - _logger.LogInformation("Cache clear requested from admin UI"); + _logger.LogDebug("Cache clear requested from admin UI"); var clearedFiles = 0; var clearedRedisKeys = 0; @@ -1658,7 +1728,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to delete cache file {File}", file); + _logger.LogError(ex, "Failed to delete cache file {File}", file); } } } @@ -1710,7 +1780,7 @@ public class AdminController : ControllerBase [HttpPost("restart")] public async Task RestartContainer() { - _logger.LogInformation("Container restart requested from admin UI"); + _logger.LogDebug("Container restart requested from admin UI"); try { @@ -1731,7 +1801,7 @@ public class AdminController : ControllerBase var containerId = Environment.MachineName; var containerName = "allstarr"; - _logger.LogInformation("Attempting to restart container {ContainerId} / {ContainerName}", containerId, containerName); + _logger.LogDebug("Attempting to restart container {ContainerId} / {ContainerName}", containerId, containerName); // Create Unix socket HTTP client var handler = new SocketsHttpHandler @@ -1919,6 +1989,53 @@ public class AdminController : ControllerBase } } + /// + /// Get all playlists from the user's Spotify account + /// + [HttpGet("spotify/user-playlists")] + public async Task GetSpotifyUserPlaylists() + { + if (!_spotifyApiSettings.Enabled || string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie)) + { + return BadRequest(new { error = "Spotify API not configured. Please set sp_dc session cookie." }); + } + + try + { + // Get list of already-configured Spotify playlist IDs + var configuredPlaylists = await ReadPlaylistsFromEnvFile(); + var linkedSpotifyIds = new HashSet( + configuredPlaylists.Select(p => p.Id), + StringComparer.OrdinalIgnoreCase + ); + + // Use SpotifyApiClient's GraphQL method - much less rate-limited than REST API + var spotifyPlaylists = await _spotifyClient.GetUserPlaylistsAsync(searchName: null); + + if (spotifyPlaylists == null || spotifyPlaylists.Count == 0) + { + return Ok(new { playlists = new List() }); + } + + var playlists = spotifyPlaylists.Select(p => new + { + id = p.SpotifyId, + name = p.Name, + trackCount = p.TotalTracks, + owner = p.OwnerName ?? "", + isPublic = p.Public, + isLinked = linkedSpotifyIds.Contains(p.SpotifyId) + }).ToList(); + + return Ok(new { playlists }); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching Spotify user playlists"); + return StatusCode(500, new { error = "Failed to fetch Spotify playlists", details = ex.Message }); + } + } + /// /// Get all playlists from Jellyfin /// @@ -1990,11 +2107,16 @@ public class AdminController : ControllerBase trackStats = await GetPlaylistTrackStats(id!); } + // Use actual track stats for configured playlists, otherwise use Jellyfin's count + var actualTrackCount = isConfigured + ? trackStats.LocalTracks + trackStats.ExternalTracks + : childCount; + playlists.Add(new { id, name, - trackCount = childCount, + trackCount = actualTrackCount, linkedSpotifyId, isConfigured, localTracks = trackStats.LocalTracks, @@ -2056,7 +2178,7 @@ public class AdminController : ControllerBase var response = await _jellyfinHttpClient.SendAsync(request); if (!response.IsSuccessStatusCode) { - _logger.LogWarning("Failed to fetch playlist items for {PlaylistId}: {StatusCode}", playlistId, response.StatusCode); + _logger.LogError("Failed to fetch playlist items for {PlaylistId}: {StatusCode}", playlistId, response.StatusCode); return (0, 0, 0); } @@ -2163,12 +2285,19 @@ public class AdminController : ControllerBase Name = request.Name, Id = request.SpotifyPlaylistId, JellyfinId = jellyfinPlaylistId, - LocalTracksPosition = LocalTracksPosition.First // Use Spotify order + LocalTracksPosition = LocalTracksPosition.First, // Use Spotify order + SyncSchedule = request.SyncSchedule ?? "0 8 * * 1" // Default to Monday 8 AM }); - // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last"],...] + // Convert to JSON format for env var: [["Name","SpotifyId","JellyfinId","first|last","cronSchedule"],...] var playlistsJson = JsonSerializer.Serialize( - currentPlaylists.Select(p => new[] { p.Name, p.Id, p.JellyfinId, p.LocalTracksPosition.ToString().ToLower() }).ToArray() + currentPlaylists.Select(p => new[] { + p.Name, + p.Id, + p.JellyfinId, + p.LocalTracksPosition.ToString().ToLower(), + p.SyncSchedule ?? "0 8 * * 1" + }).ToArray() ); // Update .env file @@ -2193,9 +2322,63 @@ public class AdminController : ControllerBase return await RemovePlaylist(decodedName); } + /// + /// Update playlist sync schedule + /// + [HttpPut("playlists/{name}/schedule")] + public async Task UpdatePlaylistSchedule(string name, [FromBody] UpdateScheduleRequest request) + { + var decodedName = Uri.UnescapeDataString(name); + + if (string.IsNullOrWhiteSpace(request.SyncSchedule)) + { + return BadRequest(new { error = "SyncSchedule is required" }); + } + + // Basic cron validation + var cronParts = request.SyncSchedule.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); + if (cronParts.Length != 5) + { + return BadRequest(new { error = "Invalid cron format. Expected: minute hour day month dayofweek" }); + } + + // Read current playlists + var currentPlaylists = await ReadPlaylistsFromEnvFile(); + var playlist = currentPlaylists.FirstOrDefault(p => p.Name.Equals(decodedName, StringComparison.OrdinalIgnoreCase)); + + if (playlist == null) + { + return NotFound(new { error = $"Playlist '{decodedName}' not found" }); + } + + // Update the schedule + playlist.SyncSchedule = request.SyncSchedule.Trim(); + + // Save back to .env + var playlistsJson = JsonSerializer.Serialize( + currentPlaylists.Select(p => new[] { + p.Name, + p.Id, + p.JellyfinId, + p.LocalTracksPosition.ToString().ToLower(), + p.SyncSchedule ?? "0 8 * * 1" + }).ToArray() + ); + + var updateRequest = new ConfigUpdateRequest + { + Updates = new Dictionary + { + ["SPOTIFY_IMPORT_PLAYLISTS"] = playlistsJson + } + }; + + return await UpdateConfig(updateRequest); + } + private string GetJellyfinAuthHeader() { - return $"MediaBrowser Client=\"Allstarr\", Device=\"Server\", DeviceId=\"allstarr-admin\", Version=\"1.0.0\", Token=\"{_jellyfinSettings.ApiKey}\""; + return $"MediaBrowser Client=\"Allstarr\", Device=\"Server\", DeviceId=\"allstarr-admin\", Version=\"1.0.1\", Token=\"{_jellyfinSettings.ApiKey}\""; } /// @@ -2224,7 +2407,7 @@ public class AdminController : ControllerBase return playlists; } - // Parse JSON array format: [["Name","SpotifyId","JellyfinId","first|last"],...] + // Parse JSON array format: [["Name","SpotifyId","JellyfinId","first|last","cronSchedule"],...] var playlistArrays = JsonSerializer.Deserialize(value); if (playlistArrays != null) { @@ -2240,7 +2423,8 @@ public class AdminController : ControllerBase LocalTracksPosition = arr.Length >= 4 && arr[3].Trim().Equals("last", StringComparison.OrdinalIgnoreCase) ? LocalTracksPosition.Last - : LocalTracksPosition.First + : LocalTracksPosition.First, + SyncSchedule = arr.Length >= 5 ? arr[4].Trim() : "0 8 * * 1" }); } } @@ -2333,7 +2517,7 @@ public class AdminController : ControllerBase { var backupPath = $"{_envFilePath}.backup.{DateTime.UtcNow:yyyyMMddHHmmss}"; System.IO.File.Copy(_envFilePath, backupPath, true); - _logger.LogInformation("Backed up existing .env to {BackupPath}", backupPath); + _logger.LogDebug("Backed up existing .env to {BackupPath}", backupPath); } // Write new .env file @@ -2643,7 +2827,7 @@ public class AdminController : ControllerBase } } - _logger.LogInformation("Cleared Spotify cache for {Count} keys via admin endpoint", clearedKeys.Count); + _logger.LogDebug("Cleared Spotify cache for {Count} keys via admin endpoint", clearedKeys.Count); return Ok(new { message = "Spotify cache cleared successfully", @@ -2748,7 +2932,7 @@ public class AdminController : ControllerBase if (System.IO.File.Exists(logFile)) { System.IO.File.Delete(logFile); - _logger.LogInformation("Cleared endpoint usage log via admin endpoint"); + _logger.LogDebug("Cleared endpoint usage log via admin endpoint"); return Ok(new { message = "Endpoint usage log cleared successfully", @@ -2917,7 +3101,7 @@ public class AdminController : ControllerBase // Cache the lyrics using the standard cache key var lyricsCacheKey = $"lyrics:{request.Artist}:{request.Title}:{request.Album ?? ""}:{request.DurationSeconds}"; await _cache.SetAsync(lyricsCacheKey, lyricsInfo.PlainLyrics); - _logger.LogInformation("✓ Fetched and cached lyrics for {Artist} - {Title}", request.Artist, request.Title); + _logger.LogDebug("✓ Fetched and cached lyrics for {Artist} - {Title}", request.Artist, request.Title); return Ok(new { @@ -2939,7 +3123,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to fetch lyrics after mapping, but mapping was saved"); + _logger.LogError(ex, "Failed to fetch lyrics after mapping, but mapping was saved"); } return Ok(new @@ -3030,7 +3214,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to read mapping file {File}", file); + _logger.LogError(ex, "Failed to read mapping file {File}", file); } } @@ -3237,7 +3421,7 @@ public class AdminController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to invalidate playlist summary cache"); + _logger.LogError(ex, "Failed to invalidate playlist summary cache"); } } @@ -3295,6 +3479,12 @@ public class LinkPlaylistRequest { public string Name { get; set; } = string.Empty; public string SpotifyPlaylistId { get; set; } = string.Empty; + public string SyncSchedule { get; set; } = "0 8 * * 1"; // Default: 8 AM every Monday +} + +public class UpdateScheduleRequest +{ + public string SyncSchedule { get; set; } = string.Empty; } /// @@ -3308,7 +3498,7 @@ public class LinkPlaylistRequest { var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept"); - _logger.LogInformation("📂 Checking kept folder: {Path}", keptPath); + _logger.LogDebug("📂 Checking kept folder: {Path}", keptPath); _logger.LogInformation("📂 Directory exists: {Exists}", Directory.Exists(keptPath)); if (!Directory.Exists(keptPath)) @@ -3327,7 +3517,7 @@ public class LinkPlaylistRequest .Where(f => audioExtensions.Contains(Path.GetExtension(f).ToLowerInvariant())) .ToList(); - _logger.LogInformation("📂 Found {Count} audio files in kept folder", allFiles.Count); + _logger.LogDebug("📂 Found {Count} audio files in kept folder", allFiles.Count); foreach (var filePath in allFiles) { @@ -3358,7 +3548,7 @@ public class LinkPlaylistRequest totalSize += fileInfo.Length; } - _logger.LogInformation("📂 Returning {Count} kept files, total size: {Size}", files.Count, FormatFileSize(totalSize)); + _logger.LogDebug("📂 Returning {Count} kept files, total size: {Size}", files.Count, FormatFileSize(totalSize)); return Ok(new { @@ -3392,7 +3582,7 @@ public class LinkPlaylistRequest var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept"); var fullPath = Path.Combine(keptPath, path); - _logger.LogInformation("🗑️ Delete request for: {Path}", fullPath); + _logger.LogDebug("🗑️ Delete request for: {Path}", fullPath); // Security: Ensure the path is within the kept directory var normalizedFullPath = Path.GetFullPath(fullPath); @@ -3411,7 +3601,7 @@ public class LinkPlaylistRequest } System.IO.File.Delete(fullPath); - _logger.LogInformation("🗑️ Deleted file: {Path}", fullPath); + _logger.LogDebug("🗑️ Deleted file: {Path}", fullPath); // Clean up empty directories (Album folder, then Artist folder if empty) var directory = Path.GetDirectoryName(fullPath); @@ -3425,7 +3615,7 @@ public class LinkPlaylistRequest } else { - _logger.LogDebug("🗑️ Directory not empty or doesn't exist, stopping cleanup: {Dir}", directory); + _logger.LogInformation("🗑️ Directory not empty or doesn't exist, stopping cleanup: {Dir}", directory); break; } } @@ -3494,4 +3684,12 @@ public class LinkPlaylistRequest } return $"{len:0.##} {sizes[order]}"; } -} \ No newline at end of file +} + +/// +/// Request model for updating configuration +/// +public class ConfigUpdateRequest +{ + public Dictionary Updates { get; set; } = new(); +} diff --git a/allstarr/Controllers/JellyfinController.cs b/allstarr/Controllers/JellyfinController.cs index 309200f..0cb91f2 100644 --- a/allstarr/Controllers/JellyfinController.cs +++ b/allstarr/Controllers/JellyfinController.cs @@ -39,7 +39,9 @@ public class JellyfinController : ControllerBase private readonly PlaylistSyncService? _playlistSyncService; private readonly SpotifyPlaylistFetcher? _spotifyPlaylistFetcher; private readonly SpotifyLyricsService? _spotifyLyricsService; + private readonly LyricsPlusService? _lyricsPlusService; private readonly LrclibService? _lrclibService; + private readonly LyricsOrchestrator? _lyricsOrchestrator; private readonly OdesliService _odesliService; private readonly RedisCacheService _cache; private readonly IConfiguration _configuration; @@ -64,7 +66,9 @@ public class JellyfinController : ControllerBase PlaylistSyncService? playlistSyncService = null, SpotifyPlaylistFetcher? spotifyPlaylistFetcher = null, SpotifyLyricsService? spotifyLyricsService = null, - LrclibService? lrclibService = null) + LyricsPlusService? lyricsPlusService = null, + LrclibService? lrclibService = null, + LyricsOrchestrator? lyricsOrchestrator = null) { _settings = settings.Value; _spotifySettings = spotifySettings.Value; @@ -80,7 +84,9 @@ public class JellyfinController : ControllerBase _playlistSyncService = playlistSyncService; _spotifyPlaylistFetcher = spotifyPlaylistFetcher; _spotifyLyricsService = spotifyLyricsService; + _lyricsPlusService = lyricsPlusService; _lrclibService = lrclibService; + _lyricsOrchestrator = lyricsOrchestrator; _odesliService = odesliService; _cache = cache; _configuration = configuration; @@ -111,7 +117,7 @@ public class JellyfinController : ControllerBase [FromQuery] bool recursive = true, string? userId = null) { - _logger.LogInformation("=== SEARCHITEMS V2 CALLED === searchTerm={SearchTerm}, includeItemTypes={ItemTypes}, parentId={ParentId}, artistIds={ArtistIds}, userId={UserId}", + _logger.LogDebug("=== SEARCHITEMS V2 CALLED === searchTerm={SearchTerm}, includeItemTypes={ItemTypes}, parentId={ParentId}, artistIds={ArtistIds}, userId={UserId}", searchTerm, includeItemTypes, parentId, artistIds, userId); // Cache search results in Redis only (no file persistence, 15 min TTL) @@ -210,14 +216,14 @@ public class JellyfinController : ControllerBase return Unauthorized(new { error = "Authentication required" }); } - _logger.LogInformation("Jellyfin returned {StatusCode}, returning empty result", statusCode); + _logger.LogDebug("Jellyfin returned {StatusCode}, returning empty result", statusCode); return new JsonResult(new { Items = Array.Empty(), TotalRecordCount = 0, StartIndex = startIndex }); } // Update Spotify playlist counts if enabled and response contains playlists if (_spotifySettings.Enabled && browseResult.RootElement.TryGetProperty("Items", out var _)) { - _logger.LogInformation("Browse result has Items, checking for Spotify playlists to update counts"); + _logger.LogDebug("Browse result has Items, checking for Spotify playlists to update counts"); browseResult = await UpdateSpotifyPlaylistCounts(browseResult); } @@ -248,7 +254,7 @@ public class JellyfinController : ControllerBase } var cleanQuery = searchTerm?.Trim().Trim('"') ?? ""; - _logger.LogInformation("Performing integrated search for: {Query}", cleanQuery); + _logger.LogDebug("Performing integrated search for: {Query}", cleanQuery); // Run local and external searches in parallel var itemTypes = ParseItemTypes(includeItemTypes); @@ -269,7 +275,7 @@ public class JellyfinController : ControllerBase var externalResult = await externalTask; var playlistResult = await playlistTask; - _logger.LogInformation("Search results: Jellyfin={JellyfinCount}, External Songs={ExtSongs}, Albums={ExtAlbums}, Artists={ExtArtists}, Playlists={Playlists}", + _logger.LogDebug("Search results: Jellyfin={JellyfinCount}, External Songs={ExtSongs}, Albums={ExtAlbums}, Artists={ExtArtists}, Playlists={Playlists}", jellyfinResult != null ? "found" : "null", externalResult.Songs.Count, externalResult.Albums.Count, @@ -279,53 +285,50 @@ public class JellyfinController : ControllerBase // Parse Jellyfin results into domain models var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult); - // Respect source ordering (SquidWTF/Tidal has better search ranking than our fuzzy matching) - // Just interleave local and external results based on which source has better overall match - - // Calculate average match score for each source to determine which should come first - var localSongsAvgScore = localSongs.Any() - ? localSongs.Average(s => FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title)) - : 0.0; - var externalSongsAvgScore = externalResult.Songs.Any() - ? externalResult.Songs.Average(s => FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title)) - : 0.0; + // Sort all results by match score (local tracks get +10 boost) + // This ensures best matches appear first regardless of source + var allSongs = localSongs.Concat(externalResult.Songs) + .Select(s => new { Song = s, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, s.Title) + (s.IsLocal ? 10.0 : 0.0) }) + .OrderByDescending(x => x.Score) + .Select(x => x.Song) + .ToList(); - var localAlbumsAvgScore = localAlbums.Any() - ? localAlbums.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title)) - : 0.0; - var externalAlbumsAvgScore = externalResult.Albums.Any() - ? externalResult.Albums.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title)) - : 0.0; + var allAlbums = localAlbums.Concat(externalResult.Albums) + .Select(a => new { Album = a, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Title) + (a.IsLocal ? 10.0 : 0.0) }) + .OrderByDescending(x => x.Score) + .Select(x => x.Album) + .ToList(); - var localArtistsAvgScore = localArtists.Any() - ? localArtists.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name)) - : 0.0; - var externalArtistsAvgScore = externalResult.Artists.Any() - ? externalResult.Artists.Average(a => FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name)) - : 0.0; + var allArtists = localArtists.Concat(externalResult.Artists) + .Select(a => new { Artist = a, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, a.Name) + (a.IsLocal ? 10.0 : 0.0) }) + .OrderByDescending(x => x.Score) + .Select(x => x.Artist) + .ToList(); - // Interleave results: put better-matching source first, preserve original ordering within each source - var allSongs = localSongsAvgScore >= externalSongsAvgScore - ? localSongs.Concat(externalResult.Songs).ToList() - : externalResult.Songs.Concat(localSongs).ToList(); - - var allAlbums = localAlbumsAvgScore >= externalAlbumsAvgScore - ? localAlbums.Concat(externalResult.Albums).ToList() - : externalResult.Albums.Concat(localAlbums).ToList(); - - var allArtists = localArtistsAvgScore >= externalArtistsAvgScore - ? localArtists.Concat(externalResult.Artists).ToList() - : externalResult.Artists.Concat(localArtists).ToList(); - - // Log results for debugging + // Log top results for debugging if (_logger.IsEnabled(LogLevel.Debug)) { - _logger.LogDebug("🎵 Songs: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}", - localSongsAvgScore, externalSongsAvgScore, localSongsAvgScore >= externalSongsAvgScore); - _logger.LogDebug("💿 Albums: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}", - localAlbumsAvgScore, externalAlbumsAvgScore, localAlbumsAvgScore >= externalAlbumsAvgScore); - _logger.LogDebug("🎤 Artists: Local avg score={LocalScore:F2}, External avg score={ExtScore:F2}, Local first={LocalFirst}", - localArtistsAvgScore, externalArtistsAvgScore, localArtistsAvgScore >= externalArtistsAvgScore); + if (allSongs.Any()) + { + var topSong = allSongs.First(); + var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topSong.Title) + (topSong.IsLocal ? 10.0 : 0.0); + _logger.LogDebug("🎵 Top song: '{Title}' (local={IsLocal}, score={Score:F2})", + topSong.Title, topSong.IsLocal, topScore); + } + if (allAlbums.Any()) + { + var topAlbum = allAlbums.First(); + var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topAlbum.Title) + (topAlbum.IsLocal ? 10.0 : 0.0); + _logger.LogDebug("💿 Top album: '{Title}' (local={IsLocal}, score={Score:F2})", + topAlbum.Title, topAlbum.IsLocal, topScore); + } + if (allArtists.Any()) + { + var topArtist = allArtists.First(); + var topScore = FuzzyMatcher.CalculateSimilarity(cleanQuery, topArtist.Name) + (topArtist.IsLocal ? 10.0 : 0.0); + _logger.LogDebug("🎤 Top artist: '{Name}' (local={IsLocal}, score={Score:F2})", + topArtist.Name, topArtist.IsLocal, topScore); + } } // Convert to Jellyfin format @@ -343,7 +346,7 @@ public class JellyfinController : ControllerBase mergedAlbums.AddRange(playlistItems); } - _logger.LogInformation("Merged results (preserving source order): Songs={Songs}, Albums={Albums}, Artists={Artists}", + _logger.LogDebug("Merged and sorted results by score: Songs={Songs}, Albums={Albums}, Artists={Artists}", mergedSongs.Count, mergedAlbums.Count, mergedArtists.Count); // Pre-fetch lyrics for top 3 songs in background (don't await) @@ -374,7 +377,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to pre-fetch lyrics for search results"); + _logger.LogError(ex, "Failed to pre-fetch lyrics for search results"); } }); } @@ -382,28 +385,28 @@ public class JellyfinController : ControllerBase // Filter by item types if specified var items = new List>(); - _logger.LogInformation("Filtering by item types: {ItemTypes}", itemTypes == null ? "null" : string.Join(",", itemTypes)); + _logger.LogDebug("Filtering by item types: {ItemTypes}", itemTypes == null ? "null" : string.Join(",", itemTypes)); if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicArtist")) { - _logger.LogInformation("Adding {Count} artists to results", mergedArtists.Count); + _logger.LogDebug("Adding {Count} artists to results", mergedArtists.Count); items.AddRange(mergedArtists); } if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicAlbum") || itemTypes.Contains("Playlist")) { - _logger.LogInformation("Adding {Count} albums to results", mergedAlbums.Count); + _logger.LogDebug("Adding {Count} albums to results", mergedAlbums.Count); items.AddRange(mergedAlbums); } if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("Audio")) { - _logger.LogInformation("Adding {Count} songs to results", mergedSongs.Count); + _logger.LogDebug("Adding {Count} songs to results", mergedSongs.Count); items.AddRange(mergedSongs); } // Apply pagination var pagedItems = items.Skip(startIndex).Take(limit).ToList(); - _logger.LogInformation("Returning {Count} items (total: {Total})", pagedItems.Count, items.Count); + _logger.LogDebug("Returning {Count} items (total: {Total})", pagedItems.Count, items.Count); try { @@ -419,11 +422,11 @@ public class JellyfinController : ControllerBase if (!string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(artistIds)) { var cacheKey = $"search:{searchTerm?.ToLowerInvariant()}:{includeItemTypes}:{limit}:{startIndex}"; - await _cache.SetAsync(cacheKey, response, TimeSpan.FromMinutes(15)); - _logger.LogDebug("💾 Cached search results for '{SearchTerm}' (15 min TTL)", searchTerm); + await _cache.SetAsync(cacheKey, response, CacheExtensions.SearchResultsTTL); + _logger.LogDebug("💾 Cached search results for '{SearchTerm}' ({Minutes} min TTL)", searchTerm, CacheExtensions.SearchResultsTTL.TotalMinutes); } - _logger.LogInformation("About to serialize response..."); + _logger.LogDebug("About to serialize response..."); var json = System.Text.Json.JsonSerializer.Serialize(response, new System.Text.Json.JsonSerializerOptions { @@ -612,7 +615,7 @@ public class JellyfinController : ControllerBase { var itemTypes = ParseItemTypes(includeItemTypes); - _logger.LogInformation("GetExternalChildItems: provider={Provider}, externalId={ExternalId}, itemTypes={ItemTypes}", + _logger.LogDebug("GetExternalChildItems: provider={Provider}, externalId={ExternalId}, itemTypes={ItemTypes}", provider, externalId, string.Join(",", itemTypes ?? Array.Empty())); // Check if asking for audio (album tracks) @@ -633,7 +636,7 @@ public class JellyfinController : ControllerBase var albums = await _metadataService.GetArtistAlbumsAsync(provider, externalId); var artist = await _metadataService.GetArtistAsync(provider, externalId); - _logger.LogInformation("Found {Count} albums for artist {ArtistName}", albums.Count, artist?.Name ?? "unknown"); + _logger.LogDebug("Found {Count} albums for artist {ArtistName}", albums.Count, artist?.Name ?? "unknown"); // Fill artist info if (artist != null) @@ -664,13 +667,13 @@ public class JellyfinController : ControllerBase [FromQuery] int limit = 50, [FromQuery] int startIndex = 0) { - _logger.LogInformation("GetArtists called: searchTerm={SearchTerm}, limit={Limit}", searchTerm, limit); + _logger.LogDebug("GetArtists called: searchTerm={SearchTerm}, limit={Limit}", searchTerm, limit); // If there's a search term, integrate external results if (!string.IsNullOrWhiteSpace(searchTerm)) { var cleanQuery = searchTerm.Trim().Trim('"'); - _logger.LogInformation("Searching artists for: {Query}", cleanQuery); + _logger.LogDebug("Searching artists for: {Query}", cleanQuery); // Run local and external searches in parallel var jellyfinTask = _proxyService.GetArtistsAsync(searchTerm, limit, startIndex, Request.Headers); @@ -681,7 +684,7 @@ public class JellyfinController : ControllerBase var (jellyfinResult, _) = await jellyfinTask; var externalArtists = await externalTask; - _logger.LogInformation("Artist search results: Jellyfin={JellyfinCount}, External={ExternalCount}", + _logger.LogDebug("Artist search results: Jellyfin={JellyfinCount}, External={ExternalCount}", jellyfinResult != null ? "found" : "null", externalArtists.Count); // Parse Jellyfin artists @@ -698,7 +701,7 @@ public class JellyfinController : ControllerBase // Show ALL matches (local + external) sorted by best match first var mergedArtists = localArtists.Concat(externalArtists).ToList(); - _logger.LogInformation("Returning {Count} total artists (local + external, no deduplication)", mergedArtists.Count); + _logger.LogDebug("Returning {Count} total artists (local + external, no deduplication)", mergedArtists.Count); // Convert to Jellyfin format var artistItems = mergedArtists.Select(a => _responseBuilder.ConvertArtistToJellyfinItem(a)).ToList(); @@ -963,14 +966,14 @@ public class JellyfinController : ControllerBase if (localPath != null && System.IO.File.Exists(localPath)) { - // Update last access time for cache cleanup + // Update last write time for cache cleanup (extends cache lifetime) try { - System.IO.File.SetLastAccessTimeUtc(localPath, DateTime.UtcNow); + System.IO.File.SetLastWriteTimeUtc(localPath, DateTime.UtcNow); } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to update last access time for {Path}", localPath); + _logger.LogError(ex, "Failed to update last write time for {Path}", localPath); } var stream = System.IO.File.OpenRead(localPath); @@ -1103,7 +1106,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to fetch cover art from {Url}", coverUrl); + _logger.LogError(ex, "Failed to fetch cover art from {Url}", coverUrl); // Return placeholder on exception return await GetPlaceholderImageAsync(); } @@ -1144,7 +1147,7 @@ public class JellyfinController : ControllerBase [HttpGet("Items/{itemId}/Lyrics")] public async Task GetLyrics(string itemId) { - _logger.LogInformation("🎵 GetLyrics called for itemId: {ItemId}", itemId); + _logger.LogDebug("🎵 GetLyrics called for itemId: {ItemId}", itemId); if (string.IsNullOrWhiteSpace(itemId)) { @@ -1153,18 +1156,18 @@ public class JellyfinController : ControllerBase var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId); - _logger.LogInformation("🎵 Lyrics request: itemId={ItemId}, isExternal={IsExternal}, provider={Provider}, externalId={ExternalId}", + _logger.LogDebug("🎵 Lyrics request: itemId={ItemId}, isExternal={IsExternal}, provider={Provider}, externalId={ExternalId}", itemId, isExternal, provider, externalId); // For local tracks, check if Jellyfin already has embedded lyrics if (!isExternal) { - _logger.LogInformation("Checking Jellyfin for embedded lyrics for local track: {ItemId}", itemId); + _logger.LogDebug("Checking Jellyfin for embedded lyrics for local track: {ItemId}", itemId); // Try to get lyrics from Jellyfin first (it reads embedded lyrics from files) var (jellyfinLyrics, statusCode) = await _proxyService.GetJsonAsync($"Audio/{itemId}/Lyrics", null, Request.Headers); - _logger.LogInformation("Jellyfin lyrics check result: statusCode={StatusCode}, hasLyrics={HasLyrics}", + _logger.LogDebug("Jellyfin lyrics check result: statusCode={StatusCode}, hasLyrics={HasLyrics}", statusCode, jellyfinLyrics != null); if (jellyfinLyrics != null && statusCode == 200) @@ -1173,7 +1176,7 @@ public class JellyfinController : ControllerBase return new JsonResult(JsonSerializer.Deserialize(jellyfinLyrics.RootElement.GetRawText())); } - _logger.LogInformation("No embedded lyrics found in Jellyfin (status: {StatusCode}), trying Spotify/LRCLIB", statusCode); + _logger.LogWarning("No embedded lyrics found in Jellyfin (status: {StatusCode}), trying Spotify/LRCLIB", statusCode); } // Get song metadata for lyrics search @@ -1197,7 +1200,7 @@ public class JellyfinController : ControllerBase spotifyTrackId = await FindSpotifyIdForExternalTrackAsync(song); if (!string.IsNullOrEmpty(spotifyTrackId)) { - _logger.LogInformation("Found Spotify ID {SpotifyId} for external track {Provider}/{ExternalId} from cache", + _logger.LogDebug("Found Spotify ID {SpotifyId} for external track {Provider}/{ExternalId} from cache", spotifyTrackId, provider, externalId); } else @@ -1225,7 +1228,7 @@ public class JellyfinController : ControllerBase if (!string.IsNullOrEmpty(spotifyTrackId)) { - _logger.LogInformation("Converted {Provider}/{ExternalId} to Spotify ID {SpotifyId} via Odesli", + _logger.LogDebug("Converted {Provider}/{ExternalId} to Spotify ID {SpotifyId} via Odesli", provider, externalId, spotifyTrackId); } } @@ -1274,50 +1277,53 @@ public class JellyfinController : ControllerBase searchArtists.Add(searchArtist); } + // Use orchestrator for clean, modular lyrics fetching LyricsInfo? lyrics = null; - // Try Spotify lyrics ONLY if we have a valid Spotify track ID - // Spotify lyrics only work for tracks from injected playlists that have been matched - if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId)) + if (_lyricsOrchestrator != null) { - // Validate that this is a real Spotify ID (not spotify:local or other invalid formats) - var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim(); - - // Spotify track IDs are 22 characters, base62 encoded - if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local")) - { - _logger.LogInformation("Trying Spotify lyrics for track ID: {SpotifyId} ({Artist} - {Title})", - cleanSpotifyId, searchArtist, searchTitle); - - var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId); - - if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0) - { - _logger.LogInformation("Found Spotify lyrics for {Artist} - {Title} ({LineCount} lines, type: {SyncType})", - searchArtist, searchTitle, spotifyLyrics.Lines.Count, spotifyLyrics.SyncType); - lyrics = _spotifyLyricsService.ToLyricsInfo(spotifyLyrics); - } - else - { - _logger.LogDebug("No Spotify lyrics found for track ID {SpotifyId}", cleanSpotifyId); - } - } - else - { - _logger.LogDebug("Invalid Spotify ID format: {SpotifyId}, skipping Spotify lyrics", spotifyTrackId); - } + lyrics = await _lyricsOrchestrator.GetLyricsAsync( + trackName: searchTitle, + artistNames: searchArtists.ToArray(), + albumName: searchAlbum, + durationSeconds: song.Duration ?? 0, + spotifyTrackId: spotifyTrackId); } - - // Fall back to LRCLIB if no Spotify lyrics - if (lyrics == null) + else { - _logger.LogInformation("Searching LRCLIB for lyrics: {Artists} - {Title}", - string.Join(", ", searchArtists), - searchTitle); - var lrclibService = HttpContext.RequestServices.GetService(); - if (lrclibService != null) + // Fallback to manual fetching if orchestrator not available + _logger.LogWarning("LyricsOrchestrator not available, using fallback method"); + + // Try Spotify lyrics ONLY if we have a valid Spotify track ID + if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId)) { - lyrics = await lrclibService.GetLyricsAsync( + var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim(); + + if (cleanSpotifyId.Length == 22 && !cleanSpotifyId.Contains(":") && !cleanSpotifyId.Contains("local")) + { + var spotifyLyrics = await _spotifyLyricsService.GetLyricsByTrackIdAsync(cleanSpotifyId); + + if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0) + { + lyrics = _spotifyLyricsService.ToLyricsInfo(spotifyLyrics); + } + } + } + + // Fall back to LyricsPlus + if (lyrics == null && _lyricsPlusService != null) + { + lyrics = await _lyricsPlusService.GetLyricsAsync( + searchTitle, + searchArtists.ToArray(), + searchAlbum, + song.Duration ?? 0); + } + + // Fall back to LRCLIB + if (lyrics == null && _lrclibService != null) + { + lyrics = await _lrclibService.GetLyricsAsync( searchTitle, searchArtists.ToArray(), searchAlbum, @@ -1342,7 +1348,7 @@ public class JellyfinController : ControllerBase if (isSynced && !string.IsNullOrEmpty(lyrics.SyncedLyrics)) { - _logger.LogInformation("Parsing synced lyrics (LRC format)"); + _logger.LogDebug("Parsing synced lyrics (LRC format)"); // Parse LRC format: [mm:ss.xx] text // Skip ID tags like [ar:Artist], [ti:Title], etc. var lines = lyrics.SyncedLyrics.Split('\n', StringSplitOptions.RemoveEmptyEntries); @@ -1370,7 +1376,7 @@ public class JellyfinController : ControllerBase } // Skip ID tags like [ar:Artist], [ti:Title], [length:2:23], etc. } - _logger.LogInformation("Parsed {Count} synced lyric lines (skipped ID tags)", lyricLines.Count); + _logger.LogDebug("Parsed {Count} synced lyric lines (skipped ID tags)", lyricLines.Count); } else if (!string.IsNullOrEmpty(lyricsText)) { @@ -1386,7 +1392,7 @@ public class JellyfinController : ControllerBase ["Text"] = line.Trim() }); } - _logger.LogInformation("Split into {Count} plain lyric lines", lyricLines.Count); + _logger.LogDebug("Split into {Count} plain lyric lines", lyricLines.Count); } else { @@ -1411,14 +1417,14 @@ public class JellyfinController : ControllerBase Lyrics = lyricLines }; - _logger.LogInformation("Returning lyrics response: {LineCount} lines, synced={IsSynced}", lyricLines.Count, isSynced); + _logger.LogDebug("Returning lyrics response: {LineCount} lines, synced={IsSynced}", lyricLines.Count, isSynced); // Log a sample of the response for debugging if (lyricLines.Count > 0) { var sampleLine = lyricLines[0]; var hasStart = sampleLine.ContainsKey("Start"); - _logger.LogInformation("Sample line: Text='{Text}', HasStart={HasStart}", + _logger.LogDebug("Sample line: Text='{Text}', HasStart={HasStart}", sampleLine.GetValueOrDefault("Text"), hasStart); } @@ -1498,6 +1504,21 @@ public class JellyfinController : ControllerBase _logger.LogDebug("🎵 Prefetching lyrics for: {Artist} - {Title}", searchArtist, searchTitle); + // Use orchestrator for prefetching + if (_lyricsOrchestrator != null) + { + await _lyricsOrchestrator.PrefetchLyricsAsync( + trackName: searchTitle, + artistNames: searchArtists.ToArray(), + albumName: searchAlbum, + durationSeconds: song.Duration ?? 0, + spotifyTrackId: spotifyTrackId); + return; + } + + // Fallback to manual prefetching if orchestrator not available + _logger.LogWarning("LyricsOrchestrator not available for prefetch, using fallback method"); + // Try Spotify lyrics if we have a valid Spotify track ID if (_spotifyLyricsService != null && _spotifyApiSettings.Enabled && !string.IsNullOrEmpty(spotifyTrackId)) { @@ -1516,6 +1537,22 @@ public class JellyfinController : ControllerBase } } + // Fall back to LyricsPlus + if (_lyricsPlusService != null) + { + var lyrics = await _lyricsPlusService.GetLyricsAsync( + searchTitle, + searchArtists.ToArray(), + searchAlbum, + song.Duration ?? 0); + + if (lyrics != null) + { + _logger.LogDebug("✓ Prefetched LyricsPlus lyrics for {Artist} - {Title}", searchArtist, searchTitle); + return; // Success, lyrics are now cached + } + } + // Fall back to LRCLIB if (_lrclibService != null) { @@ -1537,7 +1574,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Error prefetching lyrics for track {ItemId}", itemId); + _logger.LogError(ex, "Error prefetching lyrics for track {ItemId}", itemId); } } @@ -1559,7 +1596,7 @@ public class JellyfinController : ControllerBase userId = Request.Query["userId"].ToString(); } - _logger.LogInformation("MarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", + _logger.LogDebug("MarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", userId, itemId, Request.Path); // Check if this is an external playlist - trigger download @@ -1628,7 +1665,7 @@ public class JellyfinController : ControllerBase endpoint = $"{endpoint}?userId={userId}"; } - _logger.LogInformation("Proxying favorite request to Jellyfin: {Endpoint}", endpoint); + _logger.LogDebug("Proxying favorite request to Jellyfin: {Endpoint}", endpoint); var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, "{}", Request.Headers); @@ -1649,7 +1686,7 @@ public class JellyfinController : ControllerBase userId = Request.Query["userId"].ToString(); } - _logger.LogInformation("UnmarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", + _logger.LogDebug("UnmarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", userId, itemId, Request.Path); // External items - remove from kept folder if it exists @@ -1686,7 +1723,7 @@ public class JellyfinController : ControllerBase endpoint = $"{endpoint}?userId={userId}"; } - _logger.LogInformation("Proxying unfavorite request to Jellyfin: {Endpoint}", endpoint); + _logger.LogDebug("Proxying unfavorite request to Jellyfin: {Endpoint}", endpoint); var (result, statusCode) = await _proxyService.DeleteAsync(endpoint, Request.Headers); @@ -1748,7 +1785,7 @@ public class JellyfinController : ControllerBase { try { - _logger.LogInformation("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId); + _logger.LogDebug("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId); // Check if this is an external playlist (Deezer/Qobuz) first if (PlaylistIdHelper.IsExternalPlaylist(playlistId)) @@ -1788,7 +1825,7 @@ public class JellyfinController : ControllerBase endpoint = $"{endpoint}{Request.QueryString.Value}"; } - _logger.LogInformation("Proxying to Jellyfin: {Endpoint}", endpoint); + _logger.LogDebug("Proxying to Jellyfin: {Endpoint}", endpoint); var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers); return HandleProxyResponse(result, statusCode); @@ -1834,15 +1871,15 @@ public class JellyfinController : ControllerBase var imageBytes = await response.Content.ReadAsByteArrayAsync(); var contentType = response.Content.Headers.ContentType?.ToString() ?? "image/jpeg"; - // Cache for 1 hour (playlists can change, so don't cache too long) - await _cache.SetAsync(cacheKey, imageBytes, TimeSpan.FromHours(1)); + // Cache for configurable duration (playlists can change) + await _cache.SetAsync(cacheKey, imageBytes, CacheExtensions.PlaylistImagesTTL); _logger.LogDebug("Cached playlist image for {PlaylistId}", playlistId); return File(imageBytes, contentType); } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to get playlist image {PlaylistId}", playlistId); + _logger.LogError(ex, "Failed to get playlist image {PlaylistId}", playlistId); return NotFound(); } } @@ -1870,7 +1907,7 @@ public class JellyfinController : ControllerBase // Reset stream position Request.Body.Position = 0; - _logger.LogInformation("Authentication request received"); + _logger.LogDebug("Authentication request received"); // DO NOT log request body or detailed headers - contains password // Forward to Jellyfin server with client headers - completely transparent proxy @@ -1933,14 +1970,14 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to post session capabilities after auth"); + _logger.LogError(ex, "Failed to post session capabilities after auth"); } }); } } else { - _logger.LogWarning("Authentication failed - status {StatusCode}", statusCode); + _logger.LogError("Authentication failed - status {StatusCode}", statusCode); } // Return Jellyfin's exact response @@ -2023,7 +2060,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to get similar items for external song {ItemId}", itemId); + _logger.LogError(ex, "Failed to get similar items for external song {ItemId}", itemId); return _responseBuilder.CreateJsonResponse(new { Items = Array.Empty(), @@ -2132,7 +2169,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to create instant mix for external song {ItemId}", itemId); + _logger.LogError(ex, "Failed to create instant mix for external song {ItemId}", itemId); return _responseBuilder.CreateJsonResponse(new { Items = Array.Empty(), @@ -2212,7 +2249,7 @@ public class JellyfinController : ControllerBase } else if (statusCode == 401) { - _logger.LogDebug("⚠ Jellyfin returned 401 for capabilities (token expired)"); + _logger.LogWarning("⚠ Jellyfin returned 401 for capabilities (token expired)"); } else { @@ -2294,7 +2331,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to prefetch lyrics for external track {ItemId}", itemId); + _logger.LogError(ex, "Failed to prefetch lyrics for external track {ItemId}", itemId); } }); @@ -2344,7 +2381,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to prefetch lyrics for local track {ItemId}", itemId); + _logger.LogError(ex, "Failed to prefetch lyrics for local track {ItemId}", itemId); } }); } @@ -2388,7 +2425,7 @@ public class JellyfinController : ControllerBase } else { - _logger.LogWarning("⚠️ SESSION: Failed to ensure session for device {DeviceId}", deviceId); + _logger.LogError("⚠️ SESSION: Failed to ensure session for device {DeviceId}", deviceId); } } else @@ -2414,7 +2451,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to send playback start, trying basic"); + _logger.LogError(ex, "Failed to send playback start, trying basic"); // Fall back to basic playback start var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers); if (statusCode == 204 || statusCode == 200) @@ -2427,7 +2464,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to report playback start"); + _logger.LogError(ex, "Failed to report playback start"); return NoContent(); // Return success anyway to not break playback } } @@ -2540,7 +2577,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to report playback progress"); + _logger.LogError(ex, "Failed to report playback progress"); return NoContent(); } } @@ -2561,7 +2598,7 @@ public class JellyfinController : ControllerBase } Request.Body.Position = 0; - _logger.LogDebug("⏹️ Playback STOPPED reported"); + _logger.LogInformation("⏹️ Playback STOPPED reported"); // Parse the body to check if it's an external track var doc = JsonDocument.Parse(body); @@ -2657,7 +2694,7 @@ public class JellyfinController : ControllerBase } else if (statusCode == 401) { - _logger.LogDebug("Playback stop returned 401 (token expired)"); + _logger.LogWarning("Playback stop returned 401 (token expired)"); } else { @@ -2668,7 +2705,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to report playback stopped"); + _logger.LogError(ex, "Failed to report playback stopped"); return NoContent(); } } @@ -2690,7 +2727,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to ping playback session"); + _logger.LogError(ex, "Failed to ping playback session"); return NoContent(); } } @@ -2778,7 +2815,7 @@ public class JellyfinController : ControllerBase { LocalAddress = Request.Host.ToString(), ServerName = serverName ?? "Allstarr", - Version = version ?? "1.0.0", + Version = version ?? "1.0.1", ProductName = "Allstarr (Jellyfin Proxy)", OperatingSystem = Environment.OSVersion.Platform.ToString(), Id = _settings.DeviceId, @@ -2862,7 +2899,7 @@ public class JellyfinController : ControllerBase { var playlistId = parts[1]; - _logger.LogInformation("=== PLAYLIST REQUEST ==="); + _logger.LogDebug("=== PLAYLIST REQUEST ==="); _logger.LogInformation("Playlist ID: {PlaylistId}", playlistId); _logger.LogInformation("Spotify Enabled: {Enabled}", _spotifySettings.Enabled); _logger.LogInformation("Configured Playlists: {Playlists}", string.Join(", ", _spotifySettings.Playlists.Select(p => $"{p.Name}:{p.Id}"))); @@ -2938,7 +2975,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to proxy binary request for {Path}", path); + _logger.LogError(ex, "Failed to proxy binary request for {Path}", path); return NotFound(); } } @@ -2948,12 +2985,12 @@ public class JellyfinController : ControllerBase if (!string.IsNullOrWhiteSpace(searchTerm)) { - _logger.LogInformation("ProxyRequest intercepting search request: Path={Path}, SearchTerm={SearchTerm}", path, searchTerm); + _logger.LogDebug("ProxyRequest intercepting search request: Path={Path}, SearchTerm={SearchTerm}", path, searchTerm); // Item search: /users/{userId}/items or /items if (path.EndsWith("/items", StringComparison.OrdinalIgnoreCase) || path.Equals("items", StringComparison.OrdinalIgnoreCase)) { - _logger.LogInformation("Redirecting to SearchItems"); + _logger.LogDebug("Redirecting to SearchItems"); return await SearchItems( searchTerm: searchTerm, includeItemTypes: Request.Query["IncludeItemTypes"], @@ -2994,7 +3031,7 @@ public class JellyfinController : ControllerBase Request.EnableBuffering(); // Log request details for debugging - _logger.LogInformation("POST request to {Path}: Method={Method}, ContentType={ContentType}, ContentLength={ContentLength}", + _logger.LogDebug("POST request to {Path}: Method={Method}, ContentType={ContentType}, ContentLength={ContentLength}", fullPath, Request.Method, Request.ContentType, Request.ContentLength); // Read body using StreamReader with proper encoding @@ -3018,7 +3055,7 @@ public class JellyfinController : ControllerBase } else { - _logger.LogInformation("POST body received from client for {Path}: {BodyLength} bytes, ContentType={ContentType}", + _logger.LogDebug("POST body received from client for {Path}: {BodyLength} bytes, ContentType={ContentType}", fullPath, body.Length, Request.ContentType); // Always log body content for playback endpoints to debug the issue @@ -3075,7 +3112,7 @@ public class JellyfinController : ControllerBase result.RootElement.ValueKind == JsonValueKind.Object && result.RootElement.TryGetProperty("Items", out var items)) { - _logger.LogInformation("Response has Items property, checking for Spotify playlists to update counts"); + _logger.LogDebug("Response has Items property, checking for Spotify playlists to update counts"); result = await UpdateSpotifyPlaylistCounts(result); } @@ -3084,7 +3121,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Proxy request failed for {Path}", path); + _logger.LogError(ex, "Proxy request failed for {Path}", path); return _responseBuilder.CreateError(502, $"Proxy error: {ex.Message}"); } } @@ -3146,7 +3183,7 @@ public class JellyfinController : ControllerBase var modified = false; var updatedItems = new List>(); - _logger.LogInformation("Checking {Count} items for Spotify playlists", itemsArray.Count); + _logger.LogDebug("Checking {Count} items for Spotify playlists", itemsArray.Count); foreach (var item in itemsArray) { @@ -3179,7 +3216,7 @@ public class JellyfinController : ControllerBase var matchedTracksKey = $"spotify:matched:ordered:{playlistName}"; var matchedTracks = await _cache.GetAsync>(matchedTracksKey); - _logger.LogDebug("Cache lookup for {Key}: {Count} matched tracks", + _logger.LogInformation("Cache lookup for {Key}: {Count} matched tracks", matchedTracksKey, matchedTracks?.Count ?? 0); // Fallback to legacy cache format @@ -3204,7 +3241,7 @@ public class JellyfinController : ControllerBase var fileItems = await LoadPlaylistItemsFromFile(playlistName); if (fileItems != null && fileItems.Count > 0) { - _logger.LogInformation("💿 Loaded {Count} playlist items from file cache for count update", fileItems.Count); + _logger.LogDebug("💿 Loaded {Count} playlist items from file cache for count update", fileItems.Count); // Use file cache count directly itemDict["ChildCount"] = fileItems.Count; modified = true; @@ -3237,13 +3274,13 @@ public class JellyfinController : ControllerBase localTracksResponse.RootElement.TryGetProperty("Items", out var localItems)) { localTracksCount = localItems.GetArrayLength(); - _logger.LogInformation("Found {Count} total items in Jellyfin playlist {Name}", + _logger.LogDebug("Found {Count} total items in Jellyfin playlist {Name}", localTracksCount, playlistName); } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to get local tracks count for {Name}", playlistName); + _logger.LogError(ex, "Failed to get local tracks count for {Name}", playlistName); } // Count external matched tracks (not local) @@ -3262,7 +3299,7 @@ public class JellyfinController : ControllerBase // Update ChildCount to show actual available tracks itemDict["ChildCount"] = totalAvailableCount; modified = true; - _logger.LogInformation("✓ Updated ChildCount for Spotify playlist {Name} to {Total} ({Local} local + {External} external)", + _logger.LogDebug("✓ Updated ChildCount for Spotify playlist {Name} to {Total} ({Local} local + {External} external)", playlistName, totalAvailableCount, localTracksCount, externalMatchedCount); } else @@ -3288,7 +3325,7 @@ public class JellyfinController : ControllerBase return response; } - _logger.LogInformation("Modified {Count} Spotify playlists, rebuilding response", + _logger.LogDebug("Modified {Count} Spotify playlists, rebuilding response", updatedItems.Count(i => i.ContainsKey("ChildCount"))); // Rebuild the response with updated items @@ -3304,7 +3341,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to update Spotify playlist counts"); + _logger.LogError(ex, "Failed to update Spotify playlist counts"); return response; } } @@ -3336,7 +3373,7 @@ public class JellyfinController : ControllerBase catch (Exception ex) { // Don't let logging failures break the request - _logger.LogDebug(ex, "Failed to log endpoint usage"); + _logger.LogError(ex, "Failed to log endpoint usage"); } } @@ -3460,26 +3497,26 @@ public class JellyfinController : ControllerBase /// /// New mode: Gets playlist tracks with correct ordering using direct Spotify API data. + /// Optimized to only re-match when Jellyfin playlist changes (cheap check). /// private async Task GetSpotifyPlaylistTracksOrderedAsync(string spotifyPlaylistName, string playlistId) { - // Check Redis cache first for fast serving + // Check if Jellyfin playlist has changed (cheap API call) + var jellyfinSignatureCacheKey = $"spotify:playlist:jellyfin-signature:{spotifyPlaylistName}"; + var currentJellyfinSignature = await GetJellyfinPlaylistSignatureAsync(playlistId); + var cachedJellyfinSignature = await _cache.GetAsync(jellyfinSignatureCacheKey); + + var jellyfinPlaylistChanged = cachedJellyfinSignature != currentJellyfinSignature; + + // Check Redis cache first for fast serving (only if Jellyfin playlist hasn't changed) var cacheKey = $"spotify:playlist:items:{spotifyPlaylistName}"; var cachedItems = await _cache.GetAsync>>(cacheKey); - if (cachedItems != null && cachedItems.Count > 0) + if (cachedItems != null && cachedItems.Count > 0 && !jellyfinPlaylistChanged) { - _logger.LogInformation("✅ Loaded {Count} playlist items from Redis cache for {Playlist}", + _logger.LogDebug("✅ Loaded {Count} playlist items from Redis cache for {Playlist} (Jellyfin unchanged)", cachedItems.Count, spotifyPlaylistName); - // Log sample item to verify Spotify IDs are present - if (cachedItems.Count > 0 && cachedItems[0].ContainsKey("ProviderIds")) - { - var providerIds = cachedItems[0]["ProviderIds"] as Dictionary; - var hasSpotifyId = providerIds?.ContainsKey("Spotify") ?? false; - _logger.LogDebug("Sample cached item has Spotify ID: {HasSpotifyId}", hasSpotifyId); - } - return new JsonResult(new { Items = cachedItems, @@ -3488,15 +3525,20 @@ public class JellyfinController : ControllerBase }); } + if (jellyfinPlaylistChanged) + { + _logger.LogInformation("🔄 Jellyfin playlist changed for {Playlist} - re-matching tracks", spotifyPlaylistName); + } + // Check file cache as fallback var fileItems = await LoadPlaylistItemsFromFile(spotifyPlaylistName); if (fileItems != null && fileItems.Count > 0) { - _logger.LogInformation("✅ Loaded {Count} playlist items from file cache for {Playlist}", + _logger.LogDebug("✅ Loaded {Count} playlist items from file cache for {Playlist}", fileItems.Count, spotifyPlaylistName); // Restore to Redis cache - await _cache.SetAsync(cacheKey, fileItems, TimeSpan.FromHours(24)); + await _cache.SetAsync(cacheKey, fileItems, CacheExtensions.SpotifyPlaylistItemsTTL); return new JsonResult(new { @@ -3512,12 +3554,12 @@ public class JellyfinController : ControllerBase if (orderedTracks == null || orderedTracks.Count == 0) { - _logger.LogDebug("No ordered matched tracks in cache for {Playlist}, checking if we can fetch", + _logger.LogInformation("No ordered matched tracks in cache for {Playlist}, checking if we can fetch", spotifyPlaylistName); return null; // Fall back to legacy mode } - _logger.LogDebug("Using {Count} ordered matched tracks for {Playlist}", + _logger.LogInformation("Using {Count} ordered matched tracks for {Playlist}", orderedTracks.Count, spotifyPlaylistName); // Get existing Jellyfin playlist items (RAW - don't convert!) @@ -3529,8 +3571,17 @@ public class JellyfinController : ControllerBase return null; // Fall back to legacy mode } - // Request MediaSources field to get bitrate info - var playlistItemsUrl = $"Playlists/{playlistId}/Items?UserId={userId}&Fields=MediaSources"; + // Pass through all requested fields from the original request + var queryString = Request.QueryString.Value ?? ""; + var playlistItemsUrl = $"Playlists/{playlistId}/Items?UserId={userId}"; + + // Append the original query string (which includes Fields parameter) + if (!string.IsNullOrEmpty(queryString)) + { + // Remove the leading ? if present + queryString = queryString.TrimStart('?'); + playlistItemsUrl = $"{playlistItemsUrl}&{queryString}"; + } _logger.LogInformation("🔍 Fetching existing tracks from Jellyfin playlist {PlaylistId} with UserId {UserId}", playlistId, userId); @@ -3597,7 +3648,7 @@ public class JellyfinController : ControllerBase var localUsedCount = 0; var externalUsedCount = 0; - _logger.LogInformation("🔍 Building playlist in Spotify order with {SpotifyCount} positions...", spotifyTracks.Count); + _logger.LogDebug("🔍 Building playlist in Spotify order with {SpotifyCount} positions...", spotifyTracks.Count); foreach (var spotifyTrack in spotifyTracks.OrderBy(t => t.Position)) { @@ -3681,15 +3732,17 @@ public class JellyfinController : ControllerBase } } - _logger.LogInformation( - "🎵 Final playlist '{Playlist}': {Total} tracks ({Local} LOCAL + {External} EXTERNAL)", + _logger.LogDebug("🎵 Final playlist '{Playlist}': {Total} tracks ({Local} LOCAL + {External} EXTERNAL)", spotifyPlaylistName, finalItems.Count, localUsedCount, externalUsedCount); // Save to file cache for persistence across restarts await SavePlaylistItemsToFile(spotifyPlaylistName, finalItems); // Also cache in Redis for fast serving (reuse the same cache key from top of method) - await _cache.SetAsync(cacheKey, finalItems, TimeSpan.FromHours(24)); + await _cache.SetAsync(cacheKey, finalItems, CacheExtensions.SpotifyPlaylistItemsTTL); + + // Cache the Jellyfin playlist signature to detect future changes + await _cache.SetAsync(jellyfinSignatureCacheKey, currentJellyfinSignature, CacheExtensions.SpotifyPlaylistItemsTTL); // Return raw Jellyfin response format return new JsonResult(new @@ -3710,7 +3763,7 @@ public class JellyfinController : ControllerBase if (cachedTracks != null && cachedTracks.Count > 0) { - _logger.LogDebug("Returning {Count} cached matched tracks from Redis for {Playlist}", + _logger.LogInformation("Returning {Count} cached matched tracks from Redis for {Playlist}", cachedTracks.Count, spotifyPlaylistName); return _responseBuilder.CreateItemsResponse(cachedTracks); } @@ -3721,8 +3774,8 @@ public class JellyfinController : ControllerBase cachedTracks = await LoadMatchedTracksFromFile(spotifyPlaylistName); if (cachedTracks != null && cachedTracks.Count > 0) { - // Restore to Redis with 1 hour TTL - await _cache.SetAsync(cacheKey, cachedTracks, TimeSpan.FromHours(1)); + // Restore to Redis with configurable TTL + await _cache.SetAsync(cacheKey, cachedTracks, CacheExtensions.SpotifyMatchedTracksTTL); _logger.LogInformation("Loaded {Count} matched tracks from file cache for {Playlist}", cachedTracks.Count, spotifyPlaylistName); return _responseBuilder.CreateItemsResponse(cachedTracks); @@ -3739,7 +3792,7 @@ public class JellyfinController : ControllerBase } else { - _logger.LogWarning("No UserId configured - may not be able to fetch existing playlist tracks"); + _logger.LogInformation("No UserId configured - may not be able to fetch existing playlist tracks"); } var (existingTracksResponse, _) = await _proxyService.GetJsonAsync( @@ -3784,7 +3837,7 @@ public class JellyfinController : ControllerBase if (missingTracks != null && missingTracks.Count > 0) { await _cache.SetAsync(missingTracksKey, missingTracks, TimeSpan.FromDays(365)); - _logger.LogInformation("Restored {Count} missing tracks from file cache for {Playlist} (no expiration)", + _logger.LogDebug("Restored {Count} missing tracks from file cache for {Playlist} (no expiration)", missingTracks.Count, spotifyPlaylistName); } } @@ -3796,7 +3849,7 @@ public class JellyfinController : ControllerBase return _responseBuilder.CreateItemsResponse(existingTracks); } - _logger.LogInformation("Matching {Count} missing tracks for {Playlist}", + _logger.LogDebug("Matching {Count} missing tracks for {Playlist}", missingTracks.Count, spotifyPlaylistName); // Match missing tracks sequentially with rate limiting (excluding ones we already have locally) @@ -3855,7 +3908,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", + _logger.LogError(ex, "Failed to match track: {Title} - {Artist}", track.Title, track.PrimaryArtist); } } @@ -3879,7 +3932,7 @@ public class JellyfinController : ControllerBase finalTracks.AddRange(existingTracks); } - await _cache.SetAsync(cacheKey, finalTracks, TimeSpan.FromHours(1)); + await _cache.SetAsync(cacheKey, finalTracks, CacheExtensions.SpotifyMatchedTracksTTL); // Also save to file cache for persistence across restarts await SaveMatchedTracksToFile(spotifyPlaylistName, finalTracks); @@ -3948,7 +4001,7 @@ public class JellyfinController : ControllerBase if (cacheFiles.Length > 0) { sourceFilePath = cacheFiles[0]; - _logger.LogInformation("Found track in cache folder: {Path}", sourceFilePath); + _logger.LogDebug("Found track in cache folder: {Path}", sourceFilePath); } } @@ -3962,7 +4015,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to download track {ItemId}", itemId); + _logger.LogError(ex, "Failed to download track {ItemId}", itemId); return; } } @@ -3983,7 +4036,7 @@ public class JellyfinController : ControllerBase } System.IO.File.Copy(sourceFilePath, keptFilePath, overwrite: false); - _logger.LogInformation("✓ Copied track to kept folder: {Path}", keptFilePath); + _logger.LogDebug("✓ Copied track to kept folder: {Path}", keptFilePath); // Also copy cover art if it exists var sourceCoverPath = Path.Combine(Path.GetDirectoryName(sourceFilePath)!, "cover.jpg"); @@ -4044,7 +4097,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to check favorite status for {ItemId}", itemId); + _logger.LogError(ex, "Failed to check favorite status for {ItemId}", itemId); return false; } } @@ -4083,7 +4136,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to mark track as favorited: {ItemId}", itemId); + _logger.LogError(ex, "Failed to mark track as favorited: {ItemId}", itemId); } } @@ -4109,7 +4162,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to remove track from favorites: {ItemId}", itemId); + _logger.LogError(ex, "Failed to remove track from favorites: {ItemId}", itemId); } } @@ -4145,7 +4198,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to mark track for deletion: {ItemId}", itemId); + _logger.LogError(ex, "Failed to mark track for deletion: {ItemId}", itemId); } } @@ -4190,7 +4243,7 @@ public class JellyfinController : ControllerBase var updatedJson = JsonSerializer.Serialize(remaining, new JsonSerializerOptions { WriteIndented = true }); await System.IO.File.WriteAllTextAsync(deletionFilePath, updatedJson); - _logger.LogInformation("Processed {Count} pending deletions", toDelete.Count); + _logger.LogDebug("Processed {Count} pending deletions", toDelete.Count); } } catch (Exception ex) @@ -4224,7 +4277,7 @@ public class JellyfinController : ControllerBase foreach (var trackFile in trackFiles) { System.IO.File.Delete(trackFile); - _logger.LogInformation("✓ Deleted track from kept folder: {Path}", trackFile); + _logger.LogDebug("✓ Deleted track from kept folder: {Path}", trackFile); } // Clean up empty directories @@ -4242,7 +4295,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to delete track {ItemId}", itemId); + _logger.LogError(ex, "Failed to delete track {ItemId}", itemId); } } @@ -4271,14 +4324,14 @@ public class JellyfinController : ControllerBase var json = await System.IO.File.ReadAllTextAsync(filePath); var tracks = JsonSerializer.Deserialize>(json); - _logger.LogInformation("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)", + _logger.LogDebug("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)", tracks?.Count ?? 0, playlistName, fileAge.TotalHours); return tracks; } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to load missing tracks from file for {Playlist}", playlistName); + _logger.LogError(ex, "Failed to load missing tracks from file for {Playlist}", playlistName); return null; } } @@ -4295,7 +4348,7 @@ public class JellyfinController : ControllerBase if (!System.IO.File.Exists(filePath)) { - _logger.LogDebug("No matched tracks file cache found for {Playlist} at {Path}", playlistName, filePath); + _logger.LogInformation("No matched tracks file cache found for {Playlist} at {Path}", playlistName, filePath); return null; } @@ -4309,7 +4362,7 @@ public class JellyfinController : ControllerBase return null; } - _logger.LogDebug("Matched tracks file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours); + _logger.LogInformation("Matched tracks file cache for {Playlist} age: {Age:F1}h", playlistName, fileAge.TotalHours); var json = await System.IO.File.ReadAllTextAsync(filePath); var tracks = JsonSerializer.Deserialize>(json); @@ -4321,7 +4374,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to load matched tracks from file for {Playlist}", playlistName); + _logger.LogError(ex, "Failed to load matched tracks from file for {Playlist}", playlistName); return null; } } @@ -4351,6 +4404,54 @@ public class JellyfinController : ControllerBase } } + /// + /// Gets a signature (hash) of the Jellyfin playlist to detect changes. + /// This is a cheap operation compared to re-matching all tracks. + /// Signature includes: track count + concatenated track IDs. + /// + private async Task GetJellyfinPlaylistSignatureAsync(string playlistId) + { + try + { + var userId = _settings.UserId; + var playlistItemsUrl = $"Playlists/{playlistId}/Items?Fields=Id"; + if (!string.IsNullOrEmpty(userId)) + { + playlistItemsUrl += $"&UserId={userId}"; + } + + var (response, _) = await _proxyService.GetJsonAsync(playlistItemsUrl, null, Request.Headers); + + if (response != null && response.RootElement.TryGetProperty("Items", out var items)) + { + var trackIds = new List(); + foreach (var item in items.EnumerateArray()) + { + if (item.TryGetProperty("Id", out var idEl)) + { + trackIds.Add(idEl.GetString() ?? ""); + } + } + + // Create signature: count + sorted IDs (sorted for consistency) + trackIds.Sort(); + var signature = $"{trackIds.Count}:{string.Join(",", trackIds)}"; + + // Hash it to keep it compact + using var sha256 = System.Security.Cryptography.SHA256.Create(); + var hashBytes = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(signature)); + return Convert.ToHexString(hashBytes); + } + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Failed to get Jellyfin playlist signature for {PlaylistId}", playlistId); + } + + // Return empty string if failed (will trigger re-match) + return string.Empty; + } + /// /// Saves playlist items (raw Jellyfin JSON) to file cache for persistence across restarts. /// @@ -4367,7 +4468,7 @@ public class JellyfinController : ControllerBase var json = JsonSerializer.Serialize(items, new JsonSerializerOptions { WriteIndented = true }); await System.IO.File.WriteAllTextAsync(filePath, json); - _logger.LogInformation("💾 Saved {Count} playlist items to file cache for {Playlist}", + _logger.LogDebug("💾 Saved {Count} playlist items to file cache for {Playlist}", items.Count, playlistName); } catch (Exception ex) @@ -4397,7 +4498,7 @@ public class JellyfinController : ControllerBase // Check if cache is too old (more than 24 hours) if (fileAge.TotalHours > 24) { - _logger.LogInformation("Playlist items file cache for {Playlist} is too old ({Age:F1}h), will rebuild", + _logger.LogDebug("Playlist items file cache for {Playlist} is too old ({Age:F1}h), will rebuild", playlistName, fileAge.TotalHours); return null; } @@ -4407,14 +4508,14 @@ public class JellyfinController : ControllerBase var json = await System.IO.File.ReadAllTextAsync(filePath); var items = JsonSerializer.Deserialize>>(json); - _logger.LogInformation("💿 Loaded {Count} playlist items from file cache for {Playlist} (age: {Age:F1}h)", + _logger.LogDebug("💿 Loaded {Count} playlist items from file cache for {Playlist} (age: {Age:F1}h)", items?.Count ?? 0, playlistName, fileAge.TotalHours); return items; } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to load playlist items from file for {Playlist}", playlistName); + _logger.LogError(ex, "Failed to load playlist items from file for {Playlist}", playlistName); return null; } } @@ -4571,7 +4672,7 @@ public class JellyfinController : ControllerBase } catch (Exception ex) { - _logger.LogWarning(ex, "Error finding Spotify ID for external track"); + _logger.LogError(ex, "Error finding Spotify ID for external track"); return null; } } diff --git a/allstarr/Controllers/SubSonicController.cs b/allstarr/Controllers/SubSonicController.cs index d30ee34..32dba32 100644 --- a/allstarr/Controllers/SubSonicController.cs +++ b/allstarr/Controllers/SubSonicController.cs @@ -145,14 +145,14 @@ public class SubsonicController : ControllerBase if (localPath != null && System.IO.File.Exists(localPath)) { - // Update last access time for cache cleanup + // Update last write time for cache cleanup (extends cache lifetime) try { - System.IO.File.SetLastAccessTimeUtc(localPath, DateTime.UtcNow); + System.IO.File.SetLastWriteTimeUtc(localPath, DateTime.UtcNow); } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to update last access time for {Path}", localPath); + _logger.LogError(ex, "Failed to update last write time for {Path}", localPath); } var stream = System.IO.File.OpenRead(localPath); @@ -590,8 +590,8 @@ public class SubsonicController : ControllerBase var imageBytes = await imageResponse.Content.ReadAsByteArrayAsync(); var contentType = imageResponse.Content.Headers.ContentType?.ToString() ?? "image/jpeg"; - // Cache for 1 hour (playlists can change, so don't cache too long) - await _cache.SetAsync(cacheKey, imageBytes, TimeSpan.FromHours(1)); + // Cache for configurable duration (playlists can change) + await _cache.SetAsync(cacheKey, imageBytes, CacheExtensions.PlaylistImagesTTL); _logger.LogDebug("Cached playlist cover art for {Id}", id); return File(imageBytes, contentType); diff --git a/allstarr/Filters/ApiKeyAuthFilter.cs b/allstarr/Filters/ApiKeyAuthFilter.cs index ef403e4..345ad47 100644 --- a/allstarr/Filters/ApiKeyAuthFilter.cs +++ b/allstarr/Filters/ApiKeyAuthFilter.cs @@ -46,7 +46,7 @@ public class ApiKeyAuthFilter : IAsyncActionFilter return; } - _logger.LogDebug("API key authentication successful for {Path}", request.Path); + _logger.LogInformation("API key authentication successful for {Path}", request.Path); await next(); } } diff --git a/allstarr/Middleware/WebSocketProxyMiddleware.cs b/allstarr/Middleware/WebSocketProxyMiddleware.cs index 705cdcc..b4a9482 100644 --- a/allstarr/Middleware/WebSocketProxyMiddleware.cs +++ b/allstarr/Middleware/WebSocketProxyMiddleware.cs @@ -27,7 +27,7 @@ public class WebSocketProxyMiddleware _logger = logger; _sessionManager = sessionManager; - _logger.LogDebug("🔧 WEBSOCKET: WebSocketProxyMiddleware initialized - Jellyfin URL: {Url}", _settings.Url); + _logger.LogInformation("🔧 WEBSOCKET: WebSocketProxyMiddleware initialized - Jellyfin URL: {Url}", _settings.Url); } public async Task InvokeAsync(HttpContext context) @@ -139,10 +139,10 @@ public class WebSocketProxyMiddleware } // Set user agent - serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0"); + serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0.1"); await serverWebSocket.ConnectAsync(new Uri(jellyfinWsUrl), context.RequestAborted); - _logger.LogDebug("✓ WEBSOCKET: Connected to Jellyfin WebSocket"); + _logger.LogInformation("✓ WEBSOCKET: Connected to Jellyfin WebSocket"); // Start bidirectional proxying var clientToServer = ProxyMessagesAsync(clientWebSocket, serverWebSocket, "Client→Server", context.RequestAborted); @@ -158,7 +158,7 @@ public class WebSocketProxyMiddleware // 403 is expected when tokens expire or session ends - don't spam logs if (wsEx.Message.Contains("403")) { - _logger.LogDebug("WEBSOCKET: Connection rejected with 403 (token expired or session ended)"); + _logger.LogWarning("WEBSOCKET: Connection rejected with 403 (token expired or session ended)"); } else { @@ -180,7 +180,7 @@ public class WebSocketProxyMiddleware } catch (Exception ex) { - _logger.LogDebug(ex, "Error closing client WebSocket"); + _logger.LogError(ex, "Error closing client WebSocket"); } } @@ -192,7 +192,7 @@ public class WebSocketProxyMiddleware } catch (Exception ex) { - _logger.LogDebug(ex, "Error closing server WebSocket"); + _logger.LogError(ex, "Error closing server WebSocket"); } } @@ -202,7 +202,7 @@ public class WebSocketProxyMiddleware // CRITICAL: Notify session manager that client disconnected if (!string.IsNullOrEmpty(deviceId)) { - _logger.LogDebug("🧹 WEBSOCKET: Client disconnected, removing session for device {DeviceId}", deviceId); + _logger.LogInformation("🧹 WEBSOCKET: Client disconnected, removing session for device {DeviceId}", deviceId); await _sessionManager.RemoveSessionAsync(deviceId); } @@ -247,7 +247,7 @@ public class WebSocketProxyMiddleware if (direction == "Server→Client") { var messageText = System.Text.Encoding.UTF8.GetString(messageBytes); - _logger.LogTrace("📥 WEBSOCKET {Direction}: {Preview}", + _logger.LogDebug("📥 WEBSOCKET {Direction}: {Preview}", direction, messageText.Length > 500 ? messageText[..500] + "..." : messageText); } @@ -282,7 +282,7 @@ public class WebSocketProxyMiddleware } catch (Exception ex) { - _logger.LogDebug(ex, "WEBSOCKET {Direction}: Error proxying messages (connection closed)", direction); + _logger.LogError(ex, "WEBSOCKET {Direction}: Error proxying messages (connection closed)", direction); } } } diff --git a/allstarr/Models/Domain/Song.cs b/allstarr/Models/Domain/Song.cs index c61202e..0b244e5 100644 --- a/allstarr/Models/Domain/Song.cs +++ b/allstarr/Models/Domain/Song.cs @@ -19,6 +19,12 @@ public class Song /// All artists for this track (main + featured). For display in Jellyfin clients. /// public List Artists { get; set; } = new(); + + /// + /// All artist IDs corresponding to the Artists list. Index-matched with Artists. + /// + public List ArtistIds { get; set; } = new(); + public string Album { get; set; } = string.Empty; public string? AlbumId { get; set; } public int? Duration { get; set; } // In seconds diff --git a/allstarr/Models/Settings/CacheSettings.cs b/allstarr/Models/Settings/CacheSettings.cs new file mode 100644 index 0000000..a4eca44 --- /dev/null +++ b/allstarr/Models/Settings/CacheSettings.cs @@ -0,0 +1,74 @@ +namespace allstarr.Models.Settings; + +/// +/// Cache TTL (Time To Live) settings for various data types. +/// All values are configurable via Web UI and require restart to apply. +/// +public class CacheSettings +{ + /// + /// Search results cache duration in minutes. + /// Default: 120 minutes (2 hours) + /// + public int SearchResultsMinutes { get; set; } = 120; + + /// + /// Playlist cover images cache duration in hours. + /// Default: 168 hours (1 week) + /// + public int PlaylistImagesHours { get; set; } = 168; + + /// + /// Spotify playlist items cache duration in hours. + /// Default: 168 hours (1 week, until next cron job) + /// + public int SpotifyPlaylistItemsHours { get; set; } = 168; + + /// + /// Spotify matched tracks cache duration in days. + /// This is the mapping of Spotify IDs to local/external tracks. + /// Default: 30 days + /// + public int SpotifyMatchedTracksDays { get; set; } = 30; + + /// + /// Lyrics cache duration in days. + /// Default: 14 days (2 weeks) + /// + public int LyricsDays { get; set; } = 14; + + /// + /// Genre data cache duration in days. + /// Default: 30 days + /// + public int GenreDays { get; set; } = 30; + + /// + /// External metadata (SquidWTF albums/artists) cache duration in days. + /// Default: 7 days + /// + public int MetadataDays { get; set; } = 7; + + /// + /// Odesli Spotify ID lookup cache duration in days. + /// Default: 60 days + /// + public int OdesliLookupDays { get; set; } = 60; + + /// + /// Jellyfin proxy images cache duration in days. + /// Default: 14 days (2 weeks) + /// + public int ProxyImagesDays { get; set; } = 14; + + // Helper methods to get TimeSpan values + public TimeSpan SearchResultsTTL => TimeSpan.FromMinutes(SearchResultsMinutes); + public TimeSpan PlaylistImagesTTL => TimeSpan.FromHours(PlaylistImagesHours); + public TimeSpan SpotifyPlaylistItemsTTL => TimeSpan.FromHours(SpotifyPlaylistItemsHours); + public TimeSpan SpotifyMatchedTracksTTL => TimeSpan.FromDays(SpotifyMatchedTracksDays); + public TimeSpan LyricsTTL => TimeSpan.FromDays(LyricsDays); + public TimeSpan GenreTTL => TimeSpan.FromDays(GenreDays); + public TimeSpan MetadataTTL => TimeSpan.FromDays(MetadataDays); + public TimeSpan OdesliLookupTTL => TimeSpan.FromDays(OdesliLookupDays); + public TimeSpan ProxyImagesTTL => TimeSpan.FromDays(ProxyImagesDays); +} diff --git a/allstarr/Models/Settings/JellyfinSettings.cs b/allstarr/Models/Settings/JellyfinSettings.cs index 22d212b..b7c62b3 100644 --- a/allstarr/Models/Settings/JellyfinSettings.cs +++ b/allstarr/Models/Settings/JellyfinSettings.cs @@ -43,7 +43,7 @@ public class JellyfinSettings /// /// Client version reported to Jellyfin /// - public string ClientVersion { get; set; } = "1.0.0"; + public string ClientVersion { get; set; } = "1.0.1"; /// /// Device ID reported to Jellyfin diff --git a/allstarr/Models/Settings/SpotifyApiSettings.cs b/allstarr/Models/Settings/SpotifyApiSettings.cs index 88f23d4..fcf81b8 100644 --- a/allstarr/Models/Settings/SpotifyApiSettings.cs +++ b/allstarr/Models/Settings/SpotifyApiSettings.cs @@ -18,18 +18,6 @@ public class SpotifyApiSettings /// public bool Enabled { get; set; } - /// - /// Spotify Client ID from https://developer.spotify.com/dashboard - /// Used for OAuth token refresh and API access. - /// - public string ClientId { get; set; } = string.Empty; - - /// - /// Spotify Client Secret from https://developer.spotify.com/dashboard - /// Optional - only needed for certain OAuth flows. - /// - public string ClientSecret { get; set; } = string.Empty; - /// /// Spotify session cookie (sp_dc). /// Required for accessing editorial/personalized playlists like Release Radar and Discover Weekly. diff --git a/allstarr/Models/Settings/SpotifyImportSettings.cs b/allstarr/Models/Settings/SpotifyImportSettings.cs index aa810c0..48956b9 100644 --- a/allstarr/Models/Settings/SpotifyImportSettings.cs +++ b/allstarr/Models/Settings/SpotifyImportSettings.cs @@ -45,6 +45,14 @@ public class SpotifyPlaylistConfig /// Where to position local tracks: "first" or "last" /// public LocalTracksPosition LocalTracksPosition { get; set; } = LocalTracksPosition.First; + + /// + /// Cron schedule for syncing this playlist with Spotify + /// Format: minute hour day month dayofweek + /// Example: "0 8 * * 1" = 8 AM every Monday + /// Default: "0 8 * * 1" (weekly on Monday at 8 AM) + /// + public string SyncSchedule { get; set; } = "0 8 * * 1"; } /// diff --git a/allstarr/Models/Settings/SquidWTFSettings.cs b/allstarr/Models/Settings/SquidWTFSettings.cs index a6875d1..a9d20c6 100644 --- a/allstarr/Models/Settings/SquidWTFSettings.cs +++ b/allstarr/Models/Settings/SquidWTFSettings.cs @@ -6,12 +6,12 @@ namespace allstarr.Models.Settings; public class SquidWTFSettings { /// - /// No user auth should be needed for this site. - /// - - /// - /// Preferred audio quality: FLAC, MP3_320, MP3_128 - /// If not specified or unavailable, the highest available quality will be used. + /// Preferred audio quality: + /// - HI_RES or HI_RES_LOSSLESS: 24-bit/192kHz FLAC (highest quality) + /// - FLAC or LOSSLESS: 16-bit/44.1kHz FLAC (CD quality, default) + /// - HIGH: 320kbps AAC (high quality, smaller files) + /// - LOW: 96kbps AAC (low quality, smallest files) + /// If not specified or unavailable, LOSSLESS will be used. /// public string? Quality { get; set; } } diff --git a/allstarr/Program.cs b/allstarr/Program.cs index 1e97e68..41aaf06 100644 --- a/allstarr/Program.cs +++ b/allstarr/Program.cs @@ -13,9 +13,28 @@ using allstarr.Middleware; using allstarr.Filters; using Microsoft.Extensions.Http; using System.Text; +using System.Net; var builder = WebApplication.CreateBuilder(args); +// Configure forwarded headers for reverse proxy support (nginx, etc.) +// This allows ASP.NET Core to read X-Forwarded-For, X-Real-IP, etc. +builder.Services.Configure(options => +{ + options.ForwardedHeaders = Microsoft.AspNetCore.HttpOverrides.ForwardedHeaders.XForwardedFor + | Microsoft.AspNetCore.HttpOverrides.ForwardedHeaders.XForwardedProto + | Microsoft.AspNetCore.HttpOverrides.ForwardedHeaders.XForwardedHost; + + // Clear known networks and proxies to accept headers from any proxy + // This is safe when running behind a trusted reverse proxy (nginx) + options.KnownIPNetworks.Clear(); + options.KnownProxies.Clear(); + + // Trust X-Forwarded-* headers from any source + // Only do this if your reverse proxy is properly configured and trusted + options.ForwardLimit = null; +}); + // Decode SquidWTF API base URLs once at startup var squidWtfApiUrls = DecodeSquidWtfUrls(); static List DecodeSquidWtfUrls() @@ -131,6 +150,8 @@ builder.Services.Configure( builder.Configuration.GetSection("SquidWTF")); builder.Services.Configure( builder.Configuration.GetSection("Redis")); +builder.Services.Configure( + builder.Configuration.GetSection("Cache")); // Configure Spotify Import settings with custom playlist parsing from env var builder.Services.Configure(options => { @@ -454,7 +475,8 @@ else if (musicService == MusicService.SquidWTF) sp.GetRequiredService>(), sp.GetRequiredService>(), sp.GetRequiredService(), - squidWtfApiUrls)); + squidWtfApiUrls, + sp.GetRequiredService())); builder.Services.AddSingleton(sp => new SquidWTFDownloadService( sp.GetRequiredService(), @@ -505,6 +527,9 @@ builder.Services.AddHostedService(); // Register cache warming service (loads file caches into Redis on startup) builder.Services.AddHostedService(); +// Register Redis persistence service (snapshots Redis to files periodically) +builder.Services.AddHostedService(); + // Register Spotify API client, lyrics service, and settings for direct API access // Configure from environment variables with SPOTIFY_API_ prefix builder.Services.Configure(options => @@ -518,18 +543,6 @@ builder.Services.Configure(options options.Enabled = enabled.Equals("true", StringComparison.OrdinalIgnoreCase); } - var clientId = builder.Configuration.GetValue("SpotifyApi:ClientId"); - if (!string.IsNullOrEmpty(clientId)) - { - options.ClientId = clientId; - } - - var clientSecret = builder.Configuration.GetValue("SpotifyApi:ClientSecret"); - if (!string.IsNullOrEmpty(clientSecret)) - { - options.ClientSecret = clientSecret; - } - var sessionCookie = builder.Configuration.GetValue("SpotifyApi:SessionCookie"); if (!string.IsNullOrEmpty(sessionCookie)) { @@ -557,7 +570,6 @@ builder.Services.Configure(options // Log configuration (mask sensitive values) Console.WriteLine($"SpotifyApi Configuration:"); Console.WriteLine($" Enabled: {options.Enabled}"); - Console.WriteLine($" ClientId: {(string.IsNullOrEmpty(options.ClientId) ? "(not set)" : options.ClientId[..8] + "...")}"); Console.WriteLine($" SessionCookie: {(string.IsNullOrEmpty(options.SessionCookie) ? "(not set)" : "***" + options.SessionCookie[^8..])}"); Console.WriteLine($" SessionCookieSetDate: {options.SessionCookieSetDate ?? "(not set)"}"); Console.WriteLine($" CacheDurationMinutes: {options.CacheDurationMinutes}"); @@ -568,6 +580,12 @@ builder.Services.AddSingleton(); // Register Spotify lyrics service (uses Spotify's color-lyrics API) builder.Services.AddSingleton(); +// Register LyricsPlus service (multi-source lyrics API) +builder.Services.AddSingleton(); + +// Register Lyrics Orchestrator (manages priority-based lyrics fetching) +builder.Services.AddSingleton(); + // Register Spotify playlist fetcher (uses direct Spotify API when SpotifyApi is enabled) builder.Services.AddSingleton(); builder.Services.AddHostedService(sp => sp.GetRequiredService()); @@ -626,7 +644,26 @@ builder.Services.AddCors(options => var app = builder.Build(); +// Initialize cache settings for static access +CacheExtensions.InitializeCacheSettings(app.Services); + +// Migrate old .env file format on startup +try +{ + var migrationService = new EnvMigrationService(app.Services.GetRequiredService>()); + migrationService.MigrateEnvFile(); +} +catch (Exception ex) +{ + app.Logger.LogWarning(ex, "Failed to run .env migration"); +} + // Configure the HTTP request pipeline. + +// IMPORTANT: UseForwardedHeaders must be called BEFORE other middleware +// This processes X-Forwarded-For, X-Real-IP, etc. from nginx +app.UseForwardedHeaders(); + app.UseExceptionHandler(_ => { }); // Global exception handler // Enable response compression EARLY in the pipeline diff --git a/allstarr/Services/Common/BaseDownloadService.cs b/allstarr/Services/Common/BaseDownloadService.cs index 9ccfad8..dce837b 100644 --- a/allstarr/Services/Common/BaseDownloadService.cs +++ b/allstarr/Services/Common/BaseDownloadService.cs @@ -104,10 +104,10 @@ public abstract class BaseDownloadService : IDownloadService var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds; Logger.LogInformation("Streaming from local cache ({ElapsedMs}ms): {Path}", elapsed, localPath); - // Update access time for cache cleanup + // Update write time for cache cleanup (extends cache lifetime) if (SubsonicSettings.StorageMode == StorageMode.Cache) { - IOFile.SetLastAccessTime(localPath, DateTime.UtcNow); + IOFile.SetLastWriteTime(localPath, DateTime.UtcNow); } // Start background Odesli conversion for lyrics (if not already cached) @@ -264,6 +264,7 @@ public abstract class BaseDownloadService : IDownloadService // Acquire lock BEFORE checking existence to prevent race conditions with concurrent requests await DownloadLock.WaitAsync(cancellationToken); + var lockHeld = true; try { @@ -273,10 +274,10 @@ public abstract class BaseDownloadService : IDownloadService { Logger.LogInformation("Song already downloaded: {Path}", existingPath); - // For cache mode, update file access time for cache cleanup logic + // For cache mode, update file write time to extend cache lifetime if (isCache) { - IOFile.SetLastAccessTime(existingPath, DateTime.UtcNow); + IOFile.SetLastWriteTime(existingPath, DateTime.UtcNow); } return existingPath; @@ -288,6 +289,7 @@ public abstract class BaseDownloadService : IDownloadService Logger.LogDebug("Download already in progress for {SongId}, waiting for completion...", songId); // Release lock while waiting DownloadLock.Release(); + lockHeld = false; // Wait for download to complete, checking every 100ms (faster than 500ms) // Also respect cancellation token so client timeouts are handled immediately @@ -444,7 +446,10 @@ public abstract class BaseDownloadService : IDownloadService } finally { - DownloadLock.Release(); + if (lockHeld) + { + DownloadLock.Release(); + } } } diff --git a/allstarr/Services/Common/CacheCleanupService.cs b/allstarr/Services/Common/CacheCleanupService.cs index 662e1a0..1a1968f 100644 --- a/allstarr/Services/Common/CacheCleanupService.cs +++ b/allstarr/Services/Common/CacheCleanupService.cs @@ -66,7 +66,9 @@ public class CacheCleanupService : BackgroundService private async Task CleanupOldCachedFilesAsync(CancellationToken cancellationToken) { - var cachePath = PathHelper.GetCachePath(); + // Get the actual cache path used by download services + var downloadPath = _configuration["Library:DownloadPath"] ?? "downloads"; + var cachePath = Path.Combine(downloadPath, "cache"); if (!Directory.Exists(cachePath)) { @@ -78,7 +80,7 @@ public class CacheCleanupService : BackgroundService var deletedCount = 0; var totalSize = 0L; - _logger.LogInformation("Starting cache cleanup: deleting files older than {CutoffTime}", cutoffTime); + _logger.LogInformation("Starting cache cleanup: deleting files older than {CutoffTime} from {Path}", cutoffTime, cachePath); try { @@ -108,7 +110,7 @@ public class CacheCleanupService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to delete cached file: {Path}", filePath); + _logger.LogError(ex, "Failed to delete cached file: {Path}", filePath); } } @@ -123,7 +125,7 @@ public class CacheCleanupService : BackgroundService } else { - _logger.LogDebug("Cache cleanup completed: no files to delete"); + _logger.LogInformation("Cache cleanup completed: no files to delete"); } } catch (Exception ex) @@ -154,13 +156,13 @@ public class CacheCleanupService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to delete empty directory: {Path}", directory); + _logger.LogError(ex, "Failed to delete empty directory: {Path}", directory); } } } catch (Exception ex) { - _logger.LogWarning(ex, "Error cleaning up empty directories"); + _logger.LogError(ex, "Error cleaning up empty directories"); } await Task.CompletedTask; diff --git a/allstarr/Services/Common/CacheExtensions.cs b/allstarr/Services/Common/CacheExtensions.cs new file mode 100644 index 0000000..0026096 --- /dev/null +++ b/allstarr/Services/Common/CacheExtensions.cs @@ -0,0 +1,52 @@ +using Microsoft.Extensions.Options; +using allstarr.Models.Settings; + +namespace allstarr.Services.Common; + +/// +/// Extension methods for cache TTL management. +/// Provides centralized access to configurable cache durations. +/// +public static class CacheExtensions +{ + private static CacheSettings? _cacheSettings; + private static readonly object _lock = new(); + + /// + /// Initialize cache settings (called once at startup). + /// + public static void InitializeCacheSettings(IServiceProvider serviceProvider) + { + lock (_lock) + { + if (_cacheSettings == null) + { + var options = serviceProvider.GetService>(); + _cacheSettings = options?.Value ?? new CacheSettings(); + } + } + } + + /// + /// Get the current cache settings. + /// + public static CacheSettings GetCacheSettings() + { + if (_cacheSettings == null) + { + throw new InvalidOperationException("Cache settings not initialized. Call InitializeCacheSettings first."); + } + return _cacheSettings; + } + + // Convenience methods for getting TTLs + public static TimeSpan SearchResultsTTL => GetCacheSettings().SearchResultsTTL; + public static TimeSpan PlaylistImagesTTL => GetCacheSettings().PlaylistImagesTTL; + public static TimeSpan SpotifyPlaylistItemsTTL => GetCacheSettings().SpotifyPlaylistItemsTTL; + public static TimeSpan SpotifyMatchedTracksTTL => GetCacheSettings().SpotifyMatchedTracksTTL; + public static TimeSpan LyricsTTL => GetCacheSettings().LyricsTTL; + public static TimeSpan GenreTTL => GetCacheSettings().GenreTTL; + public static TimeSpan MetadataTTL => GetCacheSettings().MetadataTTL; + public static TimeSpan OdesliLookupTTL => GetCacheSettings().OdesliLookupTTL; + public static TimeSpan ProxyImagesTTL => GetCacheSettings().ProxyImagesTTL; +} diff --git a/allstarr/Services/Common/CacheWarmingService.cs b/allstarr/Services/Common/CacheWarmingService.cs index 7e0c2b8..f2be362 100644 --- a/allstarr/Services/Common/CacheWarmingService.cs +++ b/allstarr/Services/Common/CacheWarmingService.cs @@ -105,19 +105,19 @@ public class CacheWarmingService : IHostedService if (cacheEntry != null && !string.IsNullOrEmpty(cacheEntry.CacheKey)) { var redisKey = $"genre:{cacheEntry.CacheKey}"; - await _cache.SetAsync(redisKey, cacheEntry.Genre, TimeSpan.FromDays(30)); + await _cache.SetAsync(redisKey, cacheEntry.Genre, CacheExtensions.GenreTTL); warmedCount++; } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm genre cache from file: {File}", file); + _logger.LogError(ex, "Failed to warm genre cache from file: {File}", file); } } if (warmedCount > 0) { - _logger.LogInformation("🔥 Warmed {Count} genre entries from file cache", warmedCount); + _logger.LogDebug("🔥 Warmed {Count} genre entries from file cache", warmedCount); } return warmedCount; @@ -162,7 +162,7 @@ public class CacheWarmingService : IHostedService var playlistName = fileName.Replace("_items", ""); var redisKey = $"spotify:playlist:items:{playlistName}"; - await _cache.SetAsync(redisKey, items, TimeSpan.FromHours(24)); + await _cache.SetAsync(redisKey, items, CacheExtensions.SpotifyPlaylistItemsTTL); warmedCount++; _logger.LogDebug("🔥 Warmed playlist items cache for {Playlist} ({Count} items)", @@ -171,7 +171,7 @@ public class CacheWarmingService : IHostedService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm playlist items cache from file: {File}", file); + _logger.LogError(ex, "Failed to warm playlist items cache from file: {File}", file); } } @@ -200,22 +200,22 @@ public class CacheWarmingService : IHostedService var playlistName = fileName.Replace("_matched", ""); var redisKey = $"spotify:matched:ordered:{playlistName}"; - await _cache.SetAsync(redisKey, matchedTracks, TimeSpan.FromHours(1)); + await _cache.SetAsync(redisKey, matchedTracks, CacheExtensions.SpotifyMatchedTracksTTL); warmedCount++; - _logger.LogDebug("🔥 Warmed matched tracks cache for {Playlist} ({Count} tracks)", + _logger.LogInformation("🔥 Warmed matched tracks cache for {Playlist} ({Count} tracks)", playlistName, matchedTracks.Count); } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm matched tracks cache from file: {File}", file); + _logger.LogError(ex, "Failed to warm matched tracks cache from file: {File}", file); } } if (warmedCount > 0) { - _logger.LogInformation("🔥 Warmed {Count} playlist caches from file system", warmedCount); + _logger.LogDebug("🔥 Warmed {Count} playlist caches from file system", warmedCount); } return warmedCount; @@ -276,13 +276,13 @@ public class CacheWarmingService : IHostedService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm manual mappings from file: {File}", file); + _logger.LogError(ex, "Failed to warm manual mappings from file: {File}", file); } } if (warmedCount > 0) { - _logger.LogInformation("🔥 Warmed {Count} manual mappings from file system", warmedCount); + _logger.LogDebug("🔥 Warmed {Count} manual mappings from file system", warmedCount); } return warmedCount; @@ -318,13 +318,13 @@ public class CacheWarmingService : IHostedService await _cache.SetStringAsync(redisKey, mapping.LyricsId.ToString()); } - _logger.LogInformation("🔥 Warmed {Count} lyrics mappings from file system", mappings.Count); + _logger.LogDebug("🔥 Warmed {Count} lyrics mappings from file system", mappings.Count); return mappings.Count; } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm lyrics mappings from file: {File}", mappingsFile); + _logger.LogError(ex, "Failed to warm lyrics mappings from file: {File}", mappingsFile); } return 0; @@ -356,7 +356,7 @@ public class CacheWarmingService : IHostedService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to warm lyrics cache"); + _logger.LogError(ex, "Failed to warm lyrics cache"); return 0; } } diff --git a/allstarr/Services/Common/EndpointBenchmarkService.cs b/allstarr/Services/Common/EndpointBenchmarkService.cs index 688e3d9..516d5fa 100644 --- a/allstarr/Services/Common/EndpointBenchmarkService.cs +++ b/allstarr/Services/Common/EndpointBenchmarkService.cs @@ -20,6 +20,9 @@ public class EndpointBenchmarkService /// /// Benchmarks a list of endpoints by making test requests. /// Returns endpoints sorted by average response time (fastest first). + /// + /// IMPORTANT: The testFunc should implement its own timeout to prevent slow endpoints + /// from blocking startup. Recommended: 5-10 second timeout per ping. /// public async Task> BenchmarkEndpointsAsync( List endpoints, @@ -27,7 +30,7 @@ public class EndpointBenchmarkService int pingCount = 3, CancellationToken cancellationToken = default) { - _logger.LogInformation("🏁 Benchmarking {Count} endpoints with {Pings} pings each...", endpoints.Count, pingCount); + _logger.LogDebug("🏁 Benchmarking {Count} endpoints with {Pings} pings each...", endpoints.Count, pingCount); var tasks = endpoints.Select(async endpoint => { @@ -51,7 +54,7 @@ public class EndpointBenchmarkService } catch (Exception ex) { - _logger.LogDebug(ex, "Benchmark ping failed for {Endpoint}", endpoint); + _logger.LogError(ex, "Benchmark ping failed for {Endpoint}", endpoint); } // Small delay between pings @@ -82,7 +85,7 @@ public class EndpointBenchmarkService _lock.Release(); } - _logger.LogInformation(" {Endpoint}: {AvgMs}ms avg, {SuccessRate:P0} success rate", + _logger.LogDebug(" {Endpoint}: {AvgMs}ms avg, {SuccessRate:P0} success rate", endpoint, avgMs, metrics.SuccessRate); return metrics; diff --git a/allstarr/Services/Common/EnvMigrationService.cs b/allstarr/Services/Common/EnvMigrationService.cs new file mode 100644 index 0000000..6a39cce --- /dev/null +++ b/allstarr/Services/Common/EnvMigrationService.cs @@ -0,0 +1,80 @@ +namespace allstarr.Services.Common; + +/// +/// Service that runs on startup to migrate old .env file format to new format +/// +public class EnvMigrationService +{ + private readonly ILogger _logger; + private readonly string _envFilePath; + + public EnvMigrationService(ILogger logger) + { + _logger = logger; + _envFilePath = Path.Combine(Directory.GetCurrentDirectory(), ".env"); + } + + public void MigrateEnvFile() + { + if (!File.Exists(_envFilePath)) + { + _logger.LogWarning("No .env file found, skipping migration"); + return; + } + + try + { + var lines = File.ReadAllLines(_envFilePath); + var modified = false; + + for (int i = 0; i < lines.Length; i++) + { + var line = lines[i].Trim(); + + // Skip comments and empty lines + if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#")) + continue; + + // Migrate DOWNLOAD_PATH to Library__DownloadPath + if (line.StartsWith("DOWNLOAD_PATH=")) + { + var value = line.Substring("DOWNLOAD_PATH=".Length); + lines[i] = $"Library__DownloadPath={value}"; + modified = true; + _logger.LogDebug("Migrated DOWNLOAD_PATH to Library__DownloadPath in .env file"); + } + + // Migrate old SquidWTF quality values to new format + if (line.StartsWith("SQUIDWTF_QUALITY=")) + { + var value = line.Substring("SQUIDWTF_QUALITY=".Length).Trim(); + var newValue = value.ToUpperInvariant() switch + { + "FLAC" => "LOSSLESS", + "HI_RES" => "HI_RES_LOSSLESS", + "MP3_320" => "HIGH", + "MP3_128" => "LOW", + _ => null // Keep as-is if already correct + }; + + if (newValue != null) + { + lines[i] = $"SQUIDWTF_QUALITY={newValue}"; + modified = true; + _logger.LogInformation("Migrated SQUIDWTF_QUALITY from {Old} to {New} in .env file", value, newValue); + } + } + } + + if (modified) + { + File.WriteAllLines(_envFilePath, lines); + _logger.LogInformation("✅ .env file migration completed successfully"); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to migrate .env file - please manually update DOWNLOAD_PATH to Library__DownloadPath"); + } + } +} diff --git a/allstarr/Services/Common/FuzzyMatcher.cs b/allstarr/Services/Common/FuzzyMatcher.cs index 80475e5..bf8aaf2 100644 --- a/allstarr/Services/Common/FuzzyMatcher.cs +++ b/allstarr/Services/Common/FuzzyMatcher.cs @@ -58,7 +58,8 @@ public static class FuzzyMatcher /// Calculates similarity score following OPTIMAL ORDER: /// 1. Strip decorators (already done by caller) /// 2. Substring matching (cheap, high-precision) - /// 3. Levenshtein distance (expensive, fuzzy) + /// 3. Token-based matching (handles word order) + /// 4. Levenshtein distance (expensive, fuzzy) /// Returns score 0-100. /// public static int CalculateSimilarity(string query, string target) @@ -103,11 +104,71 @@ public static class FuzzyMatcher return 85; } - // STEP 3: LEVENSHTEIN DISTANCE (expensive, fuzzy) - // Only use this for candidates that survived substring checks - - var distance = LevenshteinDistance(queryNorm, targetNorm); - var maxLength = Math.Max(queryNorm.Length, targetNorm.Length); + // STEP 3: TOKEN-BASED MATCHING (handles word order) + var tokens1 = queryNorm.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); + var tokens2 = targetNorm.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); + + if (tokens1.Length > 0 && tokens2.Length > 0) + { + // Calculate how many tokens match (order-independent) + var matchedTokens = 0.0; // Use double for partial matches + var usedTokens = new HashSet(); + + foreach (var token1 in tokens1) + { + for (int i = 0; i < tokens2.Length; i++) + { + if (usedTokens.Contains(i)) continue; + + var token2 = tokens2[i]; + + // Exact token match + if (token1 == token2) + { + matchedTokens++; + usedTokens.Add(i); + break; + } + // Partial token match (one contains the other) + else if (token1.Contains(token2) || token2.Contains(token1)) + { + matchedTokens += 0.8; // Partial credit + usedTokens.Add(i); + break; + } + } + } + + // Calculate token match percentage + var maxTokens = Math.Max(tokens1.Length, tokens2.Length); + var tokenMatchScore = (matchedTokens / maxTokens) * 100.0; + + // If token match is very high (90%+), return it + if (tokenMatchScore >= 90) + { + return (int)Math.Round(tokenMatchScore, MidpointRounding.AwayFromZero); + } + + // If token match is decent (70%+), use it as a floor for Levenshtein + if (tokenMatchScore >= 70) + { + var levenshteinScore = CalculateLevenshteinScore(queryNorm, targetNorm); + return (int)Math.Max(tokenMatchScore, levenshteinScore); + } + } + + // STEP 4: LEVENSHTEIN DISTANCE (expensive, fuzzy) + return CalculateLevenshteinScore(queryNorm, targetNorm); + } + + /// + /// Calculates similarity score based on Levenshtein distance. + /// Returns score 0-75 (reserve 75-100 for substring/token matches). + /// + private static int CalculateLevenshteinScore(string str1, string str2) + { + var distance = LevenshteinDistance(str1, str2); + var maxLength = Math.Max(str1.Length, str2.Length); if (maxLength == 0) { @@ -117,8 +178,9 @@ public static class FuzzyMatcher // Normalize distance by length: score = 1 - (distance / max_length) var normalizedSimilarity = 1.0 - ((double)distance / maxLength); - // Convert to 0-80 range (reserve 80-100 for substring matches) - var score = (int)(normalizedSimilarity * 80); + // Convert to 0-75 range (reserve 75-100 for substring/token matches) + // Using 75 instead of 80 to be slightly stricter + var score = (int)(normalizedSimilarity * 75); return Math.Max(0, score); } @@ -154,7 +216,9 @@ public static class FuzzyMatcher /// /// Normalizes a string for matching by: /// - Converting to lowercase - /// - Normalizing apostrophes (', ', ') to standard ' + /// - Removing accents/diacritics + /// - Converting hyphens/underscores to spaces (for word separation) + /// - Removing other punctuation (periods, apostrophes, commas, etc.) /// - Removing extra whitespace /// private static string NormalizeForMatching(string text) @@ -166,18 +230,42 @@ public static class FuzzyMatcher var normalized = text.ToLowerInvariant().Trim(); - // Normalize different apostrophe types to standard apostrophe - normalized = normalized - .Replace("\u2019", "'") // Right single quotation mark (') - .Replace("\u2018", "'") // Left single quotation mark (') - .Replace("`", "'") // Grave accent - .Replace("\u00B4", "'"); // Acute accent (´) + // Remove accents/diacritics (é -> e, ñ -> n, etc.) + normalized = RemoveDiacritics(normalized); + + // Replace hyphens and underscores with spaces (for word separation) + // This ensures "Dua-Lipa" becomes "Dua Lipa" not "DuaLipa" + normalized = normalized.Replace('-', ' ').Replace('_', ' '); + + // Remove all other punctuation: periods, apostrophes, commas, etc. + normalized = System.Text.RegularExpressions.Regex.Replace(normalized, @"[^\w\s]", ""); // Normalize whitespace - normalized = System.Text.RegularExpressions.Regex.Replace(normalized, @"\s+", " "); + normalized = System.Text.RegularExpressions.Regex.Replace(normalized, @"\s+", " ").Trim(); return normalized; } + + /// + /// Removes diacritics (accents) from characters. + /// Example: é -> e, ñ -> n, ü -> u + /// + private static string RemoveDiacritics(string text) + { + var normalizedString = text.Normalize(System.Text.NormalizationForm.FormD); + var stringBuilder = new System.Text.StringBuilder(); + + foreach (var c in normalizedString) + { + var unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(c); + if (unicodeCategory != System.Globalization.UnicodeCategory.NonSpacingMark) + { + stringBuilder.Append(c); + } + } + + return stringBuilder.ToString().Normalize(System.Text.NormalizationForm.FormC); + } /// /// Calculates Levenshtein distance between two strings. diff --git a/allstarr/Services/Common/GenreEnrichmentService.cs b/allstarr/Services/Common/GenreEnrichmentService.cs index d73077b..decae59 100644 --- a/allstarr/Services/Common/GenreEnrichmentService.cs +++ b/allstarr/Services/Common/GenreEnrichmentService.cs @@ -93,7 +93,7 @@ public class GenreEnrichmentService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to enrich genre for {Title} - {Artist}", + _logger.LogError(ex, "Failed to enrich genre for {Title} - {Artist}", song.Title, song.Artist); } } @@ -170,7 +170,7 @@ public class GenreEnrichmentService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to read genre from file cache for {Key}", cacheKey); + _logger.LogError(ex, "Failed to read genre from file cache for {Key}", cacheKey); return null; } } @@ -201,7 +201,7 @@ public class GenreEnrichmentService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to save genre to file cache for {Key}", cacheKey); + _logger.LogError(ex, "Failed to save genre to file cache for {Key}", cacheKey); } } diff --git a/allstarr/Services/Common/OdesliService.cs b/allstarr/Services/Common/OdesliService.cs index 7fa7132..c1477c9 100644 --- a/allstarr/Services/Common/OdesliService.cs +++ b/allstarr/Services/Common/OdesliService.cs @@ -63,10 +63,10 @@ public class OdesliService if (match.Success) { var spotifyId = match.Groups[1].Value; - _logger.LogInformation("✓ Converted Tidal/{TidalId} → Spotify ID {SpotifyId}", tidalTrackId, spotifyId); + _logger.LogDebug("✓ Converted Tidal/{TidalId} → Spotify ID {SpotifyId}", tidalTrackId, spotifyId); - // Cache for 7 days - await _cache.SetAsync(cacheKey, spotifyId, TimeSpan.FromDays(7)); + // Cache for configurable duration + await _cache.SetAsync(cacheKey, spotifyId, CacheExtensions.OdesliLookupTTL); return spotifyId; } @@ -76,7 +76,7 @@ public class OdesliService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to convert Tidal track to Spotify ID via Odesli"); + _logger.LogError(ex, "Failed to convert Tidal track to Spotify ID via Odesli"); } return null; @@ -122,10 +122,10 @@ public class OdesliService if (match.Success) { var spotifyId = match.Groups[1].Value; - _logger.LogInformation("✓ Converted URL → Spotify ID {SpotifyId}", spotifyId); + _logger.LogDebug("✓ Converted URL → Spotify ID {SpotifyId}", spotifyId); - // Cache for 7 days - await _cache.SetAsync(cacheKey, spotifyId, TimeSpan.FromDays(7)); + // Cache for configurable duration + await _cache.SetAsync(cacheKey, spotifyId, CacheExtensions.OdesliLookupTTL); return spotifyId; } @@ -135,7 +135,7 @@ public class OdesliService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to convert URL to Spotify ID via Odesli"); + _logger.LogError(ex, "Failed to convert URL to Spotify ID via Odesli"); } return null; diff --git a/allstarr/Services/Common/ParallelMetadataService.cs b/allstarr/Services/Common/ParallelMetadataService.cs index 791c88d..aad3985 100644 --- a/allstarr/Services/Common/ParallelMetadataService.cs +++ b/allstarr/Services/Common/ParallelMetadataService.cs @@ -51,7 +51,7 @@ public class ParallelMetadataService } catch (Exception ex) { - _logger.LogWarning(ex, "❌ {Provider} search failed", providerName); + _logger.LogError(ex, "❌ {Provider} search failed", providerName); return (Success: false, Result: new SearchResult(), Provider: providerName, ElapsedMs: 0L); } }).ToList(); @@ -64,7 +64,7 @@ public class ParallelMetadataService if (result.Success && (result.Result.Songs.Any() || result.Result.Albums.Any() || result.Result.Artists.Any())) { - _logger.LogInformation("🏆 Using results from {Provider} ({Ms}ms) - fastest with results", + _logger.LogDebug("🏆 Using results from {Provider} ({Ms}ms) - fastest with results", result.Provider, result.ElapsedMs); return result.Result; } @@ -110,7 +110,7 @@ public class ParallelMetadataService } catch (Exception ex) { - _logger.LogWarning(ex, "❌ {Provider} song search failed", providerName); + _logger.LogError(ex, "❌ {Provider} song search failed", providerName); return (Success: false, Song: (Song?)null, Provider: providerName, ElapsedMs: 0L); } }).ToList(); diff --git a/allstarr/Services/Common/PathHelper.cs b/allstarr/Services/Common/PathHelper.cs index 35c48f0..4e15f8d 100644 --- a/allstarr/Services/Common/PathHelper.cs +++ b/allstarr/Services/Common/PathHelper.cs @@ -28,8 +28,10 @@ public static class PathHelper /// Track title (will be sanitized). /// Optional track number for prefix. /// File extension (e.g., ".flac", ".mp3"). + /// Optional provider name (e.g., "squidwtf", "deezer"). + /// Optional external ID from the provider. /// Full path for the track file. - public static string BuildTrackPath(string downloadPath, string artist, string album, string title, int? trackNumber, string extension) + public static string BuildTrackPath(string downloadPath, string artist, string album, string title, int? trackNumber, string extension, string? provider = null, string? externalId = null) { var safeArtist = SanitizeFolderName(artist); var safeAlbum = SanitizeFolderName(album); @@ -39,7 +41,10 @@ public static class PathHelper var albumFolder = Path.Combine(artistFolder, safeAlbum); var trackPrefix = trackNumber.HasValue ? $"{trackNumber:D2} - " : ""; - var fileName = $"{trackPrefix}{safeTitle}{extension}"; + var idSuffix = !string.IsNullOrEmpty(provider) && !string.IsNullOrEmpty(externalId) + ? $" [{provider}-{externalId}]" + : ""; + var fileName = $"{trackPrefix}{safeTitle}{idSuffix}{extension}"; return Path.Combine(albumFolder, fileName); } diff --git a/allstarr/Services/Common/RedisCacheService.cs b/allstarr/Services/Common/RedisCacheService.cs index 063f8c5..2180298 100644 --- a/allstarr/Services/Common/RedisCacheService.cs +++ b/allstarr/Services/Common/RedisCacheService.cs @@ -39,7 +39,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Redis connection failed. Caching disabled."); + _logger.LogError(ex, "Redis connection failed. Caching disabled."); _redis = null; _db = null; } @@ -70,7 +70,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Redis GET failed for key: {Key}", key); + _logger.LogError(ex, "Redis GET failed for key: {Key}", key); return null; } } @@ -89,7 +89,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to deserialize cached value for key: {Key}", key); + _logger.LogError(ex, "Failed to deserialize cached value for key: {Key}", key); return null; } } @@ -112,7 +112,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Redis SET failed for key: {Key}", key); + _logger.LogError(ex, "Redis SET failed for key: {Key}", key); return false; } } @@ -129,7 +129,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to serialize value for key: {Key}", key); + _logger.LogError(ex, "Failed to serialize value for key: {Key}", key); return false; } } @@ -147,7 +147,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Redis DELETE failed for key: {Key}", key); + _logger.LogError(ex, "Redis DELETE failed for key: {Key}", key); return false; } } @@ -165,7 +165,7 @@ public class RedisCacheService } catch (Exception ex) { - _logger.LogWarning(ex, "Redis EXISTS failed for key: {Key}", key); + _logger.LogError(ex, "Redis EXISTS failed for key: {Key}", key); return false; } } @@ -190,12 +190,12 @@ public class RedisCacheService } var deleted = await _db!.KeyDeleteAsync(keys); - _logger.LogInformation("Deleted {Count} Redis keys matching pattern: {Pattern}", deleted, pattern); + _logger.LogDebug("Deleted {Count} Redis keys matching pattern: {Pattern}", deleted, pattern); return (int)deleted; } catch (Exception ex) { - _logger.LogWarning(ex, "Redis DELETE BY PATTERN failed for pattern: {Pattern}", pattern); + _logger.LogError(ex, "Redis DELETE BY PATTERN failed for pattern: {Pattern}", pattern); return 0; } } diff --git a/allstarr/Services/Common/RedisPersistenceService.cs b/allstarr/Services/Common/RedisPersistenceService.cs new file mode 100644 index 0000000..aa0fe95 --- /dev/null +++ b/allstarr/Services/Common/RedisPersistenceService.cs @@ -0,0 +1,101 @@ +using System.Text.Json; +using Microsoft.Extensions.Options; +using allstarr.Models.Settings; + +namespace allstarr.Services.Common; + +/// +/// Periodically snapshots Redis cache to file system for cold start recovery. +/// Redis is the primary cache, files are the persistence layer. +/// +public class RedisPersistenceService : BackgroundService +{ + private readonly RedisCacheService _cache; + private readonly ILogger _logger; + private readonly TimeSpan _snapshotInterval = TimeSpan.FromMinutes(5); + private const string SnapshotDirectory = "/app/cache/redis-snapshots"; + + public RedisPersistenceService( + RedisCacheService cache, + ILogger logger) + { + _cache = cache; + _logger = logger; + } + + protected override async Task ExecuteAsync(CancellationToken stoppingToken) + { + // Wait 2 minutes after startup before first snapshot (let cache warm up) + await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken); + + while (!stoppingToken.IsCancellationRequested) + { + try + { + await CreateSnapshotAsync(stoppingToken); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error creating Redis snapshot"); + } + + await Task.Delay(_snapshotInterval, stoppingToken); + } + } + + private async Task CreateSnapshotAsync(CancellationToken cancellationToken) + { + if (!_cache.IsEnabled) + { + _logger.LogWarning("Redis is disabled, skipping snapshot"); + return; + } + + try + { + Directory.CreateDirectory(SnapshotDirectory); + + var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd_HH-mm-ss"); + var snapshotFile = Path.Combine(SnapshotDirectory, $"snapshot_{timestamp}.json"); + + // For now, we'll rely on Redis's built-in RDB + AOF persistence + // This service is a placeholder for future enhancements like: + // - Exporting specific key patterns to JSON + // - Creating human-readable backups + // - Syncing to external storage + + _logger.LogDebug("Redis snapshot service running (using Redis native persistence)"); + + // Clean up old snapshots (keep last 10) + await CleanupOldSnapshotsAsync(); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to create Redis snapshot"); + } + } + + private async Task CleanupOldSnapshotsAsync() + { + try + { + if (!Directory.Exists(SnapshotDirectory)) + return; + + var files = Directory.GetFiles(SnapshotDirectory, "snapshot_*.json") + .OrderByDescending(f => f) + .Skip(10) + .ToArray(); + + foreach (var file in files) + { + File.Delete(file); + _logger.LogDebug("Deleted old snapshot: {File}", Path.GetFileName(file)); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to cleanup old snapshots"); + } + } +} diff --git a/allstarr/Services/Common/RoundRobinFallbackHelper.cs b/allstarr/Services/Common/RoundRobinFallbackHelper.cs index e8fd9eb..faed7d1 100644 --- a/allstarr/Services/Common/RoundRobinFallbackHelper.cs +++ b/allstarr/Services/Common/RoundRobinFallbackHelper.cs @@ -78,7 +78,7 @@ public class RoundRobinFallbackHelper } catch (Exception ex) { - _logger.LogDebug(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl); + _logger.LogError(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl); // Cache as unhealthy lock (_healthCacheLock) @@ -137,7 +137,7 @@ public class RoundRobinFallbackHelper _apiUrls.AddRange(reordered); _currentUrlIndex = 0; - _logger.LogInformation("📊 {Service} endpoints reordered by benchmark: {Endpoints}", + _logger.LogDebug("📊 {Service} endpoints reordered by benchmark: {Endpoints}", _serviceName, string.Join(", ", _apiUrls.Take(3))); } } @@ -180,7 +180,7 @@ public class RoundRobinFallbackHelper } catch (Exception ex) { - _logger.LogWarning(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", + _logger.LogError(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", _serviceName, baseUrl); // Mark as unhealthy in cache @@ -227,7 +227,7 @@ public class RoundRobinFallbackHelper } catch (Exception ex) { - _logger.LogDebug(ex, "{Service} race failed for endpoint {Endpoint}", _serviceName, baseUrl); + _logger.LogError(ex, "{Service} race failed for endpoint {Endpoint}", _serviceName, baseUrl); return (default(T)!, baseUrl, false); } }, raceCts.Token); @@ -243,7 +243,7 @@ public class RoundRobinFallbackHelper if (success) { - _logger.LogInformation("🏁 {Service} race won by {Endpoint}, canceling others", _serviceName, endpoint); + _logger.LogDebug("🏁 {Service} race won by {Endpoint}, canceling others", _serviceName, endpoint); raceCts.Cancel(); // Cancel all other requests return result; } @@ -291,7 +291,7 @@ public class RoundRobinFallbackHelper } catch (Exception ex) { - _logger.LogWarning(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", + _logger.LogError(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", _serviceName, baseUrl); // Mark as unhealthy in cache diff --git a/allstarr/Services/Deezer/DeezerDownloadService.cs b/allstarr/Services/Deezer/DeezerDownloadService.cs index db9f6d2..b90adbf 100644 --- a/allstarr/Services/Deezer/DeezerDownloadService.cs +++ b/allstarr/Services/Deezer/DeezerDownloadService.cs @@ -111,7 +111,7 @@ public class DeezerDownloadService : BaseDownloadService var basePath = SubsonicSettings.StorageMode == StorageMode.Cache ? Path.Combine("downloads", "cache") : Path.Combine("downloads", "permanent"); - var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension); + var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension, "deezer", trackId); // Create directories if they don't exist var albumFolder = Path.GetDirectoryName(outputPath)!; diff --git a/allstarr/Services/Deezer/DeezerMetadataService.cs b/allstarr/Services/Deezer/DeezerMetadataService.cs index ae5aa3e..366eb8a 100644 --- a/allstarr/Services/Deezer/DeezerMetadataService.cs +++ b/allstarr/Services/Deezer/DeezerMetadataService.cs @@ -3,6 +3,7 @@ using allstarr.Models.Settings; using allstarr.Models.Download; using allstarr.Models.Search; using allstarr.Models.Subsonic; +using allstarr.Services.Common; using System.Text.Json; using Microsoft.Extensions.Options; @@ -15,12 +16,17 @@ public class DeezerMetadataService : IMusicMetadataService { private readonly HttpClient _httpClient; private readonly SubsonicSettings _settings; + private readonly GenreEnrichmentService? _genreEnrichment; private const string BaseUrl = "https://api.deezer.com"; - public DeezerMetadataService(IHttpClientFactory httpClientFactory, IOptions settings) + public DeezerMetadataService( + IHttpClientFactory httpClientFactory, + IOptions settings, + GenreEnrichmentService? genreEnrichment = null) { _httpClient = httpClientFactory.CreateClient(); _settings = settings.Value; + _genreEnrichment = genreEnrichment; } public async Task> SearchSongsAsync(string query, int limit = 20) @@ -203,6 +209,23 @@ public class DeezerMetadataService : IMusicMetadataService } } + // Enrich with MusicBrainz genres if missing + if (_genreEnrichment != null && string.IsNullOrEmpty(song.Genre)) + { + // Fire-and-forget: don't block the response waiting for genre enrichment + _ = Task.Run(async () => + { + try + { + await _genreEnrichment.EnrichSongGenreAsync(song); + } + catch + { + // Silently ignore genre enrichment failures + } + }); + } + return song; } @@ -384,17 +407,23 @@ public class DeezerMetadataService : IMusicMetadataService } } - // Contributors + // Contributors (all artists including features) var contributors = new List(); + var contributorIds = new List(); if (track.TryGetProperty("contributors", out var contribs)) { foreach (var contrib in contribs.EnumerateArray()) { - if (contrib.TryGetProperty("name", out var contribName)) + if (contrib.TryGetProperty("name", out var contribName) && + contrib.TryGetProperty("id", out var contribId)) { var name = contribName.GetString(); + var id = contribId.GetInt64(); if (!string.IsNullOrEmpty(name)) + { contributors.Add(name); + contributorIds.Add($"ext-deezer-artist-{id}"); + } } } } @@ -437,6 +466,8 @@ public class DeezerMetadataService : IMusicMetadataService ArtistId = track.TryGetProperty("artist", out var artistForId) ? $"ext-deezer-artist-{artistForId.GetProperty("id").GetInt64()}" : null, + Artists = contributors.Count > 0 ? contributors : new List(), + ArtistIds = contributorIds.Count > 0 ? contributorIds : new List(), Album = track.TryGetProperty("album", out var album) ? album.GetProperty("title").GetString() ?? "" : "", diff --git a/allstarr/Services/Jellyfin/JellyfinModelMapper.cs b/allstarr/Services/Jellyfin/JellyfinModelMapper.cs index 3f15836..f354de6 100644 --- a/allstarr/Services/Jellyfin/JellyfinModelMapper.cs +++ b/allstarr/Services/Jellyfin/JellyfinModelMapper.cs @@ -76,7 +76,7 @@ public class JellyfinModelMapper } catch (Exception ex) { - _logger.LogWarning(ex, "Error parsing Jellyfin items response"); + _logger.LogError(ex, "Error parsing Jellyfin items response"); } return (songs, albums, artists); @@ -126,7 +126,7 @@ public class JellyfinModelMapper } catch (Exception ex) { - _logger.LogWarning(ex, "Error parsing Jellyfin search hints response"); + _logger.LogError(ex, "Error parsing Jellyfin search hints response"); } return (songs, albums, artists); diff --git a/allstarr/Services/Jellyfin/JellyfinProxyService.cs b/allstarr/Services/Jellyfin/JellyfinProxyService.cs index 17d05df..459189e 100644 --- a/allstarr/Services/Jellyfin/JellyfinProxyService.cs +++ b/allstarr/Services/Jellyfin/JellyfinProxyService.cs @@ -222,7 +222,7 @@ public class JellyfinProxyService // Forward as X-Emby-Authorization (Jellyfin's expected header) request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue); authHeaderAdded = true; - _logger.LogTrace("Converted Authorization to X-Emby-Authorization"); + _logger.LogDebug("Converted Authorization to X-Emby-Authorization"); } else { @@ -265,11 +265,11 @@ public class JellyfinProxyService if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized) { // 401 means token expired or invalid - client needs to re-authenticate - _logger.LogInformation("Jellyfin returned 401 Unauthorized for {Url} - client should re-authenticate", url); + _logger.LogDebug("Jellyfin returned 401 Unauthorized for {Url} - client should re-authenticate", url); } else if (!isBrowserStaticRequest && !isPublicEndpoint) { - _logger.LogWarning("Jellyfin request failed: {StatusCode} for {Url}", response.StatusCode, url); + _logger.LogError("Jellyfin request failed: {StatusCode} for {Url}", response.StatusCode, url); } // Try to parse error response to pass through to client @@ -374,7 +374,7 @@ public class JellyfinProxyService { // Forward as X-Emby-Authorization request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue); - _logger.LogTrace("Converted Authorization to X-Emby-Authorization"); + _logger.LogDebug("Converted Authorization to X-Emby-Authorization"); } else { @@ -418,11 +418,11 @@ public class JellyfinProxyService // 401 is expected when tokens expire - don't spam logs if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized) { - _logger.LogInformation("Jellyfin POST returned 401 for {Url} - client should re-authenticate", url); + _logger.LogDebug("Jellyfin POST returned 401 for {Url} - client should re-authenticate", url); } else { - _logger.LogWarning("Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", + _logger.LogError("Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", response.StatusCode, url, errorContent.Length > 200 ? errorContent[..200] + "..." : errorContent); } @@ -579,12 +579,12 @@ public class JellyfinProxyService if (!authHeaderAdded) { - _logger.LogInformation("No client auth provided for DELETE {Url} - forwarding without auth", url); + _logger.LogDebug("No client auth provided for DELETE {Url} - forwarding without auth", url); } request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); - _logger.LogInformation("DELETE to Jellyfin: {Url}", url); + _logger.LogDebug("DELETE to Jellyfin: {Url}", url); var response = await _httpClient.SendAsync(request); @@ -593,7 +593,7 @@ public class JellyfinProxyService if (!response.IsSuccessStatusCode) { var errorContent = await response.Content.ReadAsStringAsync(); - _logger.LogWarning("Jellyfin DELETE request failed: {StatusCode} for {Url}. Response: {Response}", + _logger.LogError("Jellyfin DELETE request failed: {StatusCode} for {Url}. Response: {Response}", response.StatusCode, url, errorContent); return (null, statusCode); } @@ -629,7 +629,7 @@ public class JellyfinProxyService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to get bytes from {Endpoint}", endpoint); + _logger.LogError(ex, "Failed to get bytes from {Endpoint}", endpoint); return (null, null, false); } } @@ -662,7 +662,7 @@ public class JellyfinProxyService if (!string.IsNullOrEmpty(_settings.LibraryId)) { queryParams["parentId"] = _settings.LibraryId; - _logger.LogDebug("Searching within configured LibraryId {LibraryId}", _settings.LibraryId); + _logger.LogInformation("Searching within configured LibraryId {LibraryId}", _settings.LibraryId); } if (includeItemTypes != null && includeItemTypes.Length > 0) @@ -932,7 +932,7 @@ public class JellyfinProxyService if (result.Success && result.Body != null) { var cacheValue = $"{Convert.ToBase64String(result.Body)}|{result.ContentType}"; - await _cache.SetStringAsync(cacheKey, cacheValue, TimeSpan.FromDays(7)); + await _cache.SetStringAsync(cacheKey, cacheValue, CacheExtensions.ProxyImagesTTL); } return (result.Body, result.ContentType); diff --git a/allstarr/Services/Jellyfin/JellyfinResponseBuilder.cs b/allstarr/Services/Jellyfin/JellyfinResponseBuilder.cs index ce47e91..fc793d9 100644 --- a/allstarr/Services/Jellyfin/JellyfinResponseBuilder.cs +++ b/allstarr/Services/Jellyfin/JellyfinResponseBuilder.cs @@ -263,9 +263,11 @@ public class JellyfinResponseBuilder ["Name"] = songTitle, ["ServerId"] = "allstarr", ["Id"] = song.Id, + ["PlaylistItemId"] = song.Id, // Required for playlist items ["HasLyrics"] = false, // Could be enhanced to check if lyrics exist ["Container"] = "flac", ["PremiereDate"] = song.Year.HasValue ? $"{song.Year}-01-01T00:00:00.0000000Z" : null, + ["DateCreated"] = song.Year.HasValue ? $"{song.Year}-01-01T00:00:00.0000000Z" : DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ"), ["RunTimeTicks"] = (song.Duration ?? 0) * TimeSpan.TicksPerSecond, ["ProductionYear"] = song.Year, ["IndexNumber"] = song.Track, @@ -273,6 +275,7 @@ public class JellyfinResponseBuilder ["IsFolder"] = false, ["Type"] = "Audio", ["ChannelId"] = (object?)null, + ["ParentId"] = song.AlbumId, ["Genres"] = !string.IsNullOrEmpty(song.Genre) ? new[] { song.Genre } : new string[0], @@ -286,6 +289,9 @@ public class JellyfinResponseBuilder } } : new Dictionary[0], + ["Tags"] = new string[0], + ["People"] = new object[0], + ["SortName"] = songTitle, ["ParentLogoItemId"] = song.AlbumId, ["ParentBackdropItemId"] = song.AlbumId, ["ParentBackdropImageTags"] = new string[0], @@ -299,13 +305,11 @@ public class JellyfinResponseBuilder ["ItemId"] = song.Id }, ["Artists"] = artistNames.Count > 0 ? artistNames.ToArray() : new[] { artistName ?? "" }, - ["ArtistItems"] = artistNames.Count > 0 + ["ArtistItems"] = artistNames.Count > 0 && song.ArtistIds.Count == artistNames.Count ? artistNames.Select((name, index) => new Dictionary { ["Name"] = name, - ["Id"] = index == 0 && song.ArtistId != null - ? song.ArtistId - : $"{song.Id}-artist-{index}" + ["Id"] = song.ArtistIds[index] }).ToArray() : new[] { diff --git a/allstarr/Services/Jellyfin/JellyfinSessionManager.cs b/allstarr/Services/Jellyfin/JellyfinSessionManager.cs index 97e4882..93a559f 100644 --- a/allstarr/Services/Jellyfin/JellyfinSessionManager.cs +++ b/allstarr/Services/Jellyfin/JellyfinSessionManager.cs @@ -33,7 +33,7 @@ public class JellyfinSessionManager : IDisposable // Keep sessions alive every 10 seconds (Jellyfin considers sessions stale after ~15 seconds of inactivity) _keepAliveTimer = new Timer(KeepSessionsAlive, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10)); - _logger.LogDebug("🔧 SESSION: JellyfinSessionManager initialized with 10-second keep-alive and WebSocket support"); + _logger.LogInformation("🔧 SESSION: JellyfinSessionManager initialized with 10-second keep-alive and WebSocket support"); } /// @@ -44,7 +44,7 @@ public class JellyfinSessionManager : IDisposable { if (string.IsNullOrEmpty(deviceId)) { - _logger.LogWarning("Cannot create session - no device ID"); + _logger.LogError("Cannot create session - no device ID"); return false; } @@ -52,7 +52,7 @@ public class JellyfinSessionManager : IDisposable if (_sessions.TryGetValue(deviceId, out var existingSession)) { existingSession.LastActivity = DateTime.UtcNow; - _logger.LogTrace("Session already exists for device {DeviceId}", deviceId); + _logger.LogInformation("Session already exists for device {DeviceId}", deviceId); // Refresh capabilities to keep session alive // If this returns false (401), the token expired and client needs to re-auth @@ -60,7 +60,7 @@ public class JellyfinSessionManager : IDisposable if (!success) { // Token expired - remove the stale session - _logger.LogInformation("Token expired for device {DeviceId} - removing session", deviceId); + _logger.LogWarning("Token expired for device {DeviceId} - removing session", deviceId); await RemoveSessionAsync(deviceId); return false; } @@ -78,13 +78,17 @@ public class JellyfinSessionManager : IDisposable if (!success) { // Token expired or invalid - client needs to re-authenticate - _logger.LogInformation("Failed to create session for {DeviceId} - token may be expired", deviceId); + _logger.LogError("Failed to create session for {DeviceId} - token may be expired", deviceId); return false; } - _logger.LogDebug("Session created for {DeviceId}", deviceId); + _logger.LogInformation("Session created for {DeviceId}", deviceId); // Track this session + var clientIp = headers["X-Forwarded-For"].FirstOrDefault()?.Split(',')[0].Trim() + ?? headers["X-Real-IP"].FirstOrDefault() + ?? "Unknown"; + _sessions[deviceId] = new SessionInfo { DeviceId = deviceId, @@ -92,7 +96,8 @@ public class JellyfinSessionManager : IDisposable Device = device, Version = version, LastActivity = DateTime.UtcNow, - Headers = CloneHeaders(headers) + Headers = CloneHeaders(headers), + ClientIp = clientIp }; // Start a WebSocket connection to Jellyfin on behalf of this client @@ -138,7 +143,7 @@ public class JellyfinSessionManager : IDisposable else if (statusCode == 401) { // Token expired - this is expected, client needs to re-authenticate - _logger.LogDebug("Capabilities returned 401 (token expired) - client should re-authenticate"); + _logger.LogWarning("Capabilities returned 401 (token expired) - client should re-authenticate"); return false; } else @@ -160,7 +165,7 @@ public class JellyfinSessionManager : IDisposable } else { - _logger.LogDebug("⚠️ SESSION: Cannot update activity - device {DeviceId} not found", deviceId); + _logger.LogError("⚠️ SESSION: Cannot update activity - device {DeviceId} not found", deviceId); } } @@ -222,6 +227,7 @@ public class JellyfinSessionManager : IDisposable Client = s.Client, Device = s.Device, Version = s.Version, + ClientIp = s.ClientIp, LastActivity = s.LastActivity, InactiveMinutes = Math.Round((now - s.LastActivity).TotalMinutes, 1), HasWebSocket = s.WebSocket != null, @@ -256,7 +262,7 @@ public class JellyfinSessionManager : IDisposable } catch (Exception ex) { - _logger.LogDebug(ex, "WEBSOCKET: Error closing WebSocket for {DeviceId}", deviceId); + _logger.LogError(ex, "WEBSOCKET: Error closing WebSocket for {DeviceId}", deviceId); } finally { @@ -276,7 +282,7 @@ public class JellyfinSessionManager : IDisposable }; var stopJson = JsonSerializer.Serialize(stopPayload); await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", stopJson, session.Headers); - _logger.LogDebug("🛑 SESSION: Reported playback stopped for {DeviceId} (ItemId: {ItemId}, Position: {Position})", + _logger.LogInformation("🛑 SESSION: Reported playback stopped for {DeviceId} (ItemId: {ItemId}, Position: {Position})", deviceId, session.LastPlayingItemId, session.LastPlayingPositionTicks); } @@ -285,7 +291,7 @@ public class JellyfinSessionManager : IDisposable } catch (Exception ex) { - _logger.LogWarning("⚠️ SESSION: Error removing session for {DeviceId}: {Message}", deviceId, ex.Message); + _logger.LogError("⚠️ SESSION: Error removing session for {DeviceId}: {Message}", deviceId, ex.Message); } } } @@ -298,7 +304,7 @@ public class JellyfinSessionManager : IDisposable { if (!_sessions.TryGetValue(deviceId, out var session)) { - _logger.LogDebug("⚠️ WEBSOCKET: Cannot create WebSocket - session {DeviceId} not found", deviceId); + _logger.LogError("⚠️ WEBSOCKET: Cannot create WebSocket - session {DeviceId} not found", deviceId); return; } @@ -360,7 +366,7 @@ public class JellyfinSessionManager : IDisposable if (!string.IsNullOrEmpty(_settings.ApiKey)) { jellyfinWsUrl += $"?api_key={_settings.ApiKey}"; - _logger.LogDebug("WEBSOCKET: No client auth found in headers, falling back to server API key for {DeviceId}", deviceId); + _logger.LogWarning("WEBSOCKET: No client auth found in headers, falling back to server API key for {DeviceId}", deviceId); } else { @@ -375,7 +381,7 @@ public class JellyfinSessionManager : IDisposable // Connect to Jellyfin await webSocket.ConnectAsync(new Uri(jellyfinWsUrl), CancellationToken.None); - _logger.LogDebug("✓ WEBSOCKET: Connected to Jellyfin for device {DeviceId}", deviceId); + _logger.LogInformation("✓ WEBSOCKET: Connected to Jellyfin for device {DeviceId}", deviceId); // CRITICAL: Send ForceKeepAlive message to initialize session in Jellyfin // This tells Jellyfin to create/show the session in the dashboard @@ -383,7 +389,7 @@ public class JellyfinSessionManager : IDisposable var forceKeepAliveMessage = "{\"MessageType\":\"ForceKeepAlive\",\"Data\":100}"; var messageBytes = Encoding.UTF8.GetBytes(forceKeepAliveMessage); await webSocket.SendAsync(new ArraySegment(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None); - _logger.LogDebug("📤 WEBSOCKET: Sent ForceKeepAlive to initialize session for {DeviceId}", deviceId); + _logger.LogInformation("📤 WEBSOCKET: Sent ForceKeepAlive to initialize session for {DeviceId}", deviceId); // Also send SessionsStart to subscribe to session updates var sessionsStartMessage = "{\"MessageType\":\"SessionsStart\",\"Data\":\"0,1500\"}"; @@ -516,20 +522,20 @@ public class JellyfinSessionManager : IDisposable if (!success) { - _logger.LogInformation("Token expired for device {DeviceId} during keep-alive - marking for removal", session.DeviceId); + _logger.LogWarning("Token expired for device {DeviceId} during keep-alive - marking for removal", session.DeviceId); expiredSessions.Add(session.DeviceId); } } catch (Exception ex) { - _logger.LogDebug(ex, "Error keeping session alive for {DeviceId}", session.DeviceId); + _logger.LogError(ex, "Error keeping session alive for {DeviceId}", session.DeviceId); } } // Remove sessions with expired tokens foreach (var deviceId in expiredSessions) { - _logger.LogInformation("Removing session with expired token: {DeviceId}", deviceId); + _logger.LogWarning("Removing session with expired token: {DeviceId}", deviceId); await RemoveSessionAsync(deviceId); } @@ -565,6 +571,7 @@ public class JellyfinSessionManager : IDisposable public ClientWebSocket? WebSocket { get; set; } public string? LastPlayingItemId { get; set; } public long? LastPlayingPositionTicks { get; set; } + public string? ClientIp { get; set; } } public void Dispose() diff --git a/allstarr/Services/Local/LocalLibraryService.cs b/allstarr/Services/Local/LocalLibraryService.cs index 527a368..83753a3 100644 --- a/allstarr/Services/Local/LocalLibraryService.cs +++ b/allstarr/Services/Local/LocalLibraryService.cs @@ -14,262 +14,262 @@ namespace allstarr.Services.Local; /// Uses a simple JSON file to store mappings (can be replaced with a database) /// public class LocalLibraryService : ILocalLibraryService -{ - private readonly string _mappingFilePath; - private readonly string _downloadDirectory; - private readonly HttpClient _httpClient; - private readonly SubsonicSettings _subsonicSettings; - private readonly ILogger _logger; - private Dictionary? _mappings; - private readonly SemaphoreSlim _lock = new(1, 1); - - // Debounce to avoid triggering too many scans - private DateTime _lastScanTrigger = DateTime.MinValue; - private readonly TimeSpan _scanDebounceInterval = TimeSpan.FromSeconds(30); - - public LocalLibraryService( - IConfiguration configuration, - IHttpClientFactory httpClientFactory, - IOptions subsonicSettings, - ILogger logger) - { - _downloadDirectory = configuration["Library:DownloadPath"] ?? Path.Combine(Directory.GetCurrentDirectory(), "downloads"); - _mappingFilePath = Path.Combine(_downloadDirectory, ".mappings.json"); - _httpClient = httpClientFactory.CreateClient(); - _subsonicSettings = subsonicSettings.Value; - _logger = logger; - - if (!Directory.Exists(_downloadDirectory)) - { - Directory.CreateDirectory(_downloadDirectory); - } - } - - public async Task GetLocalPathForExternalSongAsync(string externalProvider, string externalId) - { - var mappings = await LoadMappingsAsync(); - var key = $"{externalProvider}:{externalId}"; - - if (mappings.TryGetValue(key, out var mapping) && File.Exists(mapping.LocalPath)) - { - return mapping.LocalPath; - } - - return null; - } - - public async Task RegisterDownloadedSongAsync(Song song, string localPath) - { - if (song.ExternalProvider == null || song.ExternalId == null) return; - - // Load mappings first (this acquires the lock internally if needed) - var mappings = await LoadMappingsAsync(); - - await _lock.WaitAsync(); - try - { - var key = $"{song.ExternalProvider}:{song.ExternalId}"; - - mappings[key] = new LocalSongMapping - { - ExternalProvider = song.ExternalProvider, - ExternalId = song.ExternalId, - LocalPath = localPath, - Title = song.Title, - Artist = song.Artist, - Album = song.Album, - DownloadedAt = DateTime.UtcNow - }; - - await SaveMappingsAsync(mappings); - } - finally - { - _lock.Release(); - } - } - - public async Task GetLocalIdForExternalSongAsync(string externalProvider, string externalId) - { - // For now, return null as we don't yet have integration - // with the Subsonic server to retrieve local ID after scan - await Task.CompletedTask; - return null; - } - - public (bool isExternal, string? provider, string? externalId) ParseSongId(string songId) - { - var (isExternal, provider, _, externalId) = ParseExternalId(songId); - return (isExternal, provider, externalId); - } - - public (bool isExternal, string? provider, string? type, string? externalId) ParseExternalId(string id) - { - if (!id.StartsWith("ext-")) - { - return (false, null, null, null); - } - - var parts = id.Split('-'); - - // Known types for the new format - var knownTypes = new HashSet { "song", "album", "artist" }; - - // New format: ext-{provider}-{type}-{id} (e.g., ext-deezer-artist-259) - // Only use new format if parts[2] is a known type - if (parts.Length >= 4 && knownTypes.Contains(parts[2])) - { - var provider = parts[1]; - var type = parts[2]; - var externalId = string.Join("-", parts.Skip(3)); // Handle IDs with dashes - return (true, provider, type, externalId); - } - - // Legacy format: ext-{provider}-{id} (assumes "song" type for backward compatibility) - // This handles both 3-part IDs and 4+ part IDs where parts[2] is NOT a known type - if (parts.Length >= 3) - { - var provider = parts[1]; - var externalId = string.Join("-", parts.Skip(2)); // Everything after provider is the ID - return (true, provider, "song", externalId); - } - - return (false, null, null, null); - } - - private async Task> LoadMappingsAsync() - { - // Fast path: return cached mappings if available - if (_mappings != null) return _mappings; - - // Slow path: acquire lock to load from file (prevents race condition) - await _lock.WaitAsync(); - try - { - // Double-check after acquiring lock - if (_mappings != null) return _mappings; - - if (File.Exists(_mappingFilePath)) - { - var json = await File.ReadAllTextAsync(_mappingFilePath); - _mappings = System.Text.Json.JsonSerializer.Deserialize>(json) - ?? new Dictionary(); - } - else - { - _mappings = new Dictionary(); - } - - return _mappings; - } - finally - { - _lock.Release(); - } - } - - private async Task SaveMappingsAsync(Dictionary mappings) - { - _mappings = mappings; - var json = System.Text.Json.JsonSerializer.Serialize(mappings, new System.Text.Json.JsonSerializerOptions - { - WriteIndented = true - }); - await File.WriteAllTextAsync(_mappingFilePath, json); - } - - public string GetDownloadDirectory() => _downloadDirectory; - - public async Task TriggerLibraryScanAsync() - { - // Debounce: avoid triggering too many successive scans - var now = DateTime.UtcNow; - if (now - _lastScanTrigger < _scanDebounceInterval) - { - _logger.LogDebug("Scan debounced - last scan was {Elapsed}s ago", - (now - _lastScanTrigger).TotalSeconds); - return true; - } - - _lastScanTrigger = now; - - try - { - // Call Subsonic API to trigger a scan - // Note: This endpoint works without authentication on most Subsonic/Navidrome servers - // when called from localhost. For remote servers requiring auth, this would need - // to be refactored to accept credentials from the controller layer. - var url = $"{_subsonicSettings.Url}/rest/startScan?f=json"; - - _logger.LogInformation("Triggering Subsonic library scan..."); - - var response = await _httpClient.GetAsync(url); - - if (response.IsSuccessStatusCode) - { - var content = await response.Content.ReadAsStringAsync(); - _logger.LogInformation("Subsonic scan triggered successfully: {Response}", content); - return true; - } - else - { - _logger.LogWarning("Failed to trigger Subsonic scan: {StatusCode} - Server may require authentication", response.StatusCode); - return false; - } - } - catch (Exception ex) - { - _logger.LogError(ex, "Error triggering Subsonic library scan"); - return false; - } - } - - public async Task GetScanStatusAsync() - { - try - { - // Note: This endpoint works without authentication on most Subsonic/Navidrome servers - // when called from localhost. - var url = $"{_subsonicSettings.Url}/rest/getScanStatus?f=json"; - - var response = await _httpClient.GetAsync(url); - - if (response.IsSuccessStatusCode) - { - var content = await response.Content.ReadAsStringAsync(); - var doc = JsonDocument.Parse(content); - - if (doc.RootElement.TryGetProperty("subsonic-response", out var subsonicResponse) && - subsonicResponse.TryGetProperty("scanStatus", out var scanStatus)) - { - return new ScanStatus - { - Scanning = scanStatus.TryGetProperty("scanning", out var scanning) && scanning.GetBoolean(), - Count = scanStatus.TryGetProperty("count", out var count) ? count.GetInt32() : null - }; - } - } - } - catch (Exception ex) - { - _logger.LogError(ex, "Error getting Subsonic scan status"); - } - - return null; - } -} - -/// -/// Represents the mapping between an external song and its local file -/// -public class LocalSongMapping -{ - public string ExternalProvider { get; set; } = string.Empty; - public string ExternalId { get; set; } = string.Empty; - public string LocalPath { get; set; } = string.Empty; - public string? LocalSubsonicId { get; set; } - public string Title { get; set; } = string.Empty; - public string Artist { get; set; } = string.Empty; - public string Album { get; set; } = string.Empty; - public DateTime DownloadedAt { get; set; } -} +{ + private readonly string _mappingFilePath; + private readonly string _downloadDirectory; + private readonly HttpClient _httpClient; + private readonly SubsonicSettings _subsonicSettings; + private readonly ILogger _logger; + private Dictionary? _mappings; + private readonly SemaphoreSlim _lock = new(1, 1); + + // Debounce to avoid triggering too many scans + private DateTime _lastScanTrigger = DateTime.MinValue; + private readonly TimeSpan _scanDebounceInterval = TimeSpan.FromSeconds(30); + + public LocalLibraryService( + IConfiguration configuration, + IHttpClientFactory httpClientFactory, + IOptions subsonicSettings, + ILogger logger) + { + _downloadDirectory = configuration["Library:DownloadPath"] ?? Path.Combine(Directory.GetCurrentDirectory(), "downloads"); + _mappingFilePath = Path.Combine(_downloadDirectory, ".mappings.json"); + _httpClient = httpClientFactory.CreateClient(); + _subsonicSettings = subsonicSettings.Value; + _logger = logger; + + if (!Directory.Exists(_downloadDirectory)) + { + Directory.CreateDirectory(_downloadDirectory); + } + } + + public async Task GetLocalPathForExternalSongAsync(string externalProvider, string externalId) + { + var mappings = await LoadMappingsAsync(); + var key = $"{externalProvider}:{externalId}"; + + if (mappings.TryGetValue(key, out var mapping) && File.Exists(mapping.LocalPath)) + { + return mapping.LocalPath; + } + + return null; + } + + public async Task RegisterDownloadedSongAsync(Song song, string localPath) + { + if (song.ExternalProvider == null || song.ExternalId == null) return; + + // Load mappings first (this acquires the lock internally if needed) + var mappings = await LoadMappingsAsync(); + + await _lock.WaitAsync(); + try + { + var key = $"{song.ExternalProvider}:{song.ExternalId}"; + + mappings[key] = new LocalSongMapping + { + ExternalProvider = song.ExternalProvider, + ExternalId = song.ExternalId, + LocalPath = localPath, + Title = song.Title, + Artist = song.Artist, + Album = song.Album, + DownloadedAt = DateTime.UtcNow + }; + + await SaveMappingsAsync(mappings); + } + finally + { + _lock.Release(); + } + } + + public async Task GetLocalIdForExternalSongAsync(string externalProvider, string externalId) + { + // For now, return null as we don't yet have integration + // with the Subsonic server to retrieve local ID after scan + await Task.CompletedTask; + return null; + } + + public (bool isExternal, string? provider, string? externalId) ParseSongId(string songId) + { + var (isExternal, provider, _, externalId) = ParseExternalId(songId); + return (isExternal, provider, externalId); + } + + public (bool isExternal, string? provider, string? type, string? externalId) ParseExternalId(string id) + { + if (!id.StartsWith("ext-")) + { + return (false, null, null, null); + } + + var parts = id.Split('-'); + + // Known types for the new format + var knownTypes = new HashSet { "song", "album", "artist" }; + + // New format: ext-{provider}-{type}-{id} (e.g., ext-deezer-artist-259) + // Only use new format if parts[2] is a known type + if (parts.Length >= 4 && knownTypes.Contains(parts[2])) + { + var provider = parts[1]; + var type = parts[2]; + var externalId = string.Join("-", parts.Skip(3)); // Handle IDs with dashes + return (true, provider, type, externalId); + } + + // Legacy format: ext-{provider}-{id} (assumes "song" type for backward compatibility) + // This handles both 3-part IDs and 4+ part IDs where parts[2] is NOT a known type + if (parts.Length >= 3) + { + var provider = parts[1]; + var externalId = string.Join("-", parts.Skip(2)); // Everything after provider is the ID + return (true, provider, "song", externalId); + } + + return (false, null, null, null); + } + + private async Task> LoadMappingsAsync() + { + // Fast path: return cached mappings if available + if (_mappings != null) return _mappings; + + // Slow path: acquire lock to load from file (prevents race condition) + await _lock.WaitAsync(); + try + { + // Double-check after acquiring lock + if (_mappings != null) return _mappings; + + if (File.Exists(_mappingFilePath)) + { + var json = await File.ReadAllTextAsync(_mappingFilePath); + _mappings = System.Text.Json.JsonSerializer.Deserialize>(json) + ?? new Dictionary(); + } + else + { + _mappings = new Dictionary(); + } + + return _mappings; + } + finally + { + _lock.Release(); + } + } + + private async Task SaveMappingsAsync(Dictionary mappings) + { + _mappings = mappings; + var json = System.Text.Json.JsonSerializer.Serialize(mappings, new System.Text.Json.JsonSerializerOptions + { + WriteIndented = true + }); + await File.WriteAllTextAsync(_mappingFilePath, json); + } + + public string GetDownloadDirectory() => _downloadDirectory; + + public async Task TriggerLibraryScanAsync() + { + // Debounce: avoid triggering too many successive scans + var now = DateTime.UtcNow; + if (now - _lastScanTrigger < _scanDebounceInterval) + { + _logger.LogDebug("Scan debounced - last scan was {Elapsed}s ago", + (now - _lastScanTrigger).TotalSeconds); + return true; + } + + _lastScanTrigger = now; + + try + { + // Call Subsonic API to trigger a scan + // Note: This endpoint works without authentication on most Subsonic/Navidrome servers + // when called from localhost. For remote servers requiring auth, this would need + // to be refactored to accept credentials from the controller layer. + var url = $"{_subsonicSettings.Url}/rest/startScan?f=json"; + + _logger.LogInformation("Triggering Subsonic library scan..."); + + var response = await _httpClient.GetAsync(url); + + if (response.IsSuccessStatusCode) + { + var content = await response.Content.ReadAsStringAsync(); + _logger.LogInformation("Subsonic scan triggered successfully: {Response}", content); + return true; + } + else + { + _logger.LogError("Failed to trigger Subsonic scan: {StatusCode} - Server may require authentication", response.StatusCode); + return false; + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Error triggering Subsonic library scan"); + return false; + } + } + + public async Task GetScanStatusAsync() + { + try + { + // Note: This endpoint works without authentication on most Subsonic/Navidrome servers + // when called from localhost. + var url = $"{_subsonicSettings.Url}/rest/getScanStatus?f=json"; + + var response = await _httpClient.GetAsync(url); + + if (response.IsSuccessStatusCode) + { + var content = await response.Content.ReadAsStringAsync(); + var doc = JsonDocument.Parse(content); + + if (doc.RootElement.TryGetProperty("subsonic-response", out var subsonicResponse) && + subsonicResponse.TryGetProperty("scanStatus", out var scanStatus)) + { + return new ScanStatus + { + Scanning = scanStatus.TryGetProperty("scanning", out var scanning) && scanning.GetBoolean(), + Count = scanStatus.TryGetProperty("count", out var count) ? count.GetInt32() : null + }; + } + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Error getting Subsonic scan status"); + } + + return null; + } +} + +/// +/// Represents the mapping between an external song and its local file +/// +public class LocalSongMapping +{ + public string ExternalProvider { get; set; } = string.Empty; + public string ExternalId { get; set; } = string.Empty; + public string LocalPath { get; set; } = string.Empty; + public string? LocalSubsonicId { get; set; } + public string Title { get; set; } = string.Empty; + public string Artist { get; set; } = string.Empty; + public string Album { get; set; } = string.Empty; + public DateTime DownloadedAt { get; set; } +} diff --git a/allstarr/Services/Lyrics/LrclibService.cs b/allstarr/Services/Lyrics/LrclibService.cs index eb7682b..f5db5e9 100644 --- a/allstarr/Services/Lyrics/LrclibService.cs +++ b/allstarr/Services/Lyrics/LrclibService.cs @@ -18,7 +18,7 @@ public class LrclibService ILogger logger) { _httpClient = httpClientFactory.CreateClient(); - _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.0 (https://github.com/SoPat712/allstarr)"); + _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)"); _cache = cache; _logger = logger; } @@ -75,7 +75,7 @@ public class LrclibService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to deserialize cached lyrics"); + _logger.LogError(ex, "Failed to deserialize cached lyrics"); } } @@ -89,7 +89,7 @@ public class LrclibService $"track_name={Uri.EscapeDataString(trackName)}&" + $"artist_name={Uri.EscapeDataString(searchArtistName)}"; - _logger.LogInformation("Searching LRCLIB: {Url} (expecting {ArtistCount} artists)", searchUrl, artistNames.Length); + _logger.LogDebug("Searching LRCLIB: {Url} (expecting {ArtistCount} artists)", searchUrl, artistNames.Length); var searchResponse = await _httpClient.GetAsync(searchUrl); @@ -157,12 +157,12 @@ public class LrclibService SyncedLyrics = bestMatch.SyncedLyrics }; - await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), TimeSpan.FromDays(30)); + await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), CacheExtensions.LyricsTTL); return result; } else { - _logger.LogInformation("Best match score too low ({Score:F1}), trying exact match", bestScore); + _logger.LogDebug("Best match score too low ({Score:F1}), trying exact match", bestScore); } } } @@ -206,7 +206,7 @@ public class LrclibService SyncedLyrics = lyrics.SyncedLyrics }; - await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(exactResult, JsonOptions), TimeSpan.FromDays(30)); + await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(exactResult, JsonOptions), CacheExtensions.LyricsTTL); _logger.LogInformation("Retrieved lyrics via exact match for {Artist} - {Track} (ID: {Id})", artistName, trackName, lyrics.Id); @@ -214,7 +214,7 @@ public class LrclibService } catch (HttpRequestException ex) { - _logger.LogWarning(ex, "Failed to fetch lyrics from LRCLIB for {Artist} - {Track}", artistName, trackName); + _logger.LogError(ex, "Failed to fetch lyrics from LRCLIB for {Artist} - {Track}", artistName, trackName); return null; } catch (Exception ex) @@ -350,7 +350,7 @@ public class LrclibService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to fetch cached lyrics for {Artist} - {Track}", artistName, trackName); + _logger.LogError(ex, "Failed to fetch cached lyrics for {Artist} - {Track}", artistName, trackName); return null; } } @@ -368,7 +368,7 @@ public class LrclibService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to deserialize cached lyrics"); + _logger.LogError(ex, "Failed to deserialize cached lyrics"); } } @@ -404,7 +404,7 @@ public class LrclibService SyncedLyrics = lyrics.SyncedLyrics }; - await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), TimeSpan.FromDays(30)); + await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), CacheExtensions.LyricsTTL); return result; } diff --git a/allstarr/Services/Lyrics/LyricsOrchestrator.cs b/allstarr/Services/Lyrics/LyricsOrchestrator.cs new file mode 100644 index 0000000..4987349 --- /dev/null +++ b/allstarr/Services/Lyrics/LyricsOrchestrator.cs @@ -0,0 +1,228 @@ +using allstarr.Models.Lyrics; +using allstarr.Models.Settings; +using Microsoft.Extensions.Options; + +namespace allstarr.Services.Lyrics; + +/// +/// Orchestrates lyrics fetching from multiple sources with priority-based fallback. +/// Priority order: Spotify → LyricsPlus → LRCLib +/// Note: Jellyfin local lyrics are handled by the controller before calling this orchestrator. +/// +public class LyricsOrchestrator +{ + private readonly SpotifyLyricsService _spotifyLyrics; + private readonly LyricsPlusService _lyricsPlus; + private readonly LrclibService _lrclib; + private readonly SpotifyApiSettings _spotifySettings; + private readonly ILogger _logger; + + public LyricsOrchestrator( + SpotifyLyricsService spotifyLyrics, + LyricsPlusService lyricsPlus, + LrclibService lrclib, + IOptions spotifySettings, + ILogger logger) + { + _spotifyLyrics = spotifyLyrics; + _lyricsPlus = lyricsPlus; + _lrclib = lrclib; + _spotifySettings = spotifySettings.Value; + _logger = logger; + } + + /// + /// Fetches lyrics with automatic fallback through all available sources. + /// Note: Jellyfin local lyrics are handled by the controller before calling this. + /// + /// Track title + /// Artist names (can be multiple) + /// Album name + /// Track duration in seconds + /// Spotify track ID (if available) + /// Lyrics info or null if not found + public async Task GetLyricsAsync( + string trackName, + string[] artistNames, + string? albumName, + int durationSeconds, + string? spotifyTrackId = null) + { + var artistName = string.Join(", ", artistNames); + + _logger.LogInformation("🎵 Fetching lyrics for: {Artist} - {Track}", artistName, trackName); + + // 1. Try Spotify lyrics (if Spotify ID provided) + if (!string.IsNullOrEmpty(spotifyTrackId)) + { + var spotifyLyrics = await TrySpotifyLyrics(spotifyTrackId, artistName, trackName); + if (spotifyLyrics != null) + { + return spotifyLyrics; + } + } + + // 2. Try LyricsPlus + var lyricsPlusLyrics = await TryLyricsPlusLyrics(trackName, artistNames, albumName, durationSeconds, artistName); + if (lyricsPlusLyrics != null) + { + return lyricsPlusLyrics; + } + + // 3. Try LRCLib + var lrclibLyrics = await TryLrclibLyrics(trackName, artistNames, albumName, durationSeconds, artistName); + if (lrclibLyrics != null) + { + return lrclibLyrics; + } + + _logger.LogInformation("❌ No lyrics found for: {Artist} - {Track}", artistName, trackName); + return null; + } + + /// + /// Prefetches lyrics in the background (for cache warming). + /// Skips Jellyfin local since we don't have an itemId. + /// + public async Task PrefetchLyricsAsync( + string trackName, + string[] artistNames, + string? albumName, + int durationSeconds, + string? spotifyTrackId = null) + { + var artistName = string.Join(", ", artistNames); + + _logger.LogDebug("🎵 Prefetching lyrics for: {Artist} - {Track}", artistName, trackName); + + // 1. Try Spotify lyrics (if Spotify ID provided) + if (!string.IsNullOrEmpty(spotifyTrackId)) + { + var spotifyLyrics = await TrySpotifyLyrics(spotifyTrackId, artistName, trackName); + if (spotifyLyrics != null) + { + return true; + } + } + + // 2. Try LyricsPlus + var lyricsPlusLyrics = await TryLyricsPlusLyrics(trackName, artistNames, albumName, durationSeconds, artistName); + if (lyricsPlusLyrics != null) + { + return true; + } + + // 3. Try LRCLib + var lrclibLyrics = await TryLrclibLyrics(trackName, artistNames, albumName, durationSeconds, artistName); + if (lrclibLyrics != null) + { + return true; + } + + _logger.LogDebug("No lyrics found for prefetch: {Artist} - {Track}", artistName, trackName); + return false; + } + + #region Private Helper Methods + + private async Task TrySpotifyLyrics(string spotifyTrackId, string artistName, string trackName) + { + if (!_spotifySettings.Enabled) + { + _logger.LogWarning("Spotify API not enabled, skipping Spotify lyrics"); + return null; + } + + try + { + // Validate Spotify ID format + var cleanSpotifyId = spotifyTrackId.Replace("spotify:track:", "").Trim(); + + if (cleanSpotifyId.Length != 22 || cleanSpotifyId.Contains(":") || cleanSpotifyId.Contains("local")) + { + _logger.LogWarning("Invalid Spotify ID format: {SpotifyId}, skipping", spotifyTrackId); + return null; + } + + _logger.LogDebug("→ Trying Spotify lyrics for track ID: {SpotifyId}", cleanSpotifyId); + + var spotifyLyrics = await _spotifyLyrics.GetLyricsByTrackIdAsync(cleanSpotifyId); + + if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0) + { + _logger.LogDebug("✓ Found Spotify lyrics for {Artist} - {Track} ({LineCount} lines, type: {SyncType})", + artistName, trackName, spotifyLyrics.Lines.Count, spotifyLyrics.SyncType); + + return _spotifyLyrics.ToLyricsInfo(spotifyLyrics); + } + + _logger.LogDebug("No Spotify lyrics found for track ID {SpotifyId}", cleanSpotifyId); + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching Spotify lyrics for track ID {SpotifyId}", spotifyTrackId); + return null; + } + } + + private async Task TryLyricsPlusLyrics( + string trackName, + string[] artistNames, + string? albumName, + int durationSeconds, + string artistName) + { + try + { + _logger.LogDebug("→ Trying LyricsPlus for: {Artist} - {Track}", artistName, trackName); + + var lyrics = await _lyricsPlus.GetLyricsAsync(trackName, artistNames, albumName, durationSeconds); + + if (lyrics != null) + { + _logger.LogInformation("✓ Found LyricsPlus lyrics for {Artist} - {Track}", artistName, trackName); + return lyrics; + } + + _logger.LogDebug("No LyricsPlus lyrics found for {Artist} - {Track}", artistName, trackName); + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching LyricsPlus lyrics for {Artist} - {Track}", artistName, trackName); + return null; + } + } + + private async Task TryLrclibLyrics( + string trackName, + string[] artistNames, + string? albumName, + int durationSeconds, + string artistName) + { + try + { + _logger.LogDebug("→ Trying LRCLib for: {Artist} - {Track}", artistName, trackName); + + var lyrics = await _lrclib.GetLyricsAsync(trackName, artistNames, albumName ?? string.Empty, durationSeconds); + + if (lyrics != null) + { + _logger.LogInformation("✓ Found LRCLib lyrics for {Artist} - {Track}", artistName, trackName); + return lyrics; + } + + _logger.LogDebug("No LRCLib lyrics found for {Artist} - {Track}", artistName, trackName); + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching LRCLib lyrics for {Artist} - {Track}", artistName, trackName); + return null; + } + } + + #endregion +} diff --git a/allstarr/Services/Lyrics/LyricsPlusService.cs b/allstarr/Services/Lyrics/LyricsPlusService.cs new file mode 100644 index 0000000..987483e --- /dev/null +++ b/allstarr/Services/Lyrics/LyricsPlusService.cs @@ -0,0 +1,254 @@ +using System.Text.Json; +using System.Text.Json.Serialization; +using allstarr.Models.Lyrics; +using allstarr.Services.Common; + +namespace allstarr.Services.Lyrics; + +/// +/// Service for fetching lyrics from LyricsPlus API (https://lyricsplus.prjktla.workers.dev) +/// Supports multiple sources: Apple Music, Spotify, Musixmatch, and more +/// +public class LyricsPlusService +{ + private readonly HttpClient _httpClient; + private readonly RedisCacheService _cache; + private readonly ILogger _logger; + private const string BaseUrl = "https://lyricsplus.prjktla.workers.dev/v2/lyrics/get"; + + public LyricsPlusService( + IHttpClientFactory httpClientFactory, + RedisCacheService cache, + ILogger logger) + { + _httpClient = httpClientFactory.CreateClient(); + _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)"); + _cache = cache; + _logger = logger; + } + + public async Task GetLyricsAsync(string trackName, string artistName, string? albumName, int durationSeconds) + { + return await GetLyricsAsync(trackName, new[] { artistName }, albumName, durationSeconds); + } + + public async Task GetLyricsAsync(string trackName, string[] artistNames, string? albumName, int durationSeconds) + { + // Validate input parameters + if (string.IsNullOrWhiteSpace(trackName) || artistNames == null || artistNames.Length == 0) + { + _logger.LogDebug("Invalid parameters for LyricsPlus search: trackName={TrackName}, artistCount={ArtistCount}", + trackName, artistNames?.Length ?? 0); + return null; + } + + var artistName = string.Join(", ", artistNames); + var cacheKey = $"lyricsplus:{artistName}:{trackName}:{albumName}:{durationSeconds}"; + + // Check cache + var cached = await _cache.GetStringAsync(cacheKey); + if (!string.IsNullOrEmpty(cached)) + { + try + { + return JsonSerializer.Deserialize(cached, JsonOptions); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to deserialize cached LyricsPlus lyrics"); + } + } + + try + { + // Build URL with query parameters + var url = $"{BaseUrl}?title={Uri.EscapeDataString(trackName)}&artist={Uri.EscapeDataString(artistName)}"; + + if (!string.IsNullOrEmpty(albumName)) + { + url += $"&album={Uri.EscapeDataString(albumName)}"; + } + + if (durationSeconds > 0) + { + url += $"&duration={durationSeconds}"; + } + + // Add sources: apple, lyricsplus, musixmatch, spotify, musixmatch-word + url += "&source=apple,lyricsplus,musixmatch,spotify,musixmatch-word"; + + _logger.LogDebug("Fetching lyrics from LyricsPlus: {Url}", url); + + var response = await _httpClient.GetAsync(url); + + if (response.StatusCode == System.Net.HttpStatusCode.NotFound) + { + _logger.LogDebug("Lyrics not found on LyricsPlus for {Artist} - {Track}", artistName, trackName); + return null; + } + + response.EnsureSuccessStatusCode(); + + var json = await response.Content.ReadAsStringAsync(); + var lyricsResponse = JsonSerializer.Deserialize(json, JsonOptions); + + if (lyricsResponse == null || lyricsResponse.Lyrics == null || lyricsResponse.Lyrics.Count == 0) + { + _logger.LogDebug("Empty lyrics response from LyricsPlus for {Artist} - {Track}", artistName, trackName); + return null; + } + + // Convert to LyricsInfo format + var result = ConvertToLyricsInfo(lyricsResponse, trackName, artistName, albumName, durationSeconds); + + if (result != null) + { + await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), CacheExtensions.LyricsTTL); + _logger.LogInformation("✓ Retrieved lyrics from LyricsPlus for {Artist} - {Track} (type: {Type}, source: {Source})", + artistName, trackName, lyricsResponse.Type, lyricsResponse.Metadata?.Source); + } + + return result; + } + catch (HttpRequestException ex) + { + _logger.LogError(ex, "Failed to fetch lyrics from LyricsPlus for {Artist} - {Track}", artistName, trackName); + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching lyrics from LyricsPlus for {Artist} - {Track}", artistName, trackName); + return null; + } + } + + private LyricsInfo? ConvertToLyricsInfo(LyricsPlusResponse response, string trackName, string artistName, string? albumName, int durationSeconds) + { + if (response.Lyrics == null || response.Lyrics.Count == 0) + { + return null; + } + + string? syncedLyrics = null; + string? plainLyrics = null; + + // Convert based on type + if (response.Type == "Word") + { + // Word-level timing - convert to line-level LRC + syncedLyrics = ConvertWordTimingToLrc(response.Lyrics); + plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text)); + } + else if (response.Type == "Line") + { + // Line-level timing - convert to LRC + syncedLyrics = ConvertLineTimingToLrc(response.Lyrics); + plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text)); + } + else + { + // Static or unknown type - just plain text + plainLyrics = string.Join("\n", response.Lyrics.Select(l => l.Text)); + } + + return new LyricsInfo + { + TrackName = trackName, + ArtistName = artistName, + AlbumName = albumName ?? string.Empty, + Duration = durationSeconds, + Instrumental = false, + PlainLyrics = plainLyrics, + SyncedLyrics = syncedLyrics + }; + } + + private string ConvertLineTimingToLrc(List lines) + { + var lrcLines = new List(); + + foreach (var line in lines) + { + if (line.Time.HasValue) + { + var timestamp = TimeSpan.FromMilliseconds(line.Time.Value); + var mm = (int)timestamp.TotalMinutes; + var ss = timestamp.Seconds; + var cs = timestamp.Milliseconds / 10; // Convert to centiseconds + + lrcLines.Add($"[{mm:D2}:{ss:D2}.{cs:D2}]{line.Text}"); + } + else + { + // No timing, just add the text + lrcLines.Add(line.Text); + } + } + + return string.Join("\n", lrcLines); + } + + private string ConvertWordTimingToLrc(List lines) + { + // For word-level timing, we use the line start time + // (word-level detail is in syllabus array but we simplify to line-level for LRC) + return ConvertLineTimingToLrc(lines); + } + + private static readonly JsonSerializerOptions JsonOptions = new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull + }; + + private class LyricsPlusResponse + { + [JsonPropertyName("type")] + public string Type { get; set; } = string.Empty; // "Word", "Line", or "Static" + + [JsonPropertyName("metadata")] + public LyricsPlusMetadata? Metadata { get; set; } + + [JsonPropertyName("lyrics")] + public List Lyrics { get; set; } = new(); + } + + private class LyricsPlusMetadata + { + [JsonPropertyName("source")] + public string? Source { get; set; } + + [JsonPropertyName("title")] + public string? Title { get; set; } + + [JsonPropertyName("language")] + public string? Language { get; set; } + } + + private class LyricsPlusLine + { + [JsonPropertyName("time")] + public long? Time { get; set; } // Milliseconds + + [JsonPropertyName("duration")] + public long? Duration { get; set; } + + [JsonPropertyName("text")] + public string Text { get; set; } = string.Empty; + + [JsonPropertyName("syllabus")] + public List? Syllabus { get; set; } + } + + private class LyricsPlusSyllable + { + [JsonPropertyName("time")] + public long Time { get; set; } + + [JsonPropertyName("duration")] + public long Duration { get; set; } + + [JsonPropertyName("text")] + public string Text { get; set; } = string.Empty; + } +} diff --git a/allstarr/Services/Lyrics/LyricsPrefetchService.cs b/allstarr/Services/Lyrics/LyricsPrefetchService.cs index dd05c09..81831eb 100644 --- a/allstarr/Services/Lyrics/LyricsPrefetchService.cs +++ b/allstarr/Services/Lyrics/LyricsPrefetchService.cs @@ -58,7 +58,7 @@ public class LyricsPrefetchService : BackgroundService // Run initial prefetch try { - _logger.LogInformation("Running initial lyrics prefetch on startup"); + _logger.LogDebug("Running initial lyrics prefetch on startup"); await PrefetchAllPlaylistLyricsAsync(stoppingToken); } catch (Exception ex) @@ -115,7 +115,7 @@ public class LyricsPrefetchService : BackgroundService string playlistName, CancellationToken cancellationToken) { - _logger.LogInformation("Prefetching lyrics for playlist: {Playlist}", playlistName); + _logger.LogDebug("Prefetching lyrics for playlist: {Playlist}", playlistName); var tracks = await _playlistFetcher.GetPlaylistTracksAsync(playlistName); if (tracks.Count == 0) @@ -156,7 +156,7 @@ public class LyricsPrefetchService : BackgroundService } } - _logger.LogDebug("Found {Count} local Jellyfin tracks with Spotify IDs in playlist {Playlist}", + _logger.LogInformation("Found {Count} local Jellyfin tracks with Spotify IDs in playlist {Playlist}", spotifyToJellyfinId.Count, playlistName); } @@ -179,7 +179,7 @@ public class LyricsPrefetchService : BackgroundService if (!string.IsNullOrEmpty(existingLyrics)) { cached++; - _logger.LogDebug("✓ Lyrics already cached for {Artist} - {Track}", track.PrimaryArtist, track.Title); + _logger.LogInformation("✓ Lyrics already cached for {Artist} - {Track}", track.PrimaryArtist, track.Title); continue; } @@ -191,7 +191,7 @@ public class LyricsPrefetchService : BackgroundService if (hasLocalLyrics) { cached++; - _logger.LogInformation("✓ Local Jellyfin lyrics found for {Artist} - {Track}, skipping external fetch", + _logger.LogWarning("✓ Local Jellyfin lyrics found for {Artist} - {Track}, skipping external fetch", track.PrimaryArtist, track.Title); // Remove any previously cached LRCLib lyrics for this track @@ -239,12 +239,12 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to prefetch lyrics for {Artist} - {Track}", track.PrimaryArtist, track.Title); + _logger.LogError(ex, "Failed to prefetch lyrics for {Artist} - {Track}", track.PrimaryArtist, track.Title); missing++; } } - _logger.LogInformation("Playlist {Playlist}: {Fetched} fetched, {Cached} cached, {Missing} missing", + _logger.LogDebug("Playlist {Playlist}: {Fetched} fetched, {Cached} cached, {Missing} missing", playlistName, fetched, cached, missing); return (fetched, cached, missing); @@ -264,7 +264,7 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to save lyrics to file for {Artist} - {Track}", artist, title); + _logger.LogError(ex, "Failed to save lyrics to file for {Artist} - {Track}", artist, title); } } @@ -277,7 +277,7 @@ public class LyricsPrefetchService : BackgroundService { if (!Directory.Exists(_lyricsCacheDir)) { - _logger.LogInformation("Lyrics cache directory does not exist, skipping cache warming"); + _logger.LogWarning("Lyrics cache directory does not exist, skipping cache warming"); return; } @@ -288,7 +288,7 @@ public class LyricsPrefetchService : BackgroundService return; } - _logger.LogInformation("🔥 Warming lyrics cache from {Count} files...", files.Length); + _logger.LogDebug("🔥 Warming lyrics cache from {Count} files...", files.Length); var loaded = 0; foreach (var file in files) @@ -301,17 +301,17 @@ public class LyricsPrefetchService : BackgroundService if (lyrics != null) { var cacheKey = $"lyrics:{lyrics.ArtistName}:{lyrics.TrackName}:{lyrics.AlbumName}:{lyrics.Duration}"; - await _cache.SetStringAsync(cacheKey, json, TimeSpan.FromDays(30)); + await _cache.SetStringAsync(cacheKey, json, CacheExtensions.LyricsTTL); loaded++; } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to load lyrics from file {File}", Path.GetFileName(file)); + _logger.LogError(ex, "Failed to load lyrics from file {File}", Path.GetFileName(file)); } } - _logger.LogInformation("✅ Warmed {Count} lyrics from file cache", loaded); + _logger.LogDebug("✅ Warmed {Count} lyrics from file cache", loaded); } catch (Exception ex) { @@ -351,7 +351,7 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to remove cached lyrics for {Artist} - {Track}", artist, title); + _logger.LogError(ex, "Failed to remove cached lyrics for {Artist} - {Track}", artist, title); } } @@ -375,7 +375,7 @@ public class LyricsPrefetchService : BackgroundService if (spotifyLyrics != null && spotifyLyrics.Lines.Count > 0) { - _logger.LogInformation("✓ Found Spotify lyrics for {Artist} - {Track} ({LineCount} lines)", + _logger.LogDebug("✓ Found Spotify lyrics for {Artist} - {Track} ({LineCount} lines)", artistName, trackTitle, spotifyLyrics.Lines.Count); return spotifyLyricsService.ToLyricsInfo(spotifyLyrics); } @@ -384,7 +384,7 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Error fetching Spotify lyrics for track {SpotifyId}", spotifyTrackId); + _logger.LogError(ex, "Error fetching Spotify lyrics for track {SpotifyId}", spotifyTrackId); return null; } } @@ -423,7 +423,7 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Error checking Jellyfin lyrics for item {ItemId}", jellyfinItemId); + _logger.LogError(ex, "Error checking Jellyfin lyrics for item {ItemId}", jellyfinItemId); return false; } } @@ -528,7 +528,7 @@ public class LyricsPrefetchService : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Error checking for local Jellyfin lyrics for Spotify track {SpotifyId}", spotifyTrackId); + _logger.LogError(ex, "Error checking for local Jellyfin lyrics for Spotify track {SpotifyId}", spotifyTrackId); return false; } } diff --git a/allstarr/Services/Lyrics/LyricsStartupValidator.cs b/allstarr/Services/Lyrics/LyricsStartupValidator.cs index b45d764..057c77f 100644 --- a/allstarr/Services/Lyrics/LyricsStartupValidator.cs +++ b/allstarr/Services/Lyrics/LyricsStartupValidator.cs @@ -167,16 +167,14 @@ public class LyricsStartupValidator : BaseStartupValidator { try { - if (string.IsNullOrEmpty(_spotifySettings.ClientId)) + if (!_spotifySettings.Enabled) { - WriteStatus("Spotify API", "NOT CONFIGURED", ConsoleColor.Yellow); - WriteDetail("Set SpotifyApi__ClientId to enable"); + WriteStatus("Spotify API", "DISABLED", ConsoleColor.Gray); return true; } WriteStatus("Spotify API", "CONFIGURED", ConsoleColor.Green); - WriteDetail($"Client ID: {_spotifySettings.ClientId.Substring(0, Math.Min(8, _spotifySettings.ClientId.Length))}..."); - WriteDetail("Note: Spotify API is used for track matching, not lyrics"); + WriteDetail("Note: Spotify API is used for track matching and lyrics"); return true; } catch (Exception ex) diff --git a/allstarr/Services/Lyrics/SpotifyLyricsService.cs b/allstarr/Services/Lyrics/SpotifyLyricsService.cs index c47278b..0793d45 100644 --- a/allstarr/Services/Lyrics/SpotifyLyricsService.cs +++ b/allstarr/Services/Lyrics/SpotifyLyricsService.cs @@ -50,13 +50,13 @@ public class SpotifyLyricsService { if (!_settings.Enabled || string.IsNullOrEmpty(_settings.SessionCookie)) { - _logger.LogDebug("Spotify API not enabled or no session cookie configured"); + _logger.LogInformation("Spotify API not enabled or no session cookie configured"); return null; } if (string.IsNullOrEmpty(_settings.LyricsApiUrl)) { - _logger.LogWarning("Spotify lyrics API URL not configured"); + _logger.LogInformation("Spotify lyrics API URL not configured"); return null; } @@ -84,7 +84,7 @@ public class SpotifyLyricsService if (result != null) { - _logger.LogInformation("Got Spotify lyrics from sidecar for track {TrackId} ({LineCount} lines)", + _logger.LogDebug("Got Spotify lyrics from sidecar for track {TrackId} ({LineCount} lines)", spotifyTrackId, result.Lines.Count); } @@ -92,7 +92,7 @@ public class SpotifyLyricsService } catch (Exception ex) { - _logger.LogWarning(ex, "Error fetching lyrics from sidecar API for track {TrackId}", spotifyTrackId); + _logger.LogError(ex, "Error fetching lyrics from sidecar API for track {TrackId}", spotifyTrackId); return null; } } @@ -110,14 +110,14 @@ public class SpotifyLyricsService { if (!_settings.Enabled || string.IsNullOrEmpty(_settings.SessionCookie)) { - _logger.LogDebug("Spotify lyrics search skipped: API not enabled or no session cookie"); + _logger.LogInformation("Spotify lyrics search skipped: API not enabled or no session cookie"); return null; } // The sidecar API only supports track ID, not search // So we skip Spotify lyrics for search-based requests // LRCLib will be used as fallback - _logger.LogDebug("Spotify lyrics search by metadata not supported with sidecar API, skipping"); + _logger.LogWarning("Spotify lyrics search by metadata not supported with sidecar API, skipping"); return null; } @@ -169,7 +169,7 @@ public class SpotifyLyricsService // Check for error if (root.TryGetProperty("error", out var error) && error.GetBoolean()) { - _logger.LogDebug("Sidecar API returned error for track {TrackId}", trackId); + _logger.LogError("Sidecar API returned error for track {TrackId}", trackId); return null; } diff --git a/allstarr/Services/MusicBrainz/MusicBrainzService.cs b/allstarr/Services/MusicBrainz/MusicBrainzService.cs index 025a2ee..1b0d326 100644 --- a/allstarr/Services/MusicBrainz/MusicBrainzService.cs +++ b/allstarr/Services/MusicBrainz/MusicBrainzService.cs @@ -25,7 +25,7 @@ public class MusicBrainzService ILogger logger) { _httpClient = httpClientFactory.CreateClient(); - _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.0 (https://github.com/SoPat712/allstarr)"); + _httpClient.DefaultRequestHeaders.Add("User-Agent", "Allstarr/1.0.1 (https://github.com/SoPat712/allstarr)"); _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); _settings = settings.Value; @@ -92,6 +92,7 @@ public class MusicBrainzService /// /// Searches for recordings by title and artist. + /// Note: Search API doesn't return genres, only MBIDs. Use LookupByMbidAsync to get genres. /// public async Task> SearchRecordingsAsync(string title, string artist, int limit = 5) { @@ -107,7 +108,8 @@ public class MusicBrainzService // Build Lucene query var query = $"recording:\"{title}\" AND artist:\"{artist}\""; var encodedQuery = Uri.EscapeDataString(query); - var url = $"{_settings.BaseUrl}/recording?query={encodedQuery}&fmt=json&limit={limit}&inc=genres+tags"; + // Note: Search API doesn't support inc=genres, only returns basic info + MBIDs + var url = $"{_settings.BaseUrl}/recording?query={encodedQuery}&fmt=json&limit={limit}"; _logger.LogDebug("MusicBrainz search: {Url}", url); @@ -128,7 +130,7 @@ public class MusicBrainzService return new List(); } - _logger.LogInformation("Found {Count} MusicBrainz recordings for: {Title} - {Artist}", + _logger.LogDebug("Found {Count} MusicBrainz recordings for: {Title} - {Artist}", result.Recordings.Count, title, artist); return result.Recordings; @@ -140,9 +142,56 @@ public class MusicBrainzService } } + /// + /// Looks up a recording by MBID to get full details including genres. + /// + public async Task LookupByMbidAsync(string mbid) + { + if (!_settings.Enabled) + { + return null; + } + + await RateLimitAsync(); + + try + { + var url = $"{_settings.BaseUrl}/recording/{mbid}?fmt=json&inc=artists+releases+release-groups+genres+tags"; + _logger.LogDebug("MusicBrainz MBID lookup: {Url}", url); + + var response = await _httpClient.GetAsync(url); + + if (!response.IsSuccessStatusCode) + { + _logger.LogWarning("MusicBrainz MBID lookup failed: {StatusCode}", response.StatusCode); + return null; + } + + var json = await response.Content.ReadAsStringAsync(); + var recording = JsonSerializer.Deserialize(json, JsonOptions); + + if (recording == null) + { + _logger.LogDebug("No MusicBrainz recording found for MBID: {Mbid}", mbid); + return null; + } + + var genres = recording.Genres?.Select(g => g.Name).Where(n => !string.IsNullOrEmpty(n)).ToList() ?? new List(); + _logger.LogInformation("✓ Found MusicBrainz recording for MBID {Mbid}: {Title} by {Artist} (Genres: {Genres})", + mbid, recording.Title, recording.ArtistCredit?[0]?.Name ?? "Unknown", string.Join(", ", genres)); + + return recording; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error looking up MBID {Mbid} in MusicBrainz", mbid); + return null; + } + } + /// /// Enriches a song with genre information from MusicBrainz. - /// First tries ISRC lookup, then falls back to title/artist search. + /// First tries ISRC lookup, then falls back to title/artist search + MBID lookup. /// public async Task> GetGenresForSongAsync(string title, string artist, string? isrc = null) { @@ -153,17 +202,23 @@ public class MusicBrainzService MusicBrainzRecording? recording = null; - // Try ISRC lookup first (most accurate) + // Try ISRC lookup first (most accurate and includes genres) if (!string.IsNullOrEmpty(isrc)) { recording = await LookupByIsrcAsync(isrc); } - // Fall back to search if ISRC lookup failed or no ISRC provided + // Fall back to search + MBID lookup if ISRC lookup failed or no ISRC provided if (recording == null) { var recordings = await SearchRecordingsAsync(title, artist, limit: 1); - recording = recordings.FirstOrDefault(); + var searchResult = recordings.FirstOrDefault(); + + // If we found a recording from search, do a full lookup by MBID to get genres + if (searchResult != null && !string.IsNullOrEmpty(searchResult.Id)) + { + recording = await LookupByMbidAsync(searchResult.Id); + } } if (recording == null) @@ -186,7 +241,7 @@ public class MusicBrainzService .ToList()); } - _logger.LogInformation("Found {Count} genres for {Title} - {Artist}: {Genres}", + _logger.LogDebug("Found {Count} genres for {Title} - {Artist}: {Genres}", genres.Count, title, artist, string.Join(", ", genres)); return genres; diff --git a/allstarr/Services/Qobuz/QobuzBundleService.cs b/allstarr/Services/Qobuz/QobuzBundleService.cs index a15d60b..36338dc 100644 --- a/allstarr/Services/Qobuz/QobuzBundleService.cs +++ b/allstarr/Services/Qobuz/QobuzBundleService.cs @@ -92,18 +92,18 @@ public class QobuzBundleService // Step 1: Get the bundle URL from login page var bundleUrl = await GetBundleUrlAsync(); - _logger.LogInformation("Found bundle URL: {BundleUrl}", bundleUrl); + _logger.LogDebug("Found bundle URL: {BundleUrl}", bundleUrl); // Step 2: Download the bundle JavaScript var bundleJs = await DownloadBundleAsync(bundleUrl); // Step 3: Extract App ID _cachedAppId = ExtractAppId(bundleJs); - _logger.LogInformation("Extracted App ID: {AppId}", _cachedAppId); + _logger.LogDebug("Extracted App ID: {AppId}", _cachedAppId); // Step 4: Extract secrets (they are base64 encoded in the bundle) _cachedSecrets = ExtractSecrets(bundleJs); - _logger.LogInformation("Extracted {Count} secrets", _cachedSecrets.Count); + _logger.LogDebug("Extracted {Count} secrets", _cachedSecrets.Count); } finally { @@ -253,7 +253,7 @@ public class QobuzBundleService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to decode secret for timezone {Timezone}", kvp.Key); + _logger.LogError(ex, "Failed to decode secret for timezone {Timezone}", kvp.Key); } } diff --git a/allstarr/Services/Qobuz/QobuzDownloadService.cs b/allstarr/Services/Qobuz/QobuzDownloadService.cs index d8aeab7..9d91150 100644 --- a/allstarr/Services/Qobuz/QobuzDownloadService.cs +++ b/allstarr/Services/Qobuz/QobuzDownloadService.cs @@ -114,7 +114,7 @@ public class QobuzDownloadService : BaseDownloadService var basePath = SubsonicSettings.StorageMode == StorageMode.Cache ? Path.Combine(DownloadPath, "cache") : Path.Combine(DownloadPath, "permanent"); - var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension); + var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension, "qobuz", trackId); var albumFolder = Path.GetDirectoryName(outputPath)!; EnsureDirectoryExists(albumFolder); diff --git a/allstarr/Services/Qobuz/QobuzMetadataService.cs b/allstarr/Services/Qobuz/QobuzMetadataService.cs index c718fe7..d5c4350 100644 --- a/allstarr/Services/Qobuz/QobuzMetadataService.cs +++ b/allstarr/Services/Qobuz/QobuzMetadataService.cs @@ -3,6 +3,7 @@ using allstarr.Models.Settings; using allstarr.Models.Download; using allstarr.Models.Search; using allstarr.Models.Subsonic; +using allstarr.Services.Common; using System.Text.Json; using Microsoft.Extensions.Options; @@ -18,6 +19,7 @@ public class QobuzMetadataService : IMusicMetadataService private readonly SubsonicSettings _settings; private readonly QobuzBundleService _bundleService; private readonly ILogger _logger; + private readonly GenreEnrichmentService? _genreEnrichment; private readonly string? _userAuthToken; private readonly string? _userId; @@ -28,12 +30,14 @@ public class QobuzMetadataService : IMusicMetadataService IOptions settings, IOptions qobuzSettings, QobuzBundleService bundleService, - ILogger logger) + ILogger logger, + GenreEnrichmentService? genreEnrichment = null) { _httpClient = httpClientFactory.CreateClient(); _settings = settings.Value; _bundleService = bundleService; _logger = logger; + _genreEnrichment = genreEnrichment; var qobuzConfig = qobuzSettings.Value; _userAuthToken = qobuzConfig.UserAuthToken; @@ -177,7 +181,26 @@ public class QobuzMetadataService : IMusicMetadataService if (track.TryGetProperty("error", out _)) return null; - return ParseQobuzTrackFull(track); + var song = ParseQobuzTrackFull(track); + + // Enrich with MusicBrainz genres if missing + if (_genreEnrichment != null && song != null && string.IsNullOrEmpty(song.Genre)) + { + // Fire-and-forget: don't block the response waiting for genre enrichment + _ = Task.Run(async () => + { + try + { + await _genreEnrichment.EnrichSongGenreAsync(song); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to enrich genre for {Title}", song.Title); + } + }); + } + + return song; } catch (Exception ex) { diff --git a/allstarr/Services/Spotify/SpotifyApiClient.cs b/allstarr/Services/Spotify/SpotifyApiClient.cs index 3d51b92..ccc391e 100644 --- a/allstarr/Services/Spotify/SpotifyApiClient.cs +++ b/allstarr/Services/Spotify/SpotifyApiClient.cs @@ -98,7 +98,7 @@ public class SpotifyApiClient : IDisposable { if (string.IsNullOrEmpty(_settings.SessionCookie)) { - _logger.LogWarning("No Spotify session cookie configured"); + _logger.LogInformation("No Spotify session cookie configured"); return null; } @@ -349,6 +349,17 @@ public class SpotifyApiClient : IDisposable var response = await _webApiClient.SendAsync(request, cancellationToken); + // Handle 429 rate limiting with exponential backoff + if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests) + { + var retryAfter = response.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(5); + _logger.LogWarning("Spotify rate limit hit (429) when fetching playlist {PlaylistId}. Waiting {Seconds}s before retry...", playlistId, retryAfter.TotalSeconds); + await Task.Delay(retryAfter, cancellationToken); + + // Retry the request + response = await _webApiClient.SendAsync(request, cancellationToken); + } + if (!response.IsSuccessStatusCode) { _logger.LogError("Failed to fetch playlist via GraphQL: {StatusCode}", response.StatusCode); @@ -519,7 +530,7 @@ public class SpotifyApiClient : IDisposable } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to parse GraphQL track"); + _logger.LogError(ex, "Failed to parse GraphQL track"); return null; } } @@ -735,6 +746,18 @@ public class SpotifyApiClient : IDisposable public async Task> SearchUserPlaylistsAsync( string searchName, CancellationToken cancellationToken = default) + { + return await GetUserPlaylistsAsync(searchName, cancellationToken); + } + + /// + /// Gets all playlists from the user's library, optionally filtered by name. + /// Uses GraphQL API which is less rate-limited than REST API. + /// + /// Optional name filter (case-insensitive). If null, returns all playlists. + public async Task> GetUserPlaylistsAsync( + string? searchName = null, + CancellationToken cancellationToken = default) { var token = await GetWebAccessTokenAsync(cancellationToken); if (string.IsNullOrEmpty(token)) @@ -744,61 +767,204 @@ public class SpotifyApiClient : IDisposable try { + // Use GraphQL endpoint instead of REST API to avoid rate limiting + // GraphQL is less aggressive with rate limits var playlists = new List(); var offset = 0; const int limit = 50; while (true) { - var url = $"{OfficialApiBase}/me/playlists?offset={offset}&limit={limit}"; + // GraphQL query to fetch user playlists - using libraryV3 operation + var queryParams = new Dictionary + { + { "operationName", "libraryV3" }, + { "variables", $"{{\"filters\":[\"Playlists\",\"By Spotify\"],\"order\":null,\"textFilter\":\"\",\"features\":[\"LIKED_SONGS\",\"YOUR_EPISODES\"],\"offset\":{offset},\"limit\":{limit}}}" }, + { "extensions", "{\"persistedQuery\":{\"version\":1,\"sha256Hash\":\"50650f72ea32a99b5b46240bee22fea83024eec302478a9a75cfd05a0814ba99\"}}" } + }; + + var queryString = string.Join("&", queryParams.Select(kv => $"{Uri.EscapeDataString(kv.Key)}={Uri.EscapeDataString(kv.Value)}")); + var url = $"{WebApiBase}/query?{queryString}"; var request = new HttpRequestMessage(HttpMethod.Get, url); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token); - var response = await _httpClient.SendAsync(request, cancellationToken); - if (!response.IsSuccessStatusCode) break; + var response = await _webApiClient.SendAsync(request, cancellationToken); + + // Handle 429 rate limiting with exponential backoff + if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests) + { + var retryAfter = response.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(5); + _logger.LogWarning("Spotify rate limit hit (429) when fetching library playlists. Waiting {Seconds}s before retry...", retryAfter.TotalSeconds); + await Task.Delay(retryAfter, cancellationToken); + + // Retry the request + response = await _httpClient.SendAsync(request, cancellationToken); + } + + if (!response.IsSuccessStatusCode) + { + _logger.LogError("GraphQL user playlists request failed: {StatusCode}", response.StatusCode); + break; + } var json = await response.Content.ReadAsStringAsync(cancellationToken); using var doc = JsonDocument.Parse(json); var root = doc.RootElement; - if (!root.TryGetProperty("items", out var items) || items.GetArrayLength() == 0) + if (!root.TryGetProperty("data", out var data) || + !data.TryGetProperty("me", out var me) || + !me.TryGetProperty("libraryV3", out var library) || + !library.TryGetProperty("items", out var items)) + { break; + } + // Get total count + if (library.TryGetProperty("totalCount", out var totalCount)) + { + var total = totalCount.GetInt32(); + if (total == 0) break; + } + + var itemCount = 0; foreach (var item in items.EnumerateArray()) { - var itemName = item.TryGetProperty("name", out var n) ? n.GetString() ?? "" : ""; + itemCount++; - // Check if name matches (case-insensitive) - if (itemName.Contains(searchName, StringComparison.OrdinalIgnoreCase)) + if (!item.TryGetProperty("item", out var playlistItem) || + !playlistItem.TryGetProperty("data", out var playlist)) { - playlists.Add(new SpotifyPlaylist - { - SpotifyId = item.TryGetProperty("id", out var itemId) ? itemId.GetString() ?? "" : "", - Name = itemName, - Description = item.TryGetProperty("description", out var desc) ? desc.GetString() : null, - TotalTracks = item.TryGetProperty("tracks", out var tracks) && - tracks.TryGetProperty("total", out var total) - ? total.GetInt32() : 0, - SnapshotId = item.TryGetProperty("snapshot_id", out var snap) ? snap.GetString() : null - }); + continue; } + + // Check __typename to filter out folders and only include playlists + if (playlistItem.TryGetProperty("__typename", out var typename)) + { + var typeStr = typename.GetString(); + // Skip folders - only process Playlist types + if (typeStr != null && typeStr.Contains("Folder", StringComparison.OrdinalIgnoreCase)) + { + continue; + } + } + + // Get playlist URI/ID + string? uri = null; + if (playlistItem.TryGetProperty("uri", out var uriProp)) + { + uri = uriProp.GetString(); + } + else if (playlistItem.TryGetProperty("_uri", out var uriProp2)) + { + uri = uriProp2.GetString(); + } + + if (string.IsNullOrEmpty(uri)) continue; + + // Skip if not a playlist URI (e.g., folders have different URI format) + if (!uri.StartsWith("spotify:playlist:", StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + var spotifyId = uri.Replace("spotify:playlist:", "", StringComparison.OrdinalIgnoreCase); + + var itemName = playlist.TryGetProperty("name", out var n) ? n.GetString() ?? "" : ""; + + // Check if name matches (case-insensitive) - if searchName is provided + if (!string.IsNullOrEmpty(searchName) && + !itemName.Contains(searchName, StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + // Get track count if available - try multiple possible paths + var trackCount = 0; + if (playlist.TryGetProperty("content", out var content)) + { + if (content.TryGetProperty("totalCount", out var totalTrackCount)) + { + trackCount = totalTrackCount.GetInt32(); + } + } + // Fallback: try attributes.itemCount + else if (playlist.TryGetProperty("attributes", out var attributes) && + attributes.TryGetProperty("itemCount", out var itemCountProp)) + { + trackCount = itemCountProp.GetInt32(); + } + // Fallback: try totalCount directly + else if (playlist.TryGetProperty("totalCount", out var directTotalCount)) + { + trackCount = directTotalCount.GetInt32(); + } + + // Log if we couldn't find track count for debugging + if (trackCount == 0) + { + _logger.LogDebug("Could not find track count for playlist {Name} (ID: {Id}). Response structure: {Json}", + itemName, spotifyId, playlist.GetRawText()); + } + + // Get owner name + string? ownerName = null; + if (playlist.TryGetProperty("ownerV2", out var ownerV2) && + ownerV2.TryGetProperty("data", out var ownerData) && + ownerData.TryGetProperty("username", out var ownerNameProp)) + { + ownerName = ownerNameProp.GetString(); + } + + // Get image URL + string? imageUrl = null; + if (playlist.TryGetProperty("images", out var images) && + images.TryGetProperty("items", out var imageItems) && + imageItems.GetArrayLength() > 0) + { + var firstImage = imageItems[0]; + if (firstImage.TryGetProperty("sources", out var sources) && + sources.GetArrayLength() > 0) + { + var firstSource = sources[0]; + if (firstSource.TryGetProperty("url", out var urlProp)) + { + imageUrl = urlProp.GetString(); + } + } + } + + playlists.Add(new SpotifyPlaylist + { + SpotifyId = spotifyId, + Name = itemName, + Description = playlist.TryGetProperty("description", out var desc) ? desc.GetString() : null, + TotalTracks = trackCount, + OwnerName = ownerName, + ImageUrl = imageUrl, + SnapshotId = null + }); } - if (items.GetArrayLength() < limit) break; + if (itemCount < limit) break; offset += limit; - if (_settings.RateLimitDelayMs > 0) - { - await Task.Delay(_settings.RateLimitDelayMs, cancellationToken); - } + // Add delay between pages to avoid rate limiting + // Library fetching can be aggressive, so use a longer delay + var delayMs = Math.Max(_settings.RateLimitDelayMs, 500); // Minimum 500ms between pages + _logger.LogDebug("Waiting {DelayMs}ms before fetching next page of library playlists...", delayMs); + await Task.Delay(delayMs, cancellationToken); } + _logger.LogDebug("Found {Count} playlists{Filter} via GraphQL", + playlists.Count, + string.IsNullOrEmpty(searchName) ? "" : $" matching '{searchName}'"); return playlists; } catch (Exception ex) { - _logger.LogError(ex, "Error searching user playlists for '{SearchName}'", searchName); + _logger.LogError(ex, "Error fetching user playlists{Filter} via GraphQL", + string.IsNullOrEmpty(searchName) ? "" : $" matching '{searchName}'"); return new List(); } } diff --git a/allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs b/allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs index ef4d785..2638e3e 100644 --- a/allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs +++ b/allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs @@ -60,7 +60,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (_spotifyApiSettings.Value.Enabled && !string.IsNullOrEmpty(_spotifyApiSettings.Value.SessionCookie)) { _logger.LogInformation("SpotifyApi is enabled with session cookie - using direct Spotify API instead of Jellyfin scraping"); - _logger.LogInformation("This service will remain dormant. SpotifyPlaylistFetcher is handling playlists."); + _logger.LogDebug("This service will remain dormant. SpotifyPlaylistFetcher is handling playlists."); _logger.LogInformation("========================================"); return; } @@ -77,7 +77,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (string.IsNullOrEmpty(jellyfinUrl) || string.IsNullOrEmpty(apiKey)) { - _logger.LogWarning("Jellyfin URL or API key not configured, Spotify playlist injection disabled"); + _logger.LogInformation("Jellyfin URL or API key not configured, Spotify playlist injection disabled"); _logger.LogInformation("========================================"); return; } @@ -115,7 +115,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService } else { - _logger.LogInformation("Skipping startup fetch - already have cached files"); + _logger.LogWarning("Skipping startup fetch - already have cached files"); _hasRunOnce = true; } } @@ -194,7 +194,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (File.Exists(filePath)) { var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath); - _logger.LogInformation(" {Playlist}: Found file cache (age: {Age:F1}h)", playlistName, fileAge.TotalHours); + _logger.LogDebug(" {Playlist}: Found file cache (age: {Age:F1}h)", playlistName, fileAge.TotalHours); // Load into Redis if not already there if (!await _cache.ExistsAsync(cacheKey)) @@ -207,7 +207,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService // Check Redis cache if (await _cache.ExistsAsync(cacheKey)) { - _logger.LogInformation(" {Playlist}: Found in Redis cache", playlistName); + _logger.LogDebug(" {Playlist}: Found in Redis cache", playlistName); continue; } @@ -218,7 +218,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (allPlaylistsHaveCache) { - _logger.LogInformation("=== ALL PLAYLISTS HAVE CACHE - SKIPPING STARTUP FETCH ==="); + _logger.LogWarning("=== ALL PLAYLISTS HAVE CACHE - SKIPPING STARTUP FETCH ==="); return false; } @@ -250,13 +250,13 @@ public class SpotifyMissingTracksFetcher : BackgroundService // No expiration - cache persists until next Jellyfin job generates new file await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromDays(365)); - _logger.LogInformation("Loaded {Count} tracks from file cache for {Playlist} (age: {Age:F1}h, no expiration)", + _logger.LogDebug("Loaded {Count} tracks from file cache for {Playlist} (age: {Age:F1}h, no expiration)", tracks.Count, playlistName, fileAge.TotalHours); } } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to load file cache for {Playlist}", playlistName); + _logger.LogError(ex, "Failed to load file cache for {Playlist}", playlistName); } } @@ -267,7 +267,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService var filePath = GetCacheFilePath(playlistName); var json = JsonSerializer.Serialize(tracks, new JsonSerializerOptions { WriteIndented = true }); await File.WriteAllTextAsync(filePath, json); - _logger.LogInformation("Saved {Count} tracks to file cache for {Playlist}", + _logger.LogDebug("Saved {Count} tracks to file cache for {Playlist}", tracks.Count, playlistName); } catch (Exception ex) @@ -279,7 +279,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService private async Task FetchMissingTracksAsync(CancellationToken cancellationToken) { _logger.LogInformation("=== FETCHING MISSING TRACKS ==="); - _logger.LogInformation("Processing {Count} playlists", _playlistIdToName.Count); + _logger.LogDebug("Processing {Count} playlists", _playlistIdToName.Count); // Track when we find files to optimize search for other playlists DateTime? firstFoundTime = null; @@ -324,11 +324,11 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (existingTracks != null && existingTracks.Count > 0) { - _logger.LogInformation(" Current cache has {Count} tracks, will search for newer file", existingTracks.Count); + _logger.LogDebug(" Current cache has {Count} tracks, will search for newer file", existingTracks.Count); } else { - _logger.LogInformation(" No existing cache, will search for missing tracks file"); + _logger.LogDebug(" No existing cache, will search for missing tracks file"); } var settings = _spotifySettings.Value; @@ -428,7 +428,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService // Keep the existing cache - don't let it expire if (existingTracks != null && existingTracks.Count > 0) { - _logger.LogInformation(" ✓ Keeping existing cache with {Count} tracks (no expiration)", existingTracks.Count); + _logger.LogDebug(" ✓ Keeping existing cache with {Count} tracks (no expiration)", existingTracks.Count); // Re-save with no expiration to ensure it persists await _cache.SetAsync(cacheKey, existingTracks, TimeSpan.FromDays(365)); // Effectively no expiration } @@ -444,7 +444,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService if (tracks != null && tracks.Count > 0) { await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromDays(365)); // No expiration - _logger.LogInformation(" ✓ Loaded {Count} tracks from file cache (no expiration)", tracks.Count); + _logger.LogDebug(" ✓ Loaded {Count} tracks from file cache (no expiration)", tracks.Count); } } catch (Exception ex) @@ -476,7 +476,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService try { // Log every request with the actual filename - _logger.LogInformation("Checking: {Playlist} at {DateTime}", playlistName, time.ToString("yyyy-MM-dd HH:mm")); + _logger.LogDebug("Checking: {Playlist} at {DateTime}", playlistName, time.ToString("yyyy-MM-dd HH:mm")); var response = await httpClient.GetAsync(url, cancellationToken); if (response.IsSuccessStatusCode) @@ -502,7 +502,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to fetch {Filename}", filename); + _logger.LogError(ex, "Failed to fetch {Filename}", filename); } return (false, null); diff --git a/allstarr/Services/Spotify/SpotifyPlaylistFetcher.cs b/allstarr/Services/Spotify/SpotifyPlaylistFetcher.cs index aefb1a2..a846a09 100644 --- a/allstarr/Services/Spotify/SpotifyPlaylistFetcher.cs +++ b/allstarr/Services/Spotify/SpotifyPlaylistFetcher.cs @@ -3,6 +3,7 @@ using allstarr.Models.Spotify; using allstarr.Services.Common; using Microsoft.Extensions.Options; using System.Text.Json; +using Cronos; namespace allstarr.Services.Spotify; @@ -14,6 +15,9 @@ namespace allstarr.Services.Spotify; /// - ISRC codes available for exact matching /// - Real-time data without waiting for plugin sync schedules /// - Full track metadata (duration, release date, etc.) +/// +/// CRON SCHEDULING: Playlists are fetched based on their cron schedules, not a global interval. +/// Cache persists until next cron run to prevent excess Spotify API calls. /// public class SpotifyPlaylistFetcher : BackgroundService { @@ -23,7 +27,6 @@ public class SpotifyPlaylistFetcher : BackgroundService private readonly SpotifyApiClient _spotifyClient; private readonly RedisCacheService _cache; - private const string CacheDirectory = "/app/cache/spotify"; private const string CacheKeyPrefix = "spotify:playlist:"; // Track Spotify playlist IDs after discovery @@ -45,6 +48,7 @@ public class SpotifyPlaylistFetcher : BackgroundService /// /// Gets the Spotify playlist tracks in order, using cache if available. + /// Cache persists until next cron run to prevent excess API calls. /// /// Playlist name (e.g., "Release Radar", "Discover Weekly") /// List of tracks in playlist order, or empty list if not found @@ -57,7 +61,38 @@ public class SpotifyPlaylistFetcher : BackgroundService if (cached != null && cached.Tracks.Count > 0) { var age = DateTime.UtcNow - cached.FetchedAt; - if (age.TotalMinutes < _spotifyApiSettings.CacheDurationMinutes) + + // Calculate if cache should still be valid based on cron schedule + var playlistConfig = _spotifyImportSettings.GetPlaylistByName(playlistName); + var shouldRefresh = false; + + if (playlistConfig != null && !string.IsNullOrEmpty(playlistConfig.SyncSchedule)) + { + try + { + var cron = CronExpression.Parse(playlistConfig.SyncSchedule); + var nextRun = cron.GetNextOccurrence(cached.FetchedAt, TimeZoneInfo.Utc); + + if (nextRun.HasValue && DateTime.UtcNow >= nextRun.Value) + { + shouldRefresh = true; + _logger.LogWarning("Cache expired for '{Name}' - next cron run was at {NextRun} UTC", + playlistName, nextRun.Value); + } + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Could not parse cron schedule for '{Name}', falling back to cache duration", playlistName); + shouldRefresh = age.TotalMinutes >= _spotifyApiSettings.CacheDurationMinutes; + } + } + else + { + // No cron schedule, use cache duration from settings + shouldRefresh = age.TotalMinutes >= _spotifyApiSettings.CacheDurationMinutes; + } + + if (!shouldRefresh) { _logger.LogDebug("Using cached playlist '{Name}' ({Count} tracks, age: {Age:F1}m)", playlistName, cached.Tracks.Count, age.TotalMinutes); @@ -65,47 +100,23 @@ public class SpotifyPlaylistFetcher : BackgroundService } } - // Try file cache - var filePath = GetCacheFilePath(playlistName); - if (File.Exists(filePath)) - { - try - { - var json = await File.ReadAllTextAsync(filePath); - var filePlaylist = JsonSerializer.Deserialize(json); - if (filePlaylist != null && filePlaylist.Tracks.Count > 0) - { - var age = DateTime.UtcNow - filePlaylist.FetchedAt; - if (age.TotalMinutes < _spotifyApiSettings.CacheDurationMinutes) - { - _logger.LogDebug("Using file-cached playlist '{Name}' ({Count} tracks)", - playlistName, filePlaylist.Tracks.Count); - return filePlaylist.Tracks; - } - } - } - catch (Exception ex) - { - _logger.LogWarning(ex, "Failed to read file cache for '{Name}'", playlistName); - } - } - - // Need to fetch fresh - try to use cached or configured Spotify playlist ID + // Cache miss or expired - need to fetch fresh from Spotify + // Try to use cached or configured Spotify playlist ID if (!_playlistNameToSpotifyId.TryGetValue(playlistName, out var spotifyId)) { // Check if we have a configured Spotify ID for this playlist - var playlistConfig = _spotifyImportSettings.GetPlaylistByName(playlistName); - if (playlistConfig != null && !string.IsNullOrEmpty(playlistConfig.Id)) + var config = _spotifyImportSettings.GetPlaylistByName(playlistName); + if (config != null && !string.IsNullOrEmpty(config.Id)) { // Use the configured Spotify playlist ID directly - spotifyId = playlistConfig.Id; + spotifyId = config.Id; _playlistNameToSpotifyId[playlistName] = spotifyId; _logger.LogInformation("Using configured Spotify playlist ID for '{Name}': {Id}", playlistName, spotifyId); } else { // No configured ID, try searching by name (works for public/followed playlists) - _logger.LogDebug("No configured Spotify ID for '{Name}', searching...", playlistName); + _logger.LogInformation("No configured Spotify ID for '{Name}', searching...", playlistName); var playlists = await _spotifyClient.SearchUserPlaylistsAsync(playlistName); var exactMatch = playlists.FirstOrDefault(p => @@ -113,21 +124,8 @@ public class SpotifyPlaylistFetcher : BackgroundService if (exactMatch == null) { - _logger.LogWarning("Could not find Spotify playlist named '{Name}' - try configuring the Spotify playlist ID", playlistName); - - // Return file cache even if expired, as a fallback - if (File.Exists(filePath)) - { - var json = await File.ReadAllTextAsync(filePath); - var fallback = JsonSerializer.Deserialize(json); - if (fallback != null) - { - _logger.LogWarning("Using expired file cache as fallback for '{Name}'", playlistName); - return fallback.Tracks; - } - } - - return new List(); + _logger.LogInformation("Could not find Spotify playlist named '{Name}' - try configuring the Spotify playlist ID", playlistName); + return cached?.Tracks ?? new List(); } spotifyId = exactMatch.SpotifyId; @@ -140,16 +138,42 @@ public class SpotifyPlaylistFetcher : BackgroundService var playlist = await _spotifyClient.GetPlaylistAsync(spotifyId); if (playlist == null || playlist.Tracks.Count == 0) { - _logger.LogWarning("Failed to fetch playlist '{Name}' from Spotify", playlistName); + _logger.LogError("Failed to fetch playlist '{Name}' from Spotify", playlistName); return cached?.Tracks ?? new List(); } - // Update cache - await _cache.SetAsync(cacheKey, playlist, TimeSpan.FromMinutes(_spotifyApiSettings.CacheDurationMinutes * 2)); - await SaveToFileCacheAsync(playlistName, playlist); + // Calculate cache expiration based on cron schedule + var playlistCfg = _spotifyImportSettings.GetPlaylistByName(playlistName); + var cacheExpiration = TimeSpan.FromMinutes(_spotifyApiSettings.CacheDurationMinutes * 2); // Default - _logger.LogInformation("Fetched and cached playlist '{Name}' with {Count} tracks in order", - playlistName, playlist.Tracks.Count); + if (playlistCfg != null && !string.IsNullOrEmpty(playlistCfg.SyncSchedule)) + { + try + { + var cron = CronExpression.Parse(playlistCfg.SyncSchedule); + var nextRun = cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc); + + if (nextRun.HasValue) + { + var timeUntilNextRun = nextRun.Value - DateTime.UtcNow; + // Add 5 minutes buffer + cacheExpiration = timeUntilNextRun + TimeSpan.FromMinutes(5); + + _logger.LogInformation("Playlist '{Name}' cache will persist until next cron run: {NextRun} UTC (in {Hours:F1}h)", + playlistName, nextRun.Value, timeUntilNextRun.TotalHours); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Could not calculate next cron run for '{Name}', using default cache duration", playlistName); + } + } + + // Update Redis cache with cron-based expiration + await _cache.SetAsync(cacheKey, playlist, cacheExpiration); + + _logger.LogInformation("Fetched and cached playlist '{Name}' with {Count} tracks (expires in {Hours:F1}h)", + playlistName, playlist.Tracks.Count, cacheExpiration.TotalHours); return playlist.Tracks; } @@ -206,9 +230,6 @@ public class SpotifyPlaylistFetcher : BackgroundService _logger.LogInformation("========================================"); _logger.LogInformation("SpotifyPlaylistFetcher: Starting up..."); - // Ensure cache directory exists - Directory.CreateDirectory(CacheDirectory); - if (!_spotifyApiSettings.Enabled) { _logger.LogInformation("Spotify API integration is DISABLED"); @@ -218,13 +239,13 @@ public class SpotifyPlaylistFetcher : BackgroundService if (string.IsNullOrEmpty(_spotifyApiSettings.SessionCookie)) { - _logger.LogWarning("Spotify session cookie not configured - cannot access editorial playlists"); + _logger.LogError("Spotify session cookie not configured - cannot access editorial playlists"); _logger.LogInformation("========================================"); return; } // Verify we can get an access token (the most reliable auth check) - _logger.LogInformation("Attempting Spotify authentication..."); + _logger.LogDebug("Attempting Spotify authentication..."); var token = await _spotifyClient.GetWebAccessTokenAsync(stoppingToken); if (string.IsNullOrEmpty(token)) { @@ -235,32 +256,99 @@ public class SpotifyPlaylistFetcher : BackgroundService _logger.LogInformation("Spotify API ENABLED"); _logger.LogInformation("Authenticated via sp_dc session cookie"); - _logger.LogInformation("Cache duration: {Minutes} minutes", _spotifyApiSettings.CacheDurationMinutes); _logger.LogInformation("ISRC matching: {Enabled}", _spotifyApiSettings.PreferIsrcMatching ? "enabled" : "disabled"); _logger.LogInformation("Configured Playlists: {Count}", _spotifyImportSettings.Playlists.Count); foreach (var playlist in _spotifyImportSettings.Playlists) { - _logger.LogInformation(" - {Name}", playlist.Name); + var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * 1" : playlist.SyncSchedule; + _logger.LogInformation(" - {Name}: {Schedule}", playlist.Name, schedule); } _logger.LogInformation("========================================"); - // Initial fetch of all playlists - await FetchAllPlaylistsAsync(stoppingToken); - - // Periodic refresh loop + // Cron-based refresh loop - only fetch when cron schedule triggers + // This prevents excess Spotify API calls while (!stoppingToken.IsCancellationRequested) { - await Task.Delay(TimeSpan.FromMinutes(_spotifyApiSettings.CacheDurationMinutes), stoppingToken); - try { - await FetchAllPlaylistsAsync(stoppingToken); + // Check each playlist to see if it needs refreshing based on cron schedule + var now = DateTime.UtcNow; + var needsRefresh = new List(); + + foreach (var config in _spotifyImportSettings.Playlists) + { + var schedule = string.IsNullOrEmpty(config.SyncSchedule) ? "0 8 * * 1" : config.SyncSchedule; + + try + { + var cron = CronExpression.Parse(schedule); + + // Check if we have cached data + var cacheKey = $"{CacheKeyPrefix}{config.Name}"; + var cached = await _cache.GetAsync(cacheKey); + + if (cached != null) + { + // Calculate when the next run should be after the last fetch + var nextRun = cron.GetNextOccurrence(cached.FetchedAt, TimeZoneInfo.Utc); + + if (nextRun.HasValue && now >= nextRun.Value) + { + needsRefresh.Add(config.Name); + _logger.LogInformation("Playlist '{Name}' needs refresh - last fetched {Age:F1}h ago, next run was {NextRun}", + config.Name, (now - cached.FetchedAt).TotalHours, nextRun.Value); + } + } + else + { + // No cache, fetch it + needsRefresh.Add(config.Name); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Invalid cron schedule for playlist {Name}: {Schedule}", config.Name, schedule); + } + } + + // Fetch playlists that need refreshing + if (needsRefresh.Count > 0) + { + _logger.LogInformation("=== CRON TRIGGER: Fetching {Count} playlists ===", needsRefresh.Count); + + foreach (var playlistName in needsRefresh) + { + if (stoppingToken.IsCancellationRequested) break; + + try + { + await GetPlaylistTracksAsync(playlistName); + + // Rate limiting between playlists + if (playlistName != needsRefresh.Last()) + { + _logger.LogWarning("Finished fetching '{Name}' - waiting 3 seconds before next playlist to avoid rate limits...", playlistName); + await Task.Delay(TimeSpan.FromSeconds(3), stoppingToken); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Error fetching playlist '{Name}'", playlistName); + } + } + + _logger.LogInformation("=== FINISHED FETCHING PLAYLISTS ==="); + } + + // Sleep for 1 hour before checking again + await Task.Delay(TimeSpan.FromHours(1), stoppingToken); } catch (Exception ex) { - _logger.LogError(ex, "Error during periodic playlist refresh"); + _logger.LogError(ex, "Error in playlist fetcher loop"); + await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken); } } } @@ -276,7 +364,7 @@ public class SpotifyPlaylistFetcher : BackgroundService try { var tracks = await GetPlaylistTracksAsync(config.Name); - _logger.LogInformation(" {Name}: {Count} tracks", config.Name, tracks.Count); + _logger.LogDebug(" {Name}: {Count} tracks", config.Name, tracks.Count); // Log sample of track order for debugging if (tracks.Count > 0) @@ -301,36 +389,11 @@ public class SpotifyPlaylistFetcher : BackgroundService // Wait 3 seconds between each playlist to avoid 429 TooManyRequests errors if (config != _spotifyImportSettings.Playlists.Last()) { - _logger.LogDebug("Waiting 3 seconds before next playlist to avoid rate limits..."); + _logger.LogWarning("Finished fetching '{Name}' - waiting 3 seconds before next playlist to avoid rate limits...", config.Name); await Task.Delay(TimeSpan.FromSeconds(3), cancellationToken); } } _logger.LogInformation("=== FINISHED FETCHING SPOTIFY PLAYLISTS ==="); } - - private string GetCacheFilePath(string playlistName) - { - var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars())); - return Path.Combine(CacheDirectory, $"{safeName}_spotify.json"); - } - - private async Task SaveToFileCacheAsync(string playlistName, SpotifyPlaylist playlist) - { - try - { - var filePath = GetCacheFilePath(playlistName); - var json = JsonSerializer.Serialize(playlist, new JsonSerializerOptions - { - WriteIndented = true, - PropertyNamingPolicy = JsonNamingPolicy.CamelCase - }); - await File.WriteAllTextAsync(filePath, json); - _logger.LogDebug("Saved playlist '{Name}' to file cache", playlistName); - } - catch (Exception ex) - { - _logger.LogWarning(ex, "Failed to save file cache for '{Name}'", playlistName); - } - } } diff --git a/allstarr/Services/Spotify/SpotifyTrackMatchingService.cs b/allstarr/Services/Spotify/SpotifyTrackMatchingService.cs index 793a5f8..e5ef606 100644 --- a/allstarr/Services/Spotify/SpotifyTrackMatchingService.cs +++ b/allstarr/Services/Spotify/SpotifyTrackMatchingService.cs @@ -6,6 +6,7 @@ using allstarr.Services.Jellyfin; using Microsoft.AspNetCore.Http; using Microsoft.Extensions.Options; using System.Text.Json; +using Cronos; namespace allstarr.Services.Spotify; @@ -17,6 +18,9 @@ namespace allstarr.Services.Spotify; /// 2. Direct API mode: Uses SpotifyPlaylistTrack (with ISRC and ordering) /// /// When ISRC is available, exact matching is preferred. Falls back to fuzzy matching. +/// +/// CRON SCHEDULING: Each playlist has its own cron schedule. Matching only runs when the schedule triggers. +/// Manual refresh is always allowed. Cache persists until next cron run. /// public class SpotifyTrackMatchingService : BackgroundService { @@ -27,8 +31,10 @@ public class SpotifyTrackMatchingService : BackgroundService private readonly IServiceProvider _serviceProvider; private const int DelayBetweenSearchesMs = 150; // 150ms = ~6.6 searches/second to avoid rate limiting private const int BatchSize = 11; // Number of parallel searches (matches SquidWTF provider count) - private DateTime _lastMatchingRun = DateTime.MinValue; - private readonly TimeSpan _minimumMatchingInterval = TimeSpan.FromMinutes(5); // Don't run more than once per 5 minutes + + // Track last run time per playlist to prevent duplicate runs + private readonly Dictionary _lastRunTimes = new(); + private readonly TimeSpan _minimumRunInterval = TimeSpan.FromMinutes(5); // Cooldown between runs public SpotifyTrackMatchingService( IOptions spotifySettings, @@ -57,17 +63,29 @@ public class SpotifyTrackMatchingService : BackgroundService protected override async Task ExecuteAsync(CancellationToken stoppingToken) { + _logger.LogInformation("========================================"); _logger.LogInformation("SpotifyTrackMatchingService: Starting up..."); if (!_spotifySettings.Enabled) { _logger.LogInformation("Spotify playlist injection is DISABLED, matching service will not run"); + _logger.LogInformation("========================================"); return; } var matchMode = _spotifyApiSettings.Enabled && _spotifyApiSettings.PreferIsrcMatching ? "ISRC-preferred" : "fuzzy"; _logger.LogInformation("Matching mode: {Mode}", matchMode); + _logger.LogInformation("Cron-based scheduling: Each playlist has independent schedule"); + + // Log all playlist schedules + foreach (var playlist in _spotifySettings.Playlists) + { + var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * 1" : playlist.SyncSchedule; + _logger.LogInformation(" - {Name}: {Schedule}", playlist.Name, schedule); + } + + _logger.LogInformation("========================================"); // Wait a bit for the fetcher to run first await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken); @@ -75,7 +93,7 @@ public class SpotifyTrackMatchingService : BackgroundService // Run once on startup to match any existing missing tracks try { - _logger.LogInformation("Running initial track matching on startup"); + _logger.LogInformation("Running initial track matching on startup (one-time)"); await MatchAllPlaylistsAsync(stoppingToken); } catch (Exception ex) @@ -83,52 +101,106 @@ public class SpotifyTrackMatchingService : BackgroundService _logger.LogError(ex, "Error during startup track matching"); } - // Now start the periodic matching loop + // Now start the cron-based scheduling loop while (!stoppingToken.IsCancellationRequested) { - // Wait for configured interval before next run (default 24 hours) - var intervalHours = _spotifySettings.MatchingIntervalHours; - if (intervalHours <= 0) - { - _logger.LogInformation("Periodic matching disabled (MatchingIntervalHours = {Hours}), only startup run will execute", intervalHours); - break; // Exit loop - only run once on startup - } - - await Task.Delay(TimeSpan.FromHours(intervalHours), stoppingToken); - try { - await MatchAllPlaylistsAsync(stoppingToken); + // Calculate next run time for each playlist + var now = DateTime.UtcNow; + var nextRuns = new List<(string PlaylistName, DateTime NextRun, CronExpression Cron)>(); + + foreach (var playlist in _spotifySettings.Playlists) + { + var schedule = string.IsNullOrEmpty(playlist.SyncSchedule) ? "0 8 * * 1" : playlist.SyncSchedule; + + try + { + var cron = CronExpression.Parse(schedule); + var nextRun = cron.GetNextOccurrence(now, TimeZoneInfo.Utc); + + if (nextRun.HasValue) + { + nextRuns.Add((playlist.Name, nextRun.Value, cron)); + } + else + { + _logger.LogWarning("Could not calculate next run for playlist {Name} with schedule {Schedule}", + playlist.Name, schedule); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Invalid cron schedule for playlist {Name}: {Schedule}", + playlist.Name, schedule); + } + } + + if (nextRuns.Count == 0) + { + _logger.LogWarning("No valid cron schedules found, sleeping for 1 hour"); + await Task.Delay(TimeSpan.FromHours(1), stoppingToken); + continue; + } + + // Find the next playlist that needs to run + var nextPlaylist = nextRuns.OrderBy(x => x.NextRun).First(); + var waitTime = nextPlaylist.NextRun - now; + + if (waitTime.TotalSeconds > 0) + { + _logger.LogInformation("Next scheduled run: {Playlist} at {Time} UTC (in {Minutes:F1} minutes)", + nextPlaylist.PlaylistName, nextPlaylist.NextRun, waitTime.TotalMinutes); + + // Wait until next run (or max 1 hour to re-check schedules) + var maxWait = TimeSpan.FromHours(1); + var actualWait = waitTime > maxWait ? maxWait : waitTime; + await Task.Delay(actualWait, stoppingToken); + continue; + } + + // Time to run this playlist + _logger.LogInformation("=== CRON TRIGGER: Running scheduled match for {Playlist} ===", nextPlaylist.PlaylistName); + + // Check cooldown to prevent duplicate runs + if (_lastRunTimes.TryGetValue(nextPlaylist.PlaylistName, out var lastRun)) + { + var timeSinceLastRun = now - lastRun; + if (timeSinceLastRun < _minimumRunInterval) + { + _logger.LogWarning("Skipping {Playlist} - last run was {Seconds}s ago (cooldown: {Cooldown}s)", + nextPlaylist.PlaylistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds); + await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken); + continue; + } + } + + // Run matching for this playlist + await MatchSinglePlaylistAsync(nextPlaylist.PlaylistName, stoppingToken); + _lastRunTimes[nextPlaylist.PlaylistName] = DateTime.UtcNow; + + _logger.LogInformation("=== FINISHED: {Playlist} - Next run at {NextRun} UTC ===", + nextPlaylist.PlaylistName, nextPlaylist.Cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc)); } catch (Exception ex) { - _logger.LogError(ex, "Error in track matching service"); + _logger.LogError(ex, "Error in cron scheduling loop"); + await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken); } } } - - /// - /// Public method to trigger matching manually for all playlists (called from controller). - /// - public async Task TriggerMatchingAsync() - { - _logger.LogInformation("Manual track matching triggered for all playlists"); - await MatchAllPlaylistsAsync(CancellationToken.None); - } /// - /// Public method to trigger matching for a specific playlist (called from controller). + /// Matches tracks for a single playlist (called by cron scheduler or manual trigger). /// - public async Task TriggerMatchingForPlaylistAsync(string playlistName) + private async Task MatchSinglePlaylistAsync(string playlistName, CancellationToken cancellationToken) { - _logger.LogInformation("Manual track matching triggered for playlist: {Playlist}", playlistName); - var playlist = _spotifySettings.Playlists .FirstOrDefault(p => p.Name.Equals(playlistName, StringComparison.OrdinalIgnoreCase)); if (playlist == null) { - _logger.LogWarning("Playlist {Playlist} not found in configuration", playlistName); + _logger.LogInformation("Playlist {Playlist} not found in configuration", playlistName); return; } @@ -148,13 +220,13 @@ public class SpotifyTrackMatchingService : BackgroundService { // Use new direct API mode with ISRC support await MatchPlaylistTracksWithIsrcAsync( - playlist.Name, playlistFetcher, metadataService, CancellationToken.None); + playlist.Name, playlistFetcher, metadataService, cancellationToken); } else { // Fall back to legacy mode await MatchPlaylistTracksLegacyAsync( - playlist.Name, metadataService, CancellationToken.None); + playlist.Name, metadataService, cancellationToken); } } catch (Exception ex) @@ -164,19 +236,43 @@ public class SpotifyTrackMatchingService : BackgroundService } } - private async Task MatchAllPlaylistsAsync(CancellationToken cancellationToken) + /// + /// Public method to trigger matching manually for all playlists (called from controller). + /// This bypasses cron schedules and runs immediately. + /// + public async Task TriggerMatchingAsync() { - // Check if we've run too recently (cooldown period) - var timeSinceLastRun = DateTime.UtcNow - _lastMatchingRun; - if (timeSinceLastRun < _minimumMatchingInterval) + _logger.LogInformation("Manual track matching triggered for all playlists (bypassing cron schedules)"); + await MatchAllPlaylistsAsync(CancellationToken.None); + } + + /// + /// Public method to trigger matching for a specific playlist (called from controller). + /// This bypasses cron schedules and runs immediately. + /// + public async Task TriggerMatchingForPlaylistAsync(string playlistName) + { + _logger.LogInformation("Manual track matching triggered for playlist: {Playlist} (bypassing cron schedule)", playlistName); + + // Check cooldown to prevent abuse + if (_lastRunTimes.TryGetValue(playlistName, out var lastRun)) { - _logger.LogInformation("Skipping track matching - last run was {Seconds}s ago (minimum interval: {MinSeconds}s)", - (int)timeSinceLastRun.TotalSeconds, (int)_minimumMatchingInterval.TotalSeconds); - return; + var timeSinceLastRun = DateTime.UtcNow - lastRun; + if (timeSinceLastRun < _minimumRunInterval) + { + _logger.LogWarning("Skipping manual refresh for {Playlist} - last run was {Seconds}s ago (cooldown: {Cooldown}s)", + playlistName, (int)timeSinceLastRun.TotalSeconds, (int)_minimumRunInterval.TotalSeconds); + throw new InvalidOperationException($"Please wait {(int)(_minimumRunInterval - timeSinceLastRun).TotalSeconds} more seconds before refreshing again"); + } } - _logger.LogInformation("=== STARTING TRACK MATCHING ==="); - _lastMatchingRun = DateTime.UtcNow; + await MatchSinglePlaylistAsync(playlistName, CancellationToken.None); + _lastRunTimes[playlistName] = DateTime.UtcNow; + } + + private async Task MatchAllPlaylistsAsync(CancellationToken cancellationToken) + { + _logger.LogInformation("=== STARTING TRACK MATCHING FOR ALL PLAYLISTS ==="); var playlists = _spotifySettings.Playlists; if (playlists.Count == 0) @@ -185,34 +281,13 @@ public class SpotifyTrackMatchingService : BackgroundService return; } - using var scope = _serviceProvider.CreateScope(); - var metadataService = scope.ServiceProvider.GetRequiredService(); - - // Check if we should use the new SpotifyPlaylistFetcher - SpotifyPlaylistFetcher? playlistFetcher = null; - if (_spotifyApiSettings.Enabled) - { - playlistFetcher = scope.ServiceProvider.GetService(); - } - foreach (var playlist in playlists) { if (cancellationToken.IsCancellationRequested) break; try { - if (playlistFetcher != null) - { - // Use new direct API mode with ISRC support - await MatchPlaylistTracksWithIsrcAsync( - playlist.Name, playlistFetcher, metadataService, cancellationToken); - } - else - { - // Fall back to legacy mode - await MatchPlaylistTracksLegacyAsync( - playlist.Name, metadataService, cancellationToken); - } + await MatchSinglePlaylistAsync(playlist.Name, cancellationToken); } catch (Exception ex) { @@ -220,7 +295,7 @@ public class SpotifyTrackMatchingService : BackgroundService } } - _logger.LogInformation("=== FINISHED TRACK MATCHING ==="); + _logger.LogInformation("=== FINISHED TRACK MATCHING FOR ALL PLAYLISTS ==="); } /// @@ -241,7 +316,7 @@ public class SpotifyTrackMatchingService : BackgroundService var spotifyTracks = await playlistFetcher.GetPlaylistTracksAsync(playlistName); if (spotifyTracks.Count == 0) { - _logger.LogInformation("No tracks found for {Playlist}, skipping matching", playlistName); + _logger.LogWarning("No tracks found for {Playlist}, skipping matching", playlistName); return; } @@ -272,7 +347,7 @@ public class SpotifyTrackMatchingService : BackgroundService } else { - _logger.LogWarning("No UserId configured - may not be able to fetch existing playlist tracks for {Playlist}", playlistName); + _logger.LogInformation("No UserId configured - may not be able to fetch existing playlist tracks for {Playlist}", playlistName); } var (existingTracksResponse, _) = await proxyService.GetJsonAsyncInternal( @@ -304,7 +379,7 @@ public class SpotifyTrackMatchingService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Could not fetch existing Jellyfin tracks for {Playlist}, will match all tracks", playlistName); + _logger.LogError(ex, "Could not fetch existing Jellyfin tracks for {Playlist}, will match all tracks", playlistName); } } } @@ -316,12 +391,12 @@ public class SpotifyTrackMatchingService : BackgroundService if (tracksToMatch.Count == 0) { - _logger.LogInformation("All {Count} tracks for {Playlist} already exist in Jellyfin, skipping matching", + _logger.LogWarning("All {Count} tracks for {Playlist} already exist in Jellyfin, skipping matching", spotifyTracks.Count, playlistName); return; } - _logger.LogInformation("Matching {ToMatch}/{Total} tracks for {Playlist} (skipping {Existing} already in Jellyfin, ISRC: {IsrcEnabled}, AGGRESSIVE MODE)", + _logger.LogWarning("Matching {ToMatch}/{Total} tracks for {Playlist} (skipping {Existing} already in Jellyfin, ISRC: {IsrcEnabled}, AGGRESSIVE MODE)", tracksToMatch.Count, spotifyTracks.Count, playlistName, existingSpotifyIds.Count, _spotifyApiSettings.PreferIsrcMatching); // Check cache - use snapshot/timestamp to detect changes @@ -355,7 +430,7 @@ public class SpotifyTrackMatchingService : BackgroundService if (!hasNewManualMappings) { - _logger.LogInformation("✓ Playlist {Playlist} already has {Count} matched tracks cached (skipping {ToMatch} new tracks), no re-matching needed", + _logger.LogWarning("✓ Playlist {Playlist} already has {Count} matched tracks cached (skipping {ToMatch} new tracks), no re-matching needed", playlistName, existingMatched.Count, tracksToMatch.Count); return; } @@ -413,7 +488,7 @@ public class SpotifyTrackMatchingService : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", + _logger.LogError(ex, "Failed to match track: {Title} - {Artist}", spotifyTrack.Title, spotifyTrack.PrimaryArtist); return (spotifyTrack, new List<(Song, double, string)>()); } @@ -497,8 +572,37 @@ public class SpotifyTrackMatchingService : BackgroundService if (matchedTracks.Count > 0) { - // Cache matched tracks with position data - await _cache.SetAsync(matchedTracksKey, matchedTracks, TimeSpan.FromHours(1)); + // Calculate cache expiration: until next cron run (not just cache duration from settings) + var playlist = _spotifySettings.Playlists + .FirstOrDefault(p => p.Name.Equals(playlistName, StringComparison.OrdinalIgnoreCase)); + + var cacheExpiration = TimeSpan.FromHours(24); // Default 24 hours + + if (playlist != null && !string.IsNullOrEmpty(playlist.SyncSchedule)) + { + try + { + var cron = CronExpression.Parse(playlist.SyncSchedule); + var nextRun = cron.GetNextOccurrence(DateTime.UtcNow, TimeZoneInfo.Utc); + + if (nextRun.HasValue) + { + var timeUntilNextRun = nextRun.Value - DateTime.UtcNow; + // Add 5 minutes buffer to ensure cache doesn't expire before next run + cacheExpiration = timeUntilNextRun + TimeSpan.FromMinutes(5); + + _logger.LogInformation("Cache will persist until next cron run: {NextRun} UTC (in {Hours:F1} hours)", + nextRun.Value, timeUntilNextRun.TotalHours); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Could not calculate next cron run for {Playlist}, using default cache duration", playlistName); + } + } + + // Cache matched tracks with position data until next cron run + await _cache.SetAsync(matchedTracksKey, matchedTracks, cacheExpiration); // Save matched tracks to file for persistence across restarts await SaveMatchedTracksToFileAsync(playlistName, matchedTracks); @@ -506,15 +610,15 @@ public class SpotifyTrackMatchingService : BackgroundService // Also update legacy cache for backward compatibility var legacyKey = $"spotify:matched:{playlistName}"; var legacySongs = matchedTracks.OrderBy(t => t.Position).Select(t => t.MatchedSong).ToList(); - await _cache.SetAsync(legacyKey, legacySongs, TimeSpan.FromHours(1)); + await _cache.SetAsync(legacyKey, legacySongs, cacheExpiration); _logger.LogInformation( - "✓ Cached {Matched}/{Total} tracks for {Playlist} via GREEDY ASSIGNMENT (ISRC: {Isrc}, Fuzzy: {Fuzzy}, No match: {NoMatch}) - manual mappings will be applied next", - matchedTracks.Count, tracksToMatch.Count, playlistName, isrcMatches, fuzzyMatches, noMatch); + "✓ Cached {Matched}/{Total} tracks for {Playlist} via GREEDY ASSIGNMENT (ISRC: {Isrc}, Fuzzy: {Fuzzy}, No match: {NoMatch}) - cache expires in {Hours:F1}h", + matchedTracks.Count, tracksToMatch.Count, playlistName, isrcMatches, fuzzyMatches, noMatch, cacheExpiration.TotalHours); // Pre-build playlist items cache for instant serving // This is what makes the UI show all matched tracks at once - await PreBuildPlaylistItemsCacheAsync(playlistName, playlistConfig?.JellyfinId, spotifyTracks, matchedTracks, cancellationToken); + await PreBuildPlaylistItemsCacheAsync(playlistName, playlistConfig?.JellyfinId, spotifyTracks, matchedTracks, cacheExpiration, cancellationToken); } else { @@ -706,7 +810,7 @@ public class SpotifyTrackMatchingService : BackgroundService var existingMatched = await _cache.GetAsync>(matchedTracksKey); if (existingMatched != null && existingMatched.Count > 0) { - _logger.LogInformation("Playlist {Playlist} already has {Count} matched tracks cached, skipping", + _logger.LogWarning("Playlist {Playlist} already has {Count} matched tracks cached, skipping", playlistName, existingMatched.Count); return; } @@ -715,11 +819,11 @@ public class SpotifyTrackMatchingService : BackgroundService var missingTracks = await _cache.GetAsync>(missingTracksKey); if (missingTracks == null || missingTracks.Count == 0) { - _logger.LogInformation("No missing tracks found for {Playlist}, skipping matching", playlistName); + _logger.LogWarning("No missing tracks found for {Playlist}, skipping matching", playlistName); return; } - _logger.LogInformation("Matching {Count} tracks for {Playlist} (with rate limiting)", + _logger.LogWarning("Matching {Count} tracks for {Playlist} (with rate limiting)", missingTracks.Count, playlistName); var matchedSongs = new List(); @@ -774,15 +878,15 @@ public class SpotifyTrackMatchingService : BackgroundService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", + _logger.LogError(ex, "Failed to match track: {Title} - {Artist}", track.Title, track.PrimaryArtist); } } if (matchedSongs.Count > 0) { - // Cache matched tracks for 1 hour - await _cache.SetAsync(matchedTracksKey, matchedSongs, TimeSpan.FromHours(1)); + // Cache matched tracks for configurable duration + await _cache.SetAsync(matchedTracksKey, matchedSongs, CacheExtensions.SpotifyMatchedTracksTTL); _logger.LogInformation("✓ Cached {Matched}/{Total} matched tracks for {Playlist}", matchedSongs.Count, missingTracks.Count, playlistName); } @@ -843,21 +947,23 @@ public class SpotifyTrackMatchingService : BackgroundService /// /// Pre-builds the playlist items cache for instant serving. /// This combines local Jellyfin tracks with external matched tracks in the correct Spotify order. + /// PRIORITY: Local Jellyfin tracks FIRST, then external providers for unmatched tracks only. /// private async Task PreBuildPlaylistItemsCacheAsync( string playlistName, string? jellyfinPlaylistId, List spotifyTracks, - List matchedTracks, + List externalMatchedTracks, + TimeSpan cacheExpiration, CancellationToken cancellationToken) { try { - _logger.LogInformation("🔨 Pre-building playlist items cache for {Playlist}...", playlistName); + _logger.LogDebug("🔨 Pre-building playlist items cache for {Playlist}...", playlistName); if (string.IsNullOrEmpty(jellyfinPlaylistId)) { - _logger.LogWarning("No Jellyfin playlist ID configured for {Playlist}, cannot pre-build cache", playlistName); + _logger.LogError("No Jellyfin playlist ID configured for {Playlist}, cannot pre-build cache", playlistName); return; } @@ -876,7 +982,7 @@ public class SpotifyTrackMatchingService : BackgroundService var userId = jellyfinSettings.UserId; if (string.IsNullOrEmpty(userId)) { - _logger.LogWarning("No UserId configured, cannot pre-build playlist cache for {Playlist}", playlistName); + _logger.LogError("No UserId configured, cannot pre-build playlist cache for {Playlist}", playlistName); return; } @@ -887,12 +993,13 @@ public class SpotifyTrackMatchingService : BackgroundService headers["X-Emby-Authorization"] = $"MediaBrowser Token=\"{jellyfinSettings.ApiKey}\""; } - var playlistItemsUrl = $"Playlists/{jellyfinPlaylistId}/Items?UserId={userId}&Fields=MediaSources"; + // Request all fields that clients typically need (not just MediaSources) + var playlistItemsUrl = $"Playlists/{jellyfinPlaylistId}/Items?UserId={userId}&Fields=Genres,DateCreated,MediaSources,ParentId,People,Tags,SortName,ProviderIds"; var (existingTracksResponse, statusCode) = await proxyService.GetJsonAsync(playlistItemsUrl, null, headers); if (statusCode != 200 || existingTracksResponse == null) { - _logger.LogWarning("Failed to fetch Jellyfin playlist items for {Playlist}: HTTP {StatusCode}", playlistName, statusCode); + _logger.LogError("Failed to fetch Jellyfin playlist items for {Playlist}: HTTP {StatusCode}", playlistName, statusCode); return; } @@ -923,8 +1030,10 @@ public class SpotifyTrackMatchingService : BackgroundService } // Build the final track list in correct Spotify order + // PRIORITY: Local Jellyfin tracks FIRST, then external for unmatched only var finalItems = new List>(); var usedJellyfinItems = new HashSet(); + var matchedSpotifyIds = new HashSet(); // Track which Spotify tracks got local matches var localUsedCount = 0; var externalUsedCount = 0; var manualExternalCount = 0; @@ -962,19 +1071,42 @@ public class SpotifyTrackMatchingService : BackgroundService var itemDict = JsonSerializer.Deserialize>(matchedJellyfinItem.Value.GetRawText()); if (itemDict != null) { - // Add Spotify ID to ProviderIds so lyrics can work for local tracks too - if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId)) + // Add Jellyfin ID to ProviderIds for easy identification + if (itemDict.TryGetValue("Id", out var jellyfinIdObj) && jellyfinIdObj != null) { - if (!itemDict.ContainsKey("ProviderIds")) + var jellyfinId = jellyfinIdObj.ToString(); + if (!string.IsNullOrEmpty(jellyfinId)) { - itemDict["ProviderIds"] = new Dictionary(); - } - - var providerIds = itemDict["ProviderIds"] as Dictionary; - if (providerIds != null && !providerIds.ContainsKey("Spotify")) - { - providerIds["Spotify"] = spotifyTrack.SpotifyId; - _logger.LogDebug("Added Spotify ID {SpotifyId} to local track for lyrics support", spotifyTrack.SpotifyId); + if (!itemDict.ContainsKey("ProviderIds")) + { + itemDict["ProviderIds"] = new Dictionary(); + } + + // Handle ProviderIds which might be a JsonElement or Dictionary + Dictionary? providerIds = null; + + if (itemDict["ProviderIds"] is Dictionary dict) + { + providerIds = dict; + } + else if (itemDict["ProviderIds"] is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object) + { + // Convert JsonElement to Dictionary + providerIds = new Dictionary(); + foreach (var prop in jsonEl.EnumerateObject()) + { + providerIds[prop.Name] = prop.Value.GetString() ?? ""; + } + // Replace the JsonElement with the Dictionary + itemDict["ProviderIds"] = providerIds; + } + + if (providerIds != null && !providerIds.ContainsKey("Jellyfin")) + { + providerIds["Jellyfin"] = jellyfinId; + _logger.LogDebug("Added Jellyfin ID {JellyfinId} to manual mapped local track {Title}", + jellyfinId, spotifyTrack.Title); + } } } @@ -983,6 +1115,7 @@ public class SpotifyTrackMatchingService : BackgroundService { usedJellyfinItems.Add(matchedKey); } + matchedSpotifyIds.Add(spotifyTrack.SpotifyId); // Mark as locally matched localUsedCount++; } continue; // Skip to next track @@ -1031,7 +1164,7 @@ public class SpotifyTrackMatchingService : BackgroundService } else { - _logger.LogWarning("Failed to fetch metadata for {Provider} ID {ExternalId}, using fallback", + _logger.LogError("Failed to fetch metadata for {Provider} ID {ExternalId}, using fallback", provider, externalId); } } @@ -1058,15 +1191,6 @@ public class SpotifyTrackMatchingService : BackgroundService }; } - var matchedTrack = new MatchedTrack - { - Position = spotifyTrack.Position, - SpotifyId = spotifyTrack.SpotifyId, - MatchedSong = externalSong - }; - - matchedTracks.Add(matchedTrack); - // Convert external song to Jellyfin item format and add to finalItems var externalItem = responseBuilder.ConvertSongToJellyfinItem(externalSong); @@ -1088,6 +1212,7 @@ public class SpotifyTrackMatchingService : BackgroundService finalItems.Add(externalItem); externalUsedCount++; manualExternalCount++; + matchedSpotifyIds.Add(spotifyTrack.SpotifyId); // Mark as matched (external) _logger.LogInformation("✓ Using manual external mapping for {Title}: {Provider} {ExternalId}", spotifyTrack.Title, provider, externalId); @@ -1096,11 +1221,11 @@ public class SpotifyTrackMatchingService : BackgroundService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to process external manual mapping for {Title}", spotifyTrack.Title); + _logger.LogError(ex, "Failed to process external manual mapping for {Title}", spotifyTrack.Title); } } - // If no manual external mapping, try AGGRESSIVE fuzzy matching with local Jellyfin tracks + // THIRD: Try AGGRESSIVE fuzzy matching with local Jellyfin tracks (PRIORITY!) double bestScore = 0; foreach (var kvp in jellyfinItemsByName) @@ -1140,19 +1265,42 @@ public class SpotifyTrackMatchingService : BackgroundService var itemDict = JsonSerializer.Deserialize>(matchedJellyfinItem.Value.GetRawText()); if (itemDict != null) { - // Add Spotify ID to ProviderIds so lyrics can work for fuzzy-matched local tracks too - if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId)) + // Add Jellyfin ID to ProviderIds for easy identification + if (itemDict.TryGetValue("Id", out var jellyfinIdObj) && jellyfinIdObj != null) { - if (!itemDict.ContainsKey("ProviderIds")) + var jellyfinId = jellyfinIdObj.ToString(); + if (!string.IsNullOrEmpty(jellyfinId)) { - itemDict["ProviderIds"] = new Dictionary(); - } - - var providerIds = itemDict["ProviderIds"] as Dictionary; - if (providerIds != null && !providerIds.ContainsKey("Spotify")) - { - providerIds["Spotify"] = spotifyTrack.SpotifyId; - _logger.LogDebug("Added Spotify ID {SpotifyId} to fuzzy-matched local track for lyrics support", spotifyTrack.SpotifyId); + if (!itemDict.ContainsKey("ProviderIds")) + { + itemDict["ProviderIds"] = new Dictionary(); + } + + // Handle ProviderIds which might be a JsonElement or Dictionary + Dictionary? providerIds = null; + + if (itemDict["ProviderIds"] is Dictionary dict) + { + providerIds = dict; + } + else if (itemDict["ProviderIds"] is JsonElement jsonEl && jsonEl.ValueKind == JsonValueKind.Object) + { + // Convert JsonElement to Dictionary + providerIds = new Dictionary(); + foreach (var prop in jsonEl.EnumerateObject()) + { + providerIds[prop.Name] = prop.Value.GetString() ?? ""; + } + // Replace the JsonElement with the Dictionary + itemDict["ProviderIds"] = providerIds; + } + + if (providerIds != null && !providerIds.ContainsKey("Jellyfin")) + { + providerIds["Jellyfin"] = jellyfinId; + _logger.LogDebug("Fuzzy matched local track {Title} with Jellyfin ID {Id} (score: {Score:F1})", + spotifyTrack.Title, jellyfinId, bestScore); + } } } @@ -1161,44 +1309,108 @@ public class SpotifyTrackMatchingService : BackgroundService { usedJellyfinItems.Add(matchedKey); } + matchedSpotifyIds.Add(spotifyTrack.SpotifyId); // Mark as locally matched localUsedCount++; } } else { - // No local match - try to find external track - var matched = matchedTracks.FirstOrDefault(t => t.SpotifyId == spotifyTrack.SpotifyId); + // FOURTH: No local match - try to find external track (ONLY for unmatched tracks) + var matched = externalMatchedTracks.FirstOrDefault(t => t.SpotifyId == spotifyTrack.SpotifyId); if (matched != null && matched.MatchedSong != null) { // Convert external song to Jellyfin item format var externalItem = responseBuilder.ConvertSongToJellyfinItem(matched.MatchedSong); - // Add Spotify ID to ProviderIds so lyrics can work - if (!string.IsNullOrEmpty(spotifyTrack.SpotifyId)) - { - if (!externalItem.ContainsKey("ProviderIds")) - { - externalItem["ProviderIds"] = new Dictionary(); - } - - var providerIds = externalItem["ProviderIds"] as Dictionary; - if (providerIds != null && !providerIds.ContainsKey("Spotify")) - { - providerIds["Spotify"] = spotifyTrack.SpotifyId; - } - } - finalItems.Add(externalItem); + matchedSpotifyIds.Add(spotifyTrack.SpotifyId); // Mark as matched (external) externalUsedCount++; + + _logger.LogDebug("Using external match for {Title}: {Provider}", + spotifyTrack.Title, matched.MatchedSong.ExternalProvider); } + // else: Track remains unmatched (not added to finalItems) } } if (finalItems.Count > 0) { - // Save to Redis cache + // Enrich external tracks with genres from MusicBrainz + if (externalUsedCount > 0) + { + try + { + var genreEnrichment = _serviceProvider.GetService(); + if (genreEnrichment != null) + { + _logger.LogDebug("🎨 Enriching {Count} external tracks with genres from MusicBrainz...", externalUsedCount); + + // Extract external songs from externalMatchedTracks that were actually used + var usedExternalSpotifyIds = finalItems + .Where(item => item.TryGetValue("Id", out var idObj) && + idObj is string id && id.StartsWith("ext-")) + .Select(item => + { + // Try to get Spotify ID from ProviderIds + if (item.TryGetValue("ProviderIds", out var providerIdsObj) && providerIdsObj is Dictionary providerIds) + { + providerIds.TryGetValue("Spotify", out var spotifyId); + return spotifyId; + } + return null; + }) + .Where(id => !string.IsNullOrEmpty(id)) + .ToHashSet(); + + var externalSongs = externalMatchedTracks + .Where(t => t.MatchedSong != null && + !t.MatchedSong.IsLocal && + usedExternalSpotifyIds.Contains(t.SpotifyId)) + .Select(t => t.MatchedSong!) + .ToList(); + + // Enrich genres in parallel + await genreEnrichment.EnrichSongsGenresAsync(externalSongs); + + // Update the genres in finalItems + foreach (var item in finalItems) + { + if (item.TryGetValue("Id", out var idObj) && idObj is string id && id.StartsWith("ext-")) + { + // Find the corresponding song + var song = externalSongs.FirstOrDefault(s => s.Id == id); + if (song != null && !string.IsNullOrEmpty(song.Genre)) + { + // Update Genres array + item["Genres"] = new[] { song.Genre }; + + // Update GenreItems array + item["GenreItems"] = new[] + { + new Dictionary + { + ["Name"] = song.Genre, + ["Id"] = $"genre-{song.Genre.ToLowerInvariant()}" + } + }; + + _logger.LogDebug("✓ Enriched {Title} with genre: {Genre}", song.Title, song.Genre); + } + } + } + + _logger.LogInformation("✅ Genre enrichment complete for {Playlist}", playlistName); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to enrich genres for {Playlist}, continuing without genres", playlistName); + } + } + + // Save to Redis cache with same expiration as matched tracks (until next cron run) var cacheKey = $"spotify:playlist:items:{playlistName}"; - await _cache.SetAsync(cacheKey, finalItems, TimeSpan.FromHours(24)); + await _cache.SetAsync(cacheKey, finalItems, cacheExpiration); // Save to file cache for persistence await SavePlaylistItemsToFileAsync(playlistName, finalItems); @@ -1209,9 +1421,8 @@ public class SpotifyTrackMatchingService : BackgroundService manualMappingInfo = $" [Manual external: {manualExternalCount}]"; } - _logger.LogInformation( - "✅ Pre-built playlist cache for {Playlist}: {Total} tracks ({Local} LOCAL + {External} EXTERNAL){ManualInfo}", - playlistName, finalItems.Count, localUsedCount, externalUsedCount, manualMappingInfo); + _logger.LogDebug("✅ Pre-built playlist cache for {Playlist}: {Total} tracks ({Local} LOCAL + {External} EXTERNAL){ManualInfo} - expires in {Hours:F1}h", + playlistName, finalItems.Count, localUsedCount, externalUsedCount, manualMappingInfo, cacheExpiration.TotalHours); } else { @@ -1264,7 +1475,7 @@ public class SpotifyTrackMatchingService : BackgroundService var json = JsonSerializer.Serialize(matchedTracks, new JsonSerializerOptions { WriteIndented = true }); await System.IO.File.WriteAllTextAsync(filePath, json); - _logger.LogDebug("💾 Saved {Count} matched tracks to file cache: {Path}", matchedTracks.Count, filePath); + _logger.LogInformation("💾 Saved {Count} matched tracks to file cache: {Path}", matchedTracks.Count, filePath); } catch (Exception ex) { diff --git a/allstarr/Services/SquidWTF/SquidWTFDownloadService.cs b/allstarr/Services/SquidWTF/SquidWTFDownloadService.cs index a8c695c..4cd36f2 100644 --- a/allstarr/Services/SquidWTF/SquidWTFDownloadService.cs +++ b/allstarr/Services/SquidWTF/SquidWTFDownloadService.cs @@ -129,7 +129,7 @@ public class SquidWTFDownloadService : BaseDownloadService var basePath = SubsonicSettings.StorageMode == StorageMode.Cache ? Path.Combine("downloads", "cache") : Path.Combine("downloads", "permanent"); - var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension); + var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension, "squidwtf", trackId); // Create directories if they don't exist var albumFolder = Path.GetDirectoryName(outputPath)!; diff --git a/allstarr/Services/SquidWTF/SquidWTFMetadataService.cs b/allstarr/Services/SquidWTF/SquidWTFMetadataService.cs index b14c6bf..750b10b 100644 --- a/allstarr/Services/SquidWTF/SquidWTFMetadataService.cs +++ b/allstarr/Services/SquidWTF/SquidWTFMetadataService.cs @@ -56,6 +56,7 @@ public class SquidWTFMetadataService : IMusicMetadataService private readonly ILogger _logger; private readonly RedisCacheService _cache; private readonly RoundRobinFallbackHelper _fallbackHelper; + private readonly GenreEnrichmentService? _genreEnrichment; public SquidWTFMetadataService( IHttpClientFactory httpClientFactory, @@ -63,13 +64,15 @@ public class SquidWTFMetadataService : IMusicMetadataService IOptions squidwtfSettings, ILogger logger, RedisCacheService cache, - List apiUrls) + List apiUrls, + GenreEnrichmentService? genreEnrichment = null) { _httpClient = httpClientFactory.CreateClient(); _settings = settings.Value; _logger = logger; _cache = cache; _fallbackHelper = new RoundRobinFallbackHelper(apiUrls, logger, "SquidWTF"); + _genreEnrichment = genreEnrichment; // Set up default headers _httpClient.DefaultRequestHeaders.Add("User-Agent", @@ -83,19 +86,19 @@ public class SquidWTFMetadataService : IMusicMetadataService public async Task> SearchSongsAsync(string query, int limit = 20) { - // Race all endpoints for fastest search results - return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) => + // Use round-robin to distribute load across endpoints (allows parallel processing of multiple tracks) + return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) => { // Use 's' parameter for track search as per hifi-api spec var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}"; - var response = await _httpClient.GetAsync(url, ct); + var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { throw new HttpRequestException($"HTTP {response.StatusCode}"); } - var json = await response.Content.ReadAsStringAsync(ct); + var json = await response.Content.ReadAsStringAsync(); // Check for error in response body var result = JsonDocument.Parse(json); @@ -129,19 +132,19 @@ public class SquidWTFMetadataService : IMusicMetadataService public async Task> SearchAlbumsAsync(string query, int limit = 20) { - // Race all endpoints for fastest search results - return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) => + // Use round-robin to distribute load across endpoints (allows parallel processing) + return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) => { // Note: hifi-api doesn't document album search, but 'al' parameter is commonly used var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}"; - var response = await _httpClient.GetAsync(url, ct); + var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { throw new HttpRequestException($"HTTP {response.StatusCode}"); } - var json = await response.Content.ReadAsStringAsync(ct); + var json = await response.Content.ReadAsStringAsync(); var result = JsonDocument.Parse(json); var albums = new List(); @@ -166,14 +169,14 @@ public class SquidWTFMetadataService : IMusicMetadataService public async Task> SearchArtistsAsync(string query, int limit = 20) { - // Race all endpoints for fastest search results - return await _fallbackHelper.RaceAllEndpointsAsync(async (baseUrl, ct) => + // Use round-robin to distribute load across endpoints (allows parallel processing) + return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) => { // Per hifi-api spec: use 'a' parameter for artist search var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}"; - _logger.LogInformation("🔍 SQUIDWTF: Searching artists with URL: {Url}", url); + _logger.LogDebug("🔍 SQUIDWTF: Searching artists with URL: {Url}", url); - var response = await _httpClient.GetAsync(url, ct); + var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { @@ -181,7 +184,7 @@ public class SquidWTFMetadataService : IMusicMetadataService throw new HttpRequestException($"HTTP {response.StatusCode}"); } - var json = await response.Content.ReadAsStringAsync(ct); + var json = await response.Content.ReadAsStringAsync(); var result = JsonDocument.Parse(json); var artists = new List(); @@ -237,7 +240,7 @@ public class SquidWTFMetadataService : IMusicMetadataService } catch (Exception ex) { - _logger.LogDebug(ex, "Failed to parse playlist, skipping"); + _logger.LogWarning(ex, "Failed to parse playlist, skipping"); // Skip this playlist and continue with others } } @@ -286,6 +289,23 @@ public class SquidWTFMetadataService : IMusicMetadataService var song = ParseTidalTrackFull(track); + // Enrich with MusicBrainz genres if missing (SquidWTF/Tidal doesn't provide genres) + if (_genreEnrichment != null && string.IsNullOrEmpty(song.Genre)) + { + // Fire-and-forget: don't block the response waiting for genre enrichment + _ = Task.Run(async () => + { + try + { + await _genreEnrichment.EnrichSongGenreAsync(song); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to enrich genre for {Title}", song.Title); + } + }); + } + // NOTE: Spotify ID conversion happens during download (in SquidWTFDownloadService) // This avoids redundant conversions and ensures it's done in parallel with the download @@ -336,8 +356,8 @@ public class SquidWTFMetadataService : IMusicMetadataService } } - // Cache for 24 hours - await _cache.SetAsync(cacheKey, album, TimeSpan.FromHours(24)); + // Cache for configurable duration + await _cache.SetAsync(cacheKey, album, CacheExtensions.MetadataTTL); return album; }, (Album?)null); @@ -347,14 +367,14 @@ public class SquidWTFMetadataService : IMusicMetadataService { if (externalProvider != "squidwtf") return null; - _logger.LogInformation("GetArtistAsync called for SquidWTF artist {ExternalId}", externalId); + _logger.LogDebug("GetArtistAsync called for SquidWTF artist {ExternalId}", externalId); // Try cache first var cacheKey = $"squidwtf:artist:{externalId}"; var cached = await _cache.GetAsync(cacheKey); if (cached != null) { - _logger.LogInformation("Returning cached artist {ArtistName}", cached.Name); + _logger.LogDebug("Returning cached artist {ArtistName}", cached.Name); return cached; } @@ -362,12 +382,12 @@ public class SquidWTFMetadataService : IMusicMetadataService { // Note: hifi-api doesn't document artist endpoint, but /artist/?f={artistId} is commonly used var url = $"{baseUrl}/artist/?f={externalId}"; - _logger.LogInformation("Fetching artist from {Url}", url); + _logger.LogDebug("Fetching artist from {Url}", url); var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { - _logger.LogWarning("SquidWTF artist request failed with status {StatusCode}", response.StatusCode); + _logger.LogError("SquidWTF artist request failed with status {StatusCode}", response.StatusCode); return null; } @@ -388,7 +408,7 @@ public class SquidWTFMetadataService : IMusicMetadataService if (albumItems[0].TryGetProperty("artist", out var artistEl)) { artistSource = artistEl; - _logger.LogInformation("Found artist from albums, albumCount={AlbumCount}", albumCount); + _logger.LogDebug("Found artist from albums, albumCount={AlbumCount}", albumCount); } } @@ -423,10 +443,10 @@ public class SquidWTFMetadataService : IMusicMetadataService using var doc = JsonDocument.Parse(normalizedArtist.ToJsonString()); var artist = ParseTidalArtist(doc.RootElement); - _logger.LogInformation("Successfully parsed artist {ArtistName} with {AlbumCount} albums", artist.Name, albumCount); + _logger.LogDebug("Successfully parsed artist {ArtistName} with {AlbumCount} albums", artist.Name, albumCount); - // Cache for 24 hours - await _cache.SetAsync(cacheKey, artist, TimeSpan.FromHours(24)); + // Cache for configurable duration + await _cache.SetAsync(cacheKey, artist, CacheExtensions.MetadataTTL); return artist; }, (Artist?)null); @@ -438,16 +458,16 @@ public class SquidWTFMetadataService : IMusicMetadataService return await _fallbackHelper.TryWithFallbackAsync(async (baseUrl) => { - _logger.LogInformation("GetArtistAlbumsAsync called for SquidWTF artist {ExternalId}", externalId); + _logger.LogDebug("GetArtistAlbumsAsync called for SquidWTF artist {ExternalId}", externalId); // Note: hifi-api doesn't document artist endpoint, but /artist/?f={artistId} is commonly used var url = $"{baseUrl}/artist/?f={externalId}"; - _logger.LogInformation("Fetching artist albums from URL: {Url}", url); + _logger.LogDebug("Fetching artist albums from URL: {Url}", url); var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { - _logger.LogWarning("SquidWTF artist albums request failed with status {StatusCode}", response.StatusCode); + _logger.LogError("SquidWTF artist albums request failed with status {StatusCode}", response.StatusCode); return new List(); } @@ -468,7 +488,7 @@ public class SquidWTFMetadataService : IMusicMetadataService parsedAlbum.Title, parsedAlbum.Artist, parsedAlbum.ArtistId); albums.Add(parsedAlbum); } - _logger.LogInformation("Found {AlbumCount} albums for artist {ExternalId}", albums.Count, externalId); + _logger.LogDebug("Found {AlbumCount} albums for artist {ExternalId}", albums.Count, externalId); } else { @@ -595,6 +615,7 @@ public class SquidWTFMetadataService : IMusicMetadataService // Get all artists - Tidal provides both "artist" (singular) and "artists" (plural array) var allArtists = new List(); + var allArtistIds = new List(); string artistName = ""; string? artistId = null; @@ -604,9 +625,11 @@ public class SquidWTFMetadataService : IMusicMetadataService foreach (var artistEl in artists.EnumerateArray()) { var name = artistEl.GetProperty("name").GetString(); + var id = artistEl.GetProperty("id").GetInt64(); if (!string.IsNullOrEmpty(name)) { allArtists.Add(name); + allArtistIds.Add($"ext-squidwtf-artist-{id}"); } } @@ -614,7 +637,7 @@ public class SquidWTFMetadataService : IMusicMetadataService if (allArtists.Count > 0) { artistName = allArtists[0]; - artistId = $"ext-squidwtf-artist-{artists[0].GetProperty("id").GetInt64()}"; + artistId = allArtistIds[0]; } } // Fallback to singular "artist" field @@ -623,6 +646,7 @@ public class SquidWTFMetadataService : IMusicMetadataService artistName = artist.GetProperty("name").GetString() ?? ""; artistId = $"ext-squidwtf-artist-{artist.GetProperty("id").GetInt64()}"; allArtists.Add(artistName); + allArtistIds.Add(artistId); } // Get album info @@ -649,6 +673,7 @@ public class SquidWTFMetadataService : IMusicMetadataService Artist = artistName, ArtistId = artistId, Artists = allArtists, + ArtistIds = allArtistIds, Album = albumTitle, AlbumId = albumId, Duration = track.TryGetProperty("duration", out var duration) @@ -711,6 +736,7 @@ public class SquidWTFMetadataService : IMusicMetadataService // Get all artists - prefer "artists" array for collaborations var allArtists = new List(); + var allArtistIds = new List(); string artistName = ""; long artistIdNum = 0; @@ -719,9 +745,11 @@ public class SquidWTFMetadataService : IMusicMetadataService foreach (var artistEl in artists.EnumerateArray()) { var name = artistEl.GetProperty("name").GetString(); + var id = artistEl.GetProperty("id").GetInt64(); if (!string.IsNullOrEmpty(name)) { allArtists.Add(name); + allArtistIds.Add($"ext-squidwtf-artist-{id}"); } } @@ -736,6 +764,7 @@ public class SquidWTFMetadataService : IMusicMetadataService artistName = artist.GetProperty("name").GetString() ?? ""; artistIdNum = artist.GetProperty("id").GetInt64(); allArtists.Add(artistName); + allArtistIds.Add($"ext-squidwtf-artist-{artistIdNum}"); } // Album artist - same as main artist for Tidal tracks @@ -771,6 +800,7 @@ public class SquidWTFMetadataService : IMusicMetadataService Artist = artistName, ArtistId = $"ext-squidwtf-artist-{artistIdNum}", Artists = allArtists, + ArtistIds = allArtistIds, Album = albumTitle, AlbumId = $"ext-squidwtf-album-{albumIdNum}", AlbumArtist = albumArtist, diff --git a/allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs b/allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs index e1bbbfc..e23ce76 100644 --- a/allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs +++ b/allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs @@ -73,7 +73,11 @@ public class SquidWTFStartupValidator : BaseStartupValidator { try { - var response = await _httpClient.GetAsync(endpoint, ct); + // 5 second timeout per ping - mark slow endpoints as failed + using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct); + timeoutCts.CancelAfter(TimeSpan.FromSeconds(5)); + + var response = await _httpClient.GetAsync(endpoint, timeoutCts.Token); return response.IsSuccessStatusCode; } catch diff --git a/allstarr/Services/Subsonic/PlaylistSyncService.cs b/allstarr/Services/Subsonic/PlaylistSyncService.cs index 0903213..0af6c10 100644 --- a/allstarr/Services/Subsonic/PlaylistSyncService.cs +++ b/allstarr/Services/Subsonic/PlaylistSyncService.cs @@ -187,7 +187,7 @@ public class PlaylistSyncService } catch (Exception ex) { - _logger.LogWarning(ex, "Failed to download track '{Artist} - {Title}'", track.Artist, track.Title); + _logger.LogError(ex, "Failed to download track '{Artist} - {Title}'", track.Artist, track.Title); } } @@ -239,7 +239,7 @@ public class PlaylistSyncService } await IOFile.WriteAllTextAsync(playlistPath, m3uContent.ToString()); - _logger.LogInformation("Created M3U playlist: {Path}", playlistPath); + _logger.LogDebug("Created M3U playlist: {Path}", playlistPath); } catch (Exception ex) { @@ -259,7 +259,7 @@ public class PlaylistSyncService // Skip real-time updates during full playlist download (M3U will be created once at the end) if (isFullPlaylistDownload) { - _logger.LogDebug("Skipping M3U update for track {TrackId} (full playlist download in progress)", track.Id); + _logger.LogWarning("Skipping M3U update for track {TrackId} (full playlist download in progress)", track.Id); return; } @@ -349,7 +349,7 @@ public class PlaylistSyncService // Write the M3U file (overwrites existing) await IOFile.WriteAllTextAsync(playlistPath, m3uContent.ToString()); - _logger.LogInformation("Updated M3U playlist '{PlaylistName}' with {Count} tracks (in correct order)", + _logger.LogDebug("Updated M3U playlist '{PlaylistName}' with {Count} tracks (in correct order)", playlist.Name, addedCount); } catch (Exception ex) @@ -382,7 +382,7 @@ public class PlaylistSyncService if (expiredKeys.Count > 0) { - _logger.LogDebug("Cleaned up {Count} expired playlist cache entries", expiredKeys.Count); + _logger.LogWarning("Cleaned up {Count} expired playlist cache entries", expiredKeys.Count); } } catch (OperationCanceledException) @@ -392,7 +392,7 @@ public class PlaylistSyncService } catch (Exception ex) { - _logger.LogWarning(ex, "Error during playlist cache cleanup"); + _logger.LogError(ex, "Error during playlist cache cleanup"); } } diff --git a/allstarr/Services/Subsonic/SubsonicModelMapper.cs b/allstarr/Services/Subsonic/SubsonicModelMapper.cs index 09542bc..a869848 100644 --- a/allstarr/Services/Subsonic/SubsonicModelMapper.cs +++ b/allstarr/Services/Subsonic/SubsonicModelMapper.cs @@ -91,7 +91,7 @@ public class SubsonicModelMapper } catch (Exception ex) { - _logger.LogWarning(ex, "Error parsing Subsonic search response"); + _logger.LogError(ex, "Error parsing Subsonic search response"); } return (songs, albums, artists); diff --git a/allstarr/allstarr.csproj b/allstarr/allstarr.csproj index a9e9b3e..19e9821 100644 --- a/allstarr/allstarr.csproj +++ b/allstarr/allstarr.csproj @@ -5,13 +5,14 @@ enable enable allstarr - 1.0.0 - 1.0.0.0 - 1.0.0.0 + 1.0.1 + 1.0.1.0 + 1.0.1.0 + diff --git a/allstarr/appsettings.json b/allstarr/appsettings.json index 771d34a..15d1523 100644 --- a/allstarr/appsettings.json +++ b/allstarr/appsettings.json @@ -32,8 +32,7 @@ "EnableExternalPlaylists": true }, "Library": { - "DownloadPath": "./downloads", - "KeptPath": "/app/kept" + "DownloadPath": "./downloads" }, "Qobuz": { "UserAuthToken": "your-qobuz-token", @@ -52,6 +51,17 @@ "Enabled": true, "ConnectionString": "localhost:6379" }, + "Cache": { + "SearchResultsMinutes": 120, + "PlaylistImagesHours": 168, + "SpotifyPlaylistItemsHours": 168, + "SpotifyMatchedTracksDays": 30, + "LyricsDays": 14, + "GenreDays": 30, + "MetadataDays": 7, + "OdesliLookupDays": 60, + "ProxyImagesDays": 14 + }, "SpotifyImport": { "Enabled": false, "SyncStartHour": 16, @@ -62,8 +72,6 @@ }, "SpotifyApi": { "Enabled": false, - "ClientId": "", - "ClientSecret": "", "SessionCookie": "", "CacheDurationMinutes": 60, "RateLimitDelayMs": 100, diff --git a/allstarr/wwwroot/index.html b/allstarr/wwwroot/index.html index 3946dc9..0ca4a1c 100644 --- a/allstarr/wwwroot/index.html +++ b/allstarr/wwwroot/index.html @@ -75,6 +75,7 @@ .status-badge.success { background: rgba(63, 185, 80, 0.2); color: var(--success); } .status-badge.warning { background: rgba(210, 153, 34, 0.2); color: var(--warning); } .status-badge.error { background: rgba(248, 81, 73, 0.2); color: var(--error); } + .status-badge.info { background: rgba(59, 130, 246, 0.2); color: #3b82f6; } .status-dot { width: 8px; @@ -537,7 +538,7 @@
Dashboard
Link Playlists
-
Active Playlists
+
Injected Playlists
Configuration
API Analytics
@@ -652,21 +653,22 @@

- Active Spotify Playlists + Injected Spotify Playlists
- + - +

- These are the Spotify playlists currently being monitored and filled with tracks from your music service. + These are the Spotify playlists currently being injected into Jellyfin with tracks from your music service.

+ @@ -675,7 +677,7 @@ - @@ -806,8 +808,62 @@
+
+

Core Settings

+
+
+ Backend Type * + - + +
+
+ Music Service * + - + +
+
+ Storage Mode + - + +
+ +
+ Download Mode + - + +
+
+ Explicit Filter + - + +
+
+ Enable External Playlists + - + +
+
+ Playlists Directory + - + +
+
+ Redis Enabled + - + +
+
+
+

Spotify API Settings

+
+ ⚠️ For active playlists and link functionality to work, sp_dc session cookie must be set! +
API Enabled @@ -815,7 +871,7 @@
- Session Cookie (sp_dc) + Session Cookie (sp_dc) * -
@@ -858,7 +914,7 @@
Quality - - +
@@ -904,17 +960,17 @@

Jellyfin Settings

- URL + URL * -
- API Key + API Key * -
- User ID + User ID * -
@@ -943,17 +999,71 @@
-

Sync Schedule

+

Spotify Import Settings

- Sync Start Time - - - + Spotify Import Enabled + - +
- Sync Window - - - + Matching Interval (hours) + - + +
+
+
+ +
+

Cache Settings

+

+ Configure how long different types of data are cached. Longer durations reduce API calls but may show stale data. +

+
+
+ Search Results (minutes) + - + +
+
+ Playlist Images (hours) + - + +
+
+ Spotify Playlist Items (hours) + - + +
+
+ Spotify Matched Tracks (days) + - + +
+
+ Lyrics (days) + - + +
+
+ Genre Data (days) + - + +
+
+ External Metadata (days) + - + +
+
+ Odesli Lookups (days) + - + +
+
+ Proxy Images (days) + - +
@@ -1119,7 +1229,7 @@

Map Track to External Provider

- Map this track to an external provider (SquidWTF, Deezer, or Qobuz). For local Jellyfin tracks, use the Spotify Import plugin instead. + Map this track to an external provider (SquidWTF, Deezer, or Qobuz). For local Jellyfin tracks, use the Jellyfin mapping modal instead.

@@ -1161,25 +1271,94 @@
+ + + '; + tbody.innerHTML = ''; } return; } @@ -1491,13 +1670,13 @@ // Show breakdown with color coding let breakdownParts = []; if (localCount > 0) { - breakdownParts.push(`${localCount} local`); + breakdownParts.push(`${localCount} Local`); } if (externalMatched > 0) { - breakdownParts.push(`${externalMatched} matched`); + breakdownParts.push(`${externalMatched} External`); } if (externalMissing > 0) { - breakdownParts.push(`${externalMissing} missing`); + breakdownParts.push(`${externalMissing} Missing`); } const breakdown = breakdownParts.length > 0 @@ -1514,25 +1693,31 @@ // Debug logging console.log(`Progress bar for ${p.name}: local=${localPct}%, external=${externalPct}%, missing=${missingPct}%, total=${completionPct}%`); + const syncSchedule = p.syncSchedule || '0 8 * * 1'; + return ` + @@ -1776,6 +1961,23 @@ const res = await fetch('/api/admin/config'); const data = await res.json(); + // Core settings + document.getElementById('config-backend-type').textContent = data.backendType || 'Jellyfin'; + document.getElementById('config-music-service').textContent = data.musicService || 'SquidWTF'; + document.getElementById('config-storage-mode').textContent = data.library?.storageMode || 'Cache'; + document.getElementById('config-cache-duration-hours').textContent = data.library?.cacheDurationHours || '24'; + document.getElementById('config-download-mode').textContent = data.library?.downloadMode || 'Track'; + document.getElementById('config-explicit-filter').textContent = data.explicitFilter || 'All'; + document.getElementById('config-enable-external-playlists').textContent = data.enableExternalPlaylists ? 'Yes' : 'No'; + document.getElementById('config-playlists-directory').textContent = data.playlistsDirectory || '(not set)'; + document.getElementById('config-redis-enabled').textContent = data.redisEnabled ? 'Yes' : 'No'; + + // Show/hide cache duration based on storage mode + const cacheDurationRow = document.getElementById('cache-duration-row'); + if (cacheDurationRow) { + cacheDurationRow.style.display = data.library?.storageMode === 'Cache' ? 'grid' : 'none'; + } + // Spotify API settings document.getElementById('config-spotify-enabled').textContent = data.spotifyApi.enabled ? 'Yes' : 'No'; document.getElementById('config-spotify-cookie').textContent = data.spotifyApi.sessionCookie; @@ -1817,10 +2019,21 @@ document.getElementById('config-kept-path').textContent = data.library?.keptPath || '/app/kept'; // Sync settings - const syncHour = data.spotifyImport.syncStartHour; - const syncMin = data.spotifyImport.syncStartMinute; - document.getElementById('config-sync-time').textContent = `${String(syncHour).padStart(2, '0')}:${String(syncMin).padStart(2, '0')}`; - document.getElementById('config-sync-window').textContent = data.spotifyImport.syncWindowHours + ' hours'; + document.getElementById('config-spotify-import-enabled').textContent = data.spotifyImport?.enabled ? 'Yes' : 'No'; + document.getElementById('config-matching-interval').textContent = (data.spotifyImport?.matchingIntervalHours || 24) + ' hours'; + + // Cache settings + if (data.cache) { + document.getElementById('config-cache-search').textContent = data.cache.searchResultsMinutes || '120'; + document.getElementById('config-cache-playlist-images').textContent = data.cache.playlistImagesHours || '168'; + document.getElementById('config-cache-spotify-items').textContent = data.cache.spotifyPlaylistItemsHours || '168'; + document.getElementById('config-cache-matched-tracks').textContent = data.cache.spotifyMatchedTracksDays || '30'; + document.getElementById('config-cache-lyrics').textContent = data.cache.lyricsDays || '14'; + document.getElementById('config-cache-genres').textContent = data.cache.genreDays || '30'; + document.getElementById('config-cache-metadata').textContent = data.cache.metadataDays || '7'; + document.getElementById('config-cache-odesli').textContent = data.cache.odesliLookupDays || '60'; + document.getElementById('config-cache-proxy-images').textContent = data.cache.proxyImagesDays || '14'; + } } catch (error) { console.error('Failed to fetch config:', error); } @@ -1896,23 +2109,138 @@ } } - function openLinkPlaylist(jellyfinId, name) { + let currentLinkMode = 'select'; // 'select' or 'manual' + let spotifyUserPlaylists = []; // Cache of user playlists + + function switchLinkMode(mode) { + currentLinkMode = mode; + + const selectGroup = document.getElementById('link-select-group'); + const manualGroup = document.getElementById('link-manual-group'); + const selectBtn = document.getElementById('select-mode-btn'); + const manualBtn = document.getElementById('manual-mode-btn'); + + if (mode === 'select') { + selectGroup.style.display = 'block'; + manualGroup.style.display = 'none'; + selectBtn.classList.add('primary'); + manualBtn.classList.remove('primary'); + } else { + selectGroup.style.display = 'none'; + manualGroup.style.display = 'block'; + selectBtn.classList.remove('primary'); + manualBtn.classList.add('primary'); + } + } + + async function fetchSpotifyUserPlaylists() { + try { + const res = await fetch('/api/admin/spotify/user-playlists'); + if (!res.ok) { + const error = await res.json(); + console.error('Failed to fetch Spotify playlists:', res.status, error); + + // Show user-friendly error message + if (res.status === 429) { + showToast('Spotify rate limit reached. Please wait a moment and try again.', 'warning', 5000); + } else if (res.status === 401) { + showToast('Spotify authentication failed. Check your sp_dc cookie.', 'error', 5000); + } + return []; + } + const data = await res.json(); + return data.playlists || []; + } catch (error) { + console.error('Failed to fetch Spotify playlists:', error); + return []; + } + } + + async function openLinkPlaylist(jellyfinId, name) { document.getElementById('link-jellyfin-id').value = jellyfinId; document.getElementById('link-jellyfin-name').value = name; document.getElementById('link-spotify-id').value = ''; + + // Reset to select mode + switchLinkMode('select'); + + // Fetch user playlists if not already cached + if (spotifyUserPlaylists.length === 0) { + const select = document.getElementById('link-spotify-select'); + select.innerHTML = ''; + + spotifyUserPlaylists = await fetchSpotifyUserPlaylists(); + + // Filter out already-linked playlists + const availablePlaylists = spotifyUserPlaylists.filter(p => !p.isLinked); + + if (availablePlaylists.length === 0) { + if (spotifyUserPlaylists.length > 0) { + select.innerHTML = ''; + } else { + select.innerHTML = ''; + } + // Switch to manual mode if no available playlists + switchLinkMode('manual'); + } else { + // Populate dropdown with only unlinked playlists + select.innerHTML = '' + + availablePlaylists.map(p => + `` + ).join(''); + } + } else { + // Re-filter in case playlists were linked since last fetch + const select = document.getElementById('link-spotify-select'); + const availablePlaylists = spotifyUserPlaylists.filter(p => !p.isLinked); + + if (availablePlaylists.length === 0) { + select.innerHTML = ''; + switchLinkMode('manual'); + } else { + select.innerHTML = '' + + availablePlaylists.map(p => + `` + ).join(''); + } + } + openModal('link-playlist-modal'); } async function linkPlaylist() { const jellyfinId = document.getElementById('link-jellyfin-id').value; const name = document.getElementById('link-jellyfin-name').value; - const spotifyId = document.getElementById('link-spotify-id').value.trim(); + const syncSchedule = document.getElementById('link-sync-schedule').value.trim(); - if (!spotifyId) { - showToast('Spotify Playlist ID is required', 'error'); + // Validate sync schedule (basic cron format check) + if (!syncSchedule) { + showToast('Sync schedule is required', 'error'); return; } + const cronParts = syncSchedule.split(/\s+/); + if (cronParts.length !== 5) { + showToast('Invalid cron format. Expected: minute hour day month dayofweek', 'error'); + return; + } + + // Get Spotify ID based on current mode + let spotifyId = ''; + if (currentLinkMode === 'select') { + spotifyId = document.getElementById('link-spotify-select').value; + if (!spotifyId) { + showToast('Please select a Spotify playlist', 'error'); + return; + } + } else { + spotifyId = document.getElementById('link-spotify-id').value.trim(); + if (!spotifyId) { + showToast('Spotify Playlist ID is required', 'error'); + return; + } + } + // Extract ID from various Spotify formats: // - spotify:playlist:37i9dQZF1DXcBWIGoYBM5M // - https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M @@ -1935,7 +2263,11 @@ const res = await fetch(`/api/admin/jellyfin/playlists/${encodeURIComponent(jellyfinId)}/link`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ name, spotifyPlaylistId: cleanSpotifyId }) + body: JSON.stringify({ + name, + spotifyPlaylistId: cleanSpotifyId, + syncSchedule: syncSchedule + }) }); const data = await res.json(); @@ -1945,6 +2277,9 @@ showRestartBanner(); closeModal('link-playlist-modal'); + // Clear the Spotify playlists cache so it refreshes next time + spotifyUserPlaylists = []; + // Update UI state without refetching all playlists const playlistsTable = document.getElementById('jellyfinPlaylistsTable'); if (playlistsTable) { @@ -1982,6 +2317,9 @@ showToast('Playlist unlinked.', 'success'); showRestartBanner(); + // Clear the Spotify playlists cache so it refreshes next time + spotifyUserPlaylists = []; + // Update UI state without refetching all playlists const playlistsTable = document.getElementById('jellyfinPlaylistsTable'); if (playlistsTable) { @@ -2020,18 +2358,18 @@ } async function clearPlaylistCache(name) { - if (!confirm(`Clear cache and rebuild for "${name}"?\n\nThis will:\n• Clear Redis cache\n• Delete file caches\n• Rebuild with latest Spotify IDs\n\nThis may take a minute.`)) return; + if (!confirm(`Rebuild "${name}" from scratch?\n\nThis will:\n• Fetch fresh Spotify playlist data\n• Clear all caches\n• Re-match all tracks\n\nUse this when the Spotify playlist has changed.\n\nThis may take a minute.`)) return; try { // Show warning banner document.getElementById('matching-warning-banner').style.display = 'block'; - showToast(`Clearing cache for ${name}...`, 'info'); + showToast(`Rebuilding ${name} from scratch...`, 'info'); const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/clear-cache`, { method: 'POST' }); const data = await res.json(); if (res.ok) { - showToast(`✓ ${data.message} (Cleared ${data.clearedKeys} cache keys, ${data.clearedFiles} files)`, 'success', 5000); + showToast(`✓ ${data.message}`, 'success', 5000); // Refresh the playlists table after a delay to show updated counts setTimeout(() => { fetchPlaylists(); @@ -2039,7 +2377,7 @@ document.getElementById('matching-warning-banner').style.display = 'none'; }, 3000); } else { - showToast(data.error || 'Failed to clear cache', 'error'); + showToast(data.error || 'Failed to rebuild playlist', 'error'); document.getElementById('matching-warning-banner').style.display = 'none'; } } catch (error) { @@ -2053,7 +2391,7 @@ // Show warning banner document.getElementById('matching-warning-banner').style.display = 'block'; - showToast(`Matching tracks for ${name}...`, 'success'); + showToast(`Re-matching local tracks for ${name}...`, 'info'); const res = await fetch(`/api/admin/playlists/${encodeURIComponent(name)}/match`, { method: 'POST' }); const data = await res.json(); @@ -2066,17 +2404,17 @@ document.getElementById('matching-warning-banner').style.display = 'none'; }, 2000); } else { - showToast(data.error || 'Failed to match tracks', 'error'); + showToast(data.error || 'Failed to re-match tracks', 'error'); document.getElementById('matching-warning-banner').style.display = 'none'; } } catch (error) { - showToast('Failed to match tracks', 'error'); + showToast('Failed to re-match tracks', 'error'); document.getElementById('matching-warning-banner').style.display = 'none'; } } async function matchAllPlaylists() { - if (!confirm('Match tracks for ALL playlists? This may take a few minutes.')) return; + if (!confirm('Re-match local tracks for ALL playlists?\n\nUse this when your local library has changed.\n\nThis may take a few minutes.')) return; try { // Show warning banner @@ -2345,6 +2683,39 @@ } } + async function editPlaylistSchedule(playlistName, currentSchedule) { + const newSchedule = prompt(`Edit sync schedule for "${playlistName}"\n\nCron format: minute hour day month dayofweek\nExamples:\n• 0 8 * * 1 = Monday 8 AM\n• 0 6 * * * = Daily 6 AM\n• 0 20 * * 5 = Friday 8 PM\n\nUse https://crontab.guru/ to build your schedule`, currentSchedule); + + if (!newSchedule || newSchedule === currentSchedule) return; + + // Validate cron format + const cronParts = newSchedule.trim().split(/\s+/); + if (cronParts.length !== 5) { + showToast('Invalid cron format. Expected: minute hour day month dayofweek', 'error'); + return; + } + + try { + const res = await fetch(`/api/admin/playlists/${encodeURIComponent(playlistName)}/schedule`, { + method: 'PUT', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ syncSchedule: newSchedule.trim() }) + }); + + if (res.ok) { + showToast('Sync schedule updated!', 'success'); + showRestartBanner(); + fetchPlaylists(); + } else { + const error = await res.json(); + showToast(error.error || 'Failed to update schedule', 'error'); + } + } catch (error) { + console.error('Failed to update schedule:', error); + showToast('Failed to update schedule', 'error'); + } + } + async function removePlaylist(name) { if (!confirm(`Remove playlist "${name}"?`)) return; @@ -2374,8 +2745,23 @@ try { const res = await fetch('/api/admin/playlists/' + encodeURIComponent(name) + '/tracks'); + + if (!res.ok) { + console.error('Failed to fetch tracks:', res.status, res.statusText); + document.getElementById('tracks-list').innerHTML = '

Failed to load tracks: ' + res.status + ' ' + res.statusText + '

'; + return; + } + const data = await res.json(); + console.log('Tracks data received:', data); + + if (!data || !data.tracks) { + console.error('Invalid data structure:', data); + document.getElementById('tracks-list').innerHTML = '

Invalid data received from server

'; + return; + } + if (data.tracks.length === 0) { document.getElementById('tracks-list').innerHTML = '

No tracks found

'; return; @@ -2399,7 +2785,7 @@ } } else if (t.isLocal === false) { const provider = capitalizeProvider(t.externalProvider) || 'External'; - statusBadge = `${escapeHtml(provider)}`; + statusBadge = `${escapeHtml(provider)}`; // Add manual mapping indicator for external tracks if (t.isManualMapping && t.manualMappingType === 'external') { statusBadge += 'Manual'; @@ -2422,7 +2808,7 @@ style="margin-left:4px;font-size:0.75rem;padding:4px 8px;background:var(--warning);border-color:var(--warning);">Map to External`; } else { // isLocal is null/undefined - track is missing (not found locally or externally) - statusBadge = 'Missing'; + statusBadge = 'Missing'; // Add both mapping buttons for missing tracks const firstArtist = (t.artists && t.artists.length > 0) ? t.artists[0] : ''; mapButton = `
Name Spotify IDSync Schedule Tracks Completion Cache Age
+ Loading playlists...
No playlists configured. Link playlists from the Jellyfin Playlists tab.
No playlists configured. Link playlists from the Jellyfin Playlists tab.
${escapeHtml(p.name)} ${p.id || '-'} + ${escapeHtml(syncSchedule)} + + ${statsHtml}${breakdown}
-
-
+
+
${completionPct}%
${p.cacheAge || '-'} - - + +