fix: use absolute path for IPA creation

- Backend: Return full metadata (Track, Disc, Year) from Tidal/Qobuz/Amazon download results
- Flutter: Use backend metadata for tagging converted M4A and history entries
- Fix: Duplicate convertTrack method in deezer.go
- Fix: Better error message for Deezer fallback failure
- Changed: Default service fallback to Tidal -> Qobuz -> Amazon
- Build: Re-enabled resource shrinking and minification for release build

.github/workflows/release.yml

@@ -85,7 +85,19 @@ jobs:
           restore-keys: gradle-${{ runner.os }}-
 
       - name: Install Android SDK & NDK
-        uses: android-actions/setup-android@v3
+        run: |
+          # Use pre-installed Android SDK on GitHub runners
+          echo "ANDROID_HOME=$ANDROID_HOME"
+          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT"
+          
+          # Accept licenses
+          yes | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses || true
+          
+          # Install NDK (required for gomobile)
+          $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "ndk;25.2.9519653" "platforms;android-34" "build-tools;34.0.0"
+          
+          # Set NDK path
+          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/25.2.9519653" >> $GITHUB_ENV
 
       - name: Install gomobile
         run: |
@@ -113,7 +125,14 @@ jobs:
         run: dart run flutter_launcher_icons
 
       - name: Build APK (Release - unsigned)
-        run: flutter build apk --release --split-per-abi
+        run: |
+          flutter build apk --release --split-per-abi || true
+          # Verify APKs were created
+          ls -la build/app/outputs/flutter-apk/
+          if [ ! -f "build/app/outputs/flutter-apk/app-arm64-v8a-release.apk" ]; then
+            echo "ERROR: APK not found!"
+            exit 1
+          fi
 
       - name: Sign APKs
         uses: r0adkll/sign-android-release@v1
@@ -253,17 +272,43 @@ jobs:
         run: dart run flutter_launcher_icons
 
       - name: Build iOS (unsigned)
-        run: flutter build ios --release --no-codesign
+        run: |
+          # Build Flutter iOS without codesigning
+          flutter build ios --release --no-codesign --config-only
+          
+          # Use xcodebuild with code signing disabled
+          cd ios
+          xcodebuild -workspace Runner.xcworkspace \
+            -scheme Runner \
+            -configuration Release \
+            -sdk iphoneos \
+            -destination 'generic/platform=iOS' \
+            -archivePath build/Runner.xcarchive \
+            archive \
+            CODE_SIGNING_ALLOWED=NO \
+            CODE_SIGNING_REQUIRED=NO \
+            CODE_SIGN_IDENTITY="" \
+            DEVELOPMENT_TEAM=""
 
       - name: Create IPA
         run: |
           VERSION=${{ needs.get-version.outputs.version }}
           mkdir -p build/ios/ipa
-          cd build/ios/iphoneos
+          cd ios/build/Runner.xcarchive/Products/Applications
           mkdir Payload
           cp -r Runner.app Payload/
-          zip -r ../ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa Payload
+          # Use absolute path to avoid relative path issues
+          zip -r $GITHUB_WORKSPACE/build/ios/ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa Payload
           rm -rf Payload
+          
+      - name: Verify IPA created
+        run: |
+          ls -la build/ios/ipa/
+          VERSION=${{ needs.get-version.outputs.version }}
+          if [ ! -f "build/ios/ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa" ]; then
+            echo "ERROR: IPA not created!"
+            exit 1
+          fi
 
       - name: Upload IPA artifact
         uses: actions/upload-artifact@v4

.gitignore

@@ -49,3 +49,4 @@ ios/Pods/
 ios/.symlinks/
 ios/Flutter/Flutter.framework/
 ios/Flutter/Flutter.podspec
+android/app/libs/gobackend-sources.jar

CHANGELOG.md

@@ -1,8 +1,251 @@
 # Changelog
 
+## [2.1.6] - 2026-01-08
+
+### Added
+
+- **Metadata Enrichment**: Automatically fetches full track details if metadata is incomplete (e.g., Track Number 0)
+  - Fixes missing Track Number, Disc Number, and Year for tracks added from Search results
+  - Ensures accurate tagging for Deezer/Tidal downloads
+- **ISRC Index Building**: Fast duplicate checking with cached ISRC index
+
+  - Scans download folder once and builds index of all ISRCs
+  - 5 minute cache TTL for optimal performance
+  - Parallel duplicate checking for album/playlist tracks
+  - Auto-adds new downloads to index (no rebuild needed)
+
+- **Japanese to Romaji Search**: Better search results for Japanese tracks
+
+  - Converts Hiragana/Katakana to Romaji for Tidal/Qobuz search
+  - 4 fallback search strategies (like PC version):
+    1. Original text (artist + track)
+    2. Romaji converted (artist + track)
+    3. ASCII-only cleaned version
+    4. Artist name only as last resort
+  - Handles combination characters (きゃ →kya, シャ →sha, etc.)
+
+- **SongLink Deezer Support**: Query SongLink using Deezer ID as source
+
+  - `CheckAvailabilityFromDeezer()` - find track on other platforms using Deezer ID
+  - `CheckAvailabilityByPlatform()` - generic function for any platform
+  - `GetSpotifyIDFromDeezer()`, `GetTidalURLFromDeezer()`, `GetAmazonURLFromDeezer()`
+  - Useful when starting from Deezer metadata
+
+- **LRC Metadata Headers**: Lyrics now include metadata headers
+
+  - `[ti:Track Name]` - track title
+  - `[ar:Artist Name]` - artist name
+  - `[by:SpotiFLAC-Mobile]` - generator tag
+
+- **Download Error Types**: Better error categorization for UI
+
+  - `not_found` - track not available on any service
+  - `rate_limit` - API rate limit exceeded
+  - `network` - connection/timeout errors
+  - `unknown` - other errors
+
+- **Amazon Rate Limiting**: Proper rate limiting for Amazon via SongLink
+  - 7 second minimum delay between requests
+  - Max 9 requests per minute
+  - 3x retry with 15s wait on 429 rate limit
+
+### Fixed
+
+- **SongLink 400 Error**: Added validation for empty Spotify ID
+
+  - Specific error messages for 400, 404, 429 status codes
+  - Better error handling for invalid track IDs
+
+- **gomobile Compatibility**: Fixed `ISRCIndex.Lookup()` signature
+  - Changed from `(string, bool)` to `(string, error)` for gomobile binding
+
+### Technical
+
+- New file: `go_backend/romaji.go` with Japanese to Romaji conversion
+- New file: `go_backend/duplicate.go` with ISRC index building
+- Updated `go_backend/tidal.go` and `go_backend/qobuz.go` with romaji search strategies
+- Updated `go_backend/songlink.go` with Deezer support functions
+- Updated `go_backend/exports.go` with new export functions for Flutter
+- Updated `go_backend/lyrics.go` with `convertToLRCWithMetadata()`
+- Updated `go_backend/progress.go` with `SpeedMBps` field
+- Updated `lib/models/download_item.dart` with `DownloadErrorType` enum
+- Updated `lib/screens/queue_tab.dart` with speed display and error messages
+
+---
+
+## [2.1.6-preview] - 2026-01-08
+
+### Added
+
+- **Deezer as Alternative Metadata Source**: Choose between Deezer or Spotify for search
+
+  - Configure in Settings > Options > Spotify API > Search Source
+  - Default is Deezer for better reliability
+  - Spotify URLs are always supported regardless of this setting
+
+- **Automatic Deezer Fallback for Spotify URLs**: When Spotify API is rate limited (429), automatically falls back to Deezer
+  - Uses SongLink/Odesli API to convert Spotify track/album ID to Deezer ID
+  - Fetches metadata from Deezer instead
+
+### Changed
+
+- **Default Download Service**: Changed from Tidal to Qobuz
+  - Fallback order is now: Qobuz → Tidal → Amazon
+- **Deezer API Updated to v2.0**: More reliable and complete metadata
+  - Direct ISRC lookup via `/track/isrc:{ISRC}` endpoint
+  - Search results now fetch full track info to include ISRC
+
+### Fixed
+
+- **Progress Bar Not Updating**: Fixed bug where download progress jumped from 1% directly to 100%
+  - Progress now updates smoothly every 64KB of data received
+  - First progress update happens immediately when download starts
+- **Incomplete Downloads**: Fixed bug where interrupted downloads could result in corrupted/incomplete files
+  - File size is validated against server's Content-Length header
+  - Incomplete files are automatically deleted and error is reported
+  - Applies to all services: Tidal, Qobuz, and Amazon
+- **ISRC Not Available from Deezer Search**: Search results now fetch full track details to get ISRC
+
+### Technical
+
+- Settings migration for existing users to set Deezer as default metadata source
+
+---
+
+## [2.1.5] - 2026-01-08
+
+### Added
+
+- **Service Switcher in Quality Picker**: Choose download service (Tidal/Qobuz/Amazon) directly when selecting quality
+  - Service selector chips appear above quality options
+  - Defaults to your preferred service from settings
+  - Change service on-the-fly without going to settings
+  - Available in Home, Album, and Playlist screens
+- **AMOLED Dark Theme**: Pure black background for OLED screens
+  - Toggle in Settings > Appearance > Theme
+  - Saves battery on OLED/AMOLED displays
+  - All surface colors adjusted for true black background
+- **Update Channel Setting**: Choose between Stable and Preview release channels
+  - Stable: Only receive stable release notifications
+  - Preview: Get notified about preview/beta releases too
+  - Configure in Settings > Options > App
+
+### Changed
+
+- **Reduced APK Size**: Replaced FFmpeg plugin with custom AAR containing only required codecs
+  - arm64 APK: 46.6 MB (previously 51 MB)
+  - arm32 APK: 59 MB (previously 64 MB)
+  - Only includes FLAC, MP3 (LAME), and AAC codecs
+  - Custom FFmpeg AAR with arm64-v8a and armeabi-v7a only
+  - Native MethodChannel bridge for FFmpeg operations
+  - Separate iOS build configuration with ffmpeg_kit_flutter plugin
+
+### Fixed
+
+- **Retry Failed Downloads**: Fixed issue where retrying failed downloads sometimes did nothing
+  - Now properly handles retry when queue processing has finished
+  - Also allows retrying skipped (cancelled) downloads
+- **Lyrics Loading Timeout**: Added 20 second timeout for lyrics fetching
+  - Shows "Lyrics not available" instead of loading forever
+- **iOS Directory Picker**: Fixed unable to select download folder on iOS
+  - iOS limitation: Empty folders cannot be selected via document picker
+  - Added "App Documents Folder" option as recommended default
+  - Files saved to app Documents folder are accessible via iOS Files app
+
+### Performance
+
+- **Download Speed Optimizations**: Significant improvements to download initialization and throughput
+  - Token caching for Tidal (eliminates redundant auth requests)
+  - Singleton pattern for all downloaders (HTTP connection reuse)
+  - ISRC search first strategy (faster than SongLink API)
+  - Track ID cache with 30 minute TTL for album/playlist downloads
+  - Pre-warm cache when viewing album/playlist
+  - Parallel cover art and lyrics fetching during audio download
+  - 64KB HTTP read/write buffers
+  - 256KB buffered file writer for all downloaders
+  - Progress updates every 64KB (reduced lock contention)
+- **Amazon Music Optimizations**: Same optimizations now applied to Amazon downloader
+
+## [2.1.0-preview2] - 2026-01-06
+
+### Added
+
+- **Service Switcher in Quality Picker**: Choose download service (Tidal/Qobuz/Amazon) directly when selecting quality
+  - Service selector chips appear above quality options
+  - Defaults to your preferred service from settings
+  - Change service on-the-fly without going to settings
+  - Available in Home, Album, and Playlist screens
+- **AMOLED Dark Theme**: Pure black background for OLED screens
+  - Toggle in Settings > Appearance > Theme
+  - Saves battery on OLED/AMOLED displays
+  - All surface colors adjusted for true black background
+- **Update Channel Setting**: Choose between Stable and Preview release channels
+  - Stable: Only receive stable release notifications
+  - Preview: Get notified about preview/beta releases too
+  - Configure in Settings > Options > App
+
+### Fixed
+
+- **Retry Failed Downloads**: Fixed issue where retrying failed downloads sometimes did nothing
+  - Now properly handles retry when queue processing has finished
+  - Also allows retrying skipped (cancelled) downloads
+  - Added logging for better debugging
+- **Lyrics Loading Timeout**: Added 20 second timeout for lyrics fetching
+  - Shows "Lyrics not available" instead of loading forever
+  - Better error messages for timeout and not found cases
+
+## [2.1.0-preview] - 2026-01-06
+
+### Performance
+
+- **Download Speed Optimizations**: Significant improvements to download initialization and throughput
+  - Token caching for Tidal (eliminates redundant auth requests)
+  - Singleton pattern for all downloaders (HTTP connection reuse)
+  - ISRC search first strategy (faster than SongLink API)
+  - Track ID cache with 30 minute TTL for album/playlist downloads
+  - Pre-warm cache when viewing album/playlist
+  - Parallel cover art and lyrics fetching during audio download
+  - 64KB HTTP read/write buffers
+  - 256KB buffered file writer for all downloaders
+  - Progress updates every 64KB (reduced lock contention)
+- **Amazon Music Optimizations**: Same optimizations now applied to Amazon downloader
+
+### Technical
+
+- New `go_backend/parallel.go` with `TrackIDCache`, `FetchCoverAndLyricsParallel()`, `PreWarmTrackCache()`
+- Flutter: `_preWarmCacheForTracks()` in `track_provider.dart`
+- New method channels: `preWarmTrackCache`, `getTrackCacheSize`, `clearTrackCache`
+
+## [2.0.7-preview2] - 2026-01-06
+
+### Fixed
+
+- **iOS Directory Picker**: Fixed unable to select download folder on iOS
+  - iOS limitation: Empty folders cannot be selected via document picker
+  - Added "App Documents Folder" option as recommended default
+  - Shows info message explaining iOS limitation
+  - Files saved to app Documents folder are accessible via iOS Files app
+
+## [2.0.7-preview] - 2026-01-05
+
+### Changed
+
+- **Reduced APK Size**: Replaced FFmpeg plugin with custom AAR containing only required codecs
+  - arm64 APK: 46.6 MB (previously 51 MB)
+  - arm32 APK: 59 MB (previously 64 MB)
+  - Only includes FLAC, MP3 (LAME), and AAC codecs
+  - Removed x86/x86_64 architectures (emulator only)
+
+### Technical
+
+- Custom FFmpeg AAR with arm64-v8a and armeabi-v7a only
+- Native MethodChannel bridge for FFmpeg operations
+- Separate iOS build configuration with ffmpeg_kit_flutter plugin
+
 ## [2.0.6] - 2026-01-05
 
 ### Fixed
+
 - **Duration Display Bug**: Fixed duration showing incorrect values like "4135:53" instead of "4:14"
   - `duration_ms` (milliseconds) was being stored directly without conversion to seconds
   - Now properly converts milliseconds to seconds before display
@@ -22,14 +265,17 @@
 ## [2.0.5] - 2026-01-05
 
 ### Added
+
 - **Large Playlist Support**: Playlists with up to 1000 tracks are now fully fetched (was limited to 100)
 
 ### Fixed
+
 - **Wrong Track Download**: Fixed issue where tracks with same ISRC but different versions (e.g., short/instrumental vs full version) would download the wrong track. Now verifies duration matches before downloading (30 second tolerance).
 
 ## [2.0.4] - 2026-01-04
 
 ### Fixed
+
 - **Android 11 Storage Permission**: Fixed "Permission denied" error on Android 11 (API 30) devices
   - Added `MANAGE_EXTERNAL_STORAGE` permission for Android 11-12
   - Shows explanation dialog before opening system settings
@@ -37,6 +283,7 @@
 ## [2.0.3] - 2026-01-03
 
 ### Added
+
 - **Custom Spotify API Credentials**: Set your own Spotify Client ID and Secret in Settings > Options to avoid rate limiting
   - Toggle to enable/disable custom credentials without deleting them
   - Material Expressive 3 bottom sheet UI for entering credentials
@@ -44,9 +291,11 @@
 - **Rate Limit Error UI**: Shows friendly error card when API rate limit (429) is hit on Home, Artist, and Album screens
 
 ### Changed
+
 - **Search on Enter Only**: Removed auto-search debounce, now only searches when pressing Enter key (saves API calls)
 
 ### Fixed
+
 - **Download Cancel**: Fixed cancelled downloads still completing in background and appearing in history. Cancelled files are now properly deleted.
 - **Search Keyboard Dismiss**: Fixed keyboard randomly dismissing and navigating back when starting to search
 - **Back Button During Search**: Back button now properly dismisses keyboard first before clearing search
@@ -56,6 +305,7 @@
 ## [2.0.2] - 2026-01-03
 
 ### Added
+
 - **Actual Quality Display**: Shows real audio quality (bit depth/sample rate) after download
   - Quality badge on download history items (e.g., "24-bit", "16-bit")
   - Full quality info in Track Metadata screen (e.g., "24-bit/96kHz")
@@ -64,13 +314,16 @@
 - **Instant Lyrics Loading**: Lyrics now load from embedded file first (instant) before falling back to internet fetch
 
 ### Fixed
+
 - **Fallback Service Display**: Fixed download history showing wrong service when fallback occurs (e.g., showing "TIDAL" when actually downloaded from "QOBUZ")
 - **Open in Spotify**: Fixed "Open in Spotify" button not opening Spotify app correctly
 
 ### Removed
+
 - **Romaji Conversion**: Removed Japanese lyrics to romaji conversion feature (Kanji not supported, results were incomplete)
 
 ### Technical
+
 - Go backend now returns `actual_bit_depth` and `actual_sample_rate` in download response
 - Go backend now returns `service` field indicating actual service used (important for fallback)
 - Tidal API v2 response provides exact quality info
@@ -80,18 +333,21 @@
 ## [2.0.1] - 2026-01-03
 
 ### Added
+
 - **Quality Picker Track Info**: Shows track name, artist, and cover in quality picker
   - Tap to expand long track titles
   - Expand icon only shows when title is truncated
   - Ripple effect follows rounded corners including drag handle
 
 ### Changed
+
 - **Unified Progress Tracking System**: Deprecated legacy single-download progress
   - All downloads now use item-based progress tracking
   - Fixes duplicate notification bug when finalizing
   - Cleaner codebase with single progress system
 
 ### Fixed
+
 - **Duplicate Notification Bug**: Fixed issue where "Finalizing" and "Downloading" notifications appeared simultaneously
 - **Update Notification Stuck**: Fixed notification staying at 100% after download completes
 - **Quality Picker Consistency**: Unified quality picker UI across all screens (Home, Album, Playlist)
@@ -101,6 +357,7 @@
 ## [2.0.0] - 2026-01-03
 
 ### Added
+
 - **Artist Search Results**: Search now shows artists alongside tracks
   - Horizontal scrollable artist cards with circular avatars
   - Tap artist to view their discography
@@ -121,11 +378,12 @@
   - Stable users won't receive update notifications for preview versions
 
 ### Changed
+
 - **Instant Navigation UX**: Navigate to Artist/Album screens immediately
   - Header (name, cover) shows instantly from available data
   - Content (albums/tracks) loads in background inside the screen
   - Second visit to same artist/album is instant from Flutter cache
-- **Search Results UI Redesign**: 
+- **Search Results UI Redesign**:
   - Removed "Download All" button from search results
   - Added "Songs" section header (matches "Artists" header style)
   - Track list now in grouped card with rounded corners (like Settings)
@@ -148,6 +406,7 @@
 - **Ask Before Download Default**: Now enabled by default for better UX
 
 ### Fixed
+
 - **Artist Profile Images**: Fixed artist images not showing in search results (field name mismatch)
 - **Album Card Overflow**: Fixed 5px overflow in artist discography album cards
 - **Optimized Rebuilds**: Each track item only rebuilds when its own status changes
@@ -158,6 +417,7 @@
 ## [1.6.3] - 2026-01-03
 
 ### Added
+
 - **Predictive Back Navigation**: Support for Android 14+ predictive back gesture with smooth animations
 - **Separate Detail Screens**: Album, Artist, and Playlist now open as dedicated screens with Material Expressive 3 design
   - Collapsing header with cover art and gradient overlay
@@ -167,6 +427,7 @@
 - **Double-Tap to Exit**: Press back twice to exit app when at home screen (replaces exit dialog)
 
 ### Changed
+
 - **Navigation Architecture**: Refactored from state-based to screen-based navigation
   - Album/Artist/Playlist URLs navigate to dedicated screens via `Navigator.push()`
   - Enables native predictive back gesture animations
@@ -176,17 +437,21 @@
 ## [1.6.2] - 2026-01-02
 
 ### Added
+
 - **HTTPS-Only Downloads**: APK downloads and update checks now enforce HTTPS-only connections for security
 
 ### Changed
+
 - **Home Tab Rename**: Renamed "Search" tab to "Home" with home icon
 - **Branding**: Changed idle screen title from "Search Music" to "SpotiFLAC"
 - **About Page Redesign**: New Material Expressive 3 grouped layout with app header, contributors section with GitHub avatars, and organized links
 
 ### Fixed
+
 - **Play Button Flash**: Fixed play button briefly showing red error icon on app start (now uses optimistic rendering)
 
 ### Performance
+
 - **Optimized State Management**: Use `.select()` for Riverpod providers to prevent unnecessary widget rebuilds
 - **List Keys**: Added keys to all list builders for efficient list updates and reordering
 - **Request Cancellation**: Outdated API requests are ignored when new search/fetch is triggered
@@ -198,12 +463,14 @@
 ## [1.6.1] - 2026-01-02
 
 ### Added
+
 - **Background Download Service**: Downloads now continue running when app is in background
   - Foreground service with wake lock prevents Android from killing downloads
   - Persistent notification shows download progress
   - No more "connection abort" errors when switching apps
 
 ### Fixed
+
 - **Share Intent App Restart**: Fixed download queue being lost when sharing from Spotify while downloads are in progress
   - Download queue is now persisted to storage and automatically restored on app restart
   - Interrupted downloads (marked as "downloading") are reset to "queued" and auto-resumed
@@ -212,11 +479,13 @@
 - **Back Button During Loading**: Back button no longer clears state while loading shared URL
 
 ### Changed
+
 - **Kotlin**: Upgraded from 2.2.20 to 2.3.0 for better plugin compatibility
 
 ## [1.6.0] - 2026-01-02
 
 ### Added
+
 - **Manual Quality Selection**: New option to choose audio quality before each download
   - Toggle "Ask Before Download" in Download Settings
   - When enabled, shows quality picker (Lossless, Hi-Res, Hi-Res Max) before downloading
@@ -231,12 +500,14 @@
 - **Share Audio File**: Share downloaded tracks to other apps from Track Metadata screen
 
 ### Fixed
+
 - **Update Checker**: Fixed version comparison for versions with suffix (e.g., `1.5.0-hotfix6`)
   - Users on hotfix versions now properly receive update notifications
   - Handles `-hotfix`, `-beta`, `-rc` suffixes correctly
 - **Settings Ripple Effect**: Fixed splash/ripple effect to properly clip within rounded card corners
 
 ### Changed
+
 - **Settings UI Redesign**: New Android-style grouped settings with connected cards
   - Items in same group are connected with rounded card container
   - Section headers outside cards for clear visual hierarchy
@@ -245,6 +516,7 @@
 - **Consistent Header Position**: Fixed Search tab header alignment to match History and Settings tabs
 
 ### Improved
+
 - **Code Quality**: Replaced all `print()` statements with structured logging using `logger` package
 - **Dependencies Updated**:
   - `share_plus`: 10.1.4 → 12.0.1
@@ -254,6 +526,7 @@
 ## [1.5.5] - 2026-01-02
 
 ### Added
+
 - **Share to App**: Share Spotify links directly from Spotify app or browser to SpotiFLAC
   - Supports track, album, playlist, and artist URLs
   - Auto-fetches metadata when link is shared
@@ -280,6 +553,7 @@
 - **Exit Confirmation**: Dialog prompt when pressing back to exit app (only at root)
 
 ### Changed
+
 - **Downloads Tab Renamed to History**: Better reflects the tab's purpose
   - Shows download queue at top when active
   - Completed downloads auto-move to history section
@@ -290,11 +564,13 @@
   - Only shows exit dialog when truly at root
 
 ### Fixed
+
 - **Download Progress**: Fixed progress stuck at 0% when using item-based progress tracking (affected sequential downloads after multi-download feature was added)
 - **Artist View State**: Fixed UI state not clearing properly when switching between artist and album views
 - **Share Intent Timing**: Fixed shared URLs not being processed when app was cold-started from share intent
 
 ### Improved
+
 - **Cleaner UI for Returning Users**: Helper text "Supports: Track, Album, Playlist URLs" now only shows for new users and hides after first search
 - **Cleaner Home Tab**: Removed redundant "Recent Downloads" section, renamed to "Search" tab
 - **Centered Search Bar**: Search bar now appears centered on screen when empty, moves to top when results are shown - easier to reach on large phones
@@ -303,26 +579,31 @@
 ## [1.5.0-hotfix6] - 2026-01-02
 
 ### Fixed
+
 - **App Signing**: Use r0adkll/sign-android-release GitHub Action for reliable signing
 
 ## [1.5.0-hotfix5] - 2026-01-02
 
 ### Fixed
+
 - **App Signing**: Use key.properties as per Flutter official documentation
 
 ## [1.5.0-hotfix4] - 2026-01-02
 
 ### Fixed
+
 - **App Signing**: Create keystore.properties in workflow for Gradle
 
 ## [1.5.0-hotfix] - 2026-01-02
 
 ### Important Notice
+
 We apologize for the inconvenience. Previous releases were signed with different keys, causing "package conflicts" errors when upgrading. Starting from this version, all releases will use a consistent signing key.
 
 **If you're upgrading from v1.5.0 or earlier, please uninstall the app first before installing this version.** This is a one-time requirement. Future updates will work seamlessly without uninstalling.
 
 ### Added
+
 - **In-App Update**: Download and install updates directly from the app
   - Progress bar shows download status
   - Automatic device architecture detection (arm64/arm32)
@@ -330,11 +611,13 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Consistent App Signing**: All future releases will use the same signing key
 
 ### Fixed
+
 - **Update Checker**: Now downloads APK directly instead of opening browser
 
 ## [1.5.0] - 2026-01-02
 
 ### Added
+
 - **Download Progress Notification**: Shows notification with download progress percentage while downloading
   - Progress bar in notification during download
   - Completion notification when track finishes
@@ -358,6 +641,7 @@ We apologize for the inconvenience. Previous releases were signed with different
   - Downloads correct APK for your device
 
 ### Changed
+
 - **Recent Downloads**: Now shows up to 10 items (was 5) for better scrolling
 - **Queue UI Redesign**: Card-based layout with clearer status indicators
   - Removed global pause/resume in favor of per-item controls
@@ -382,6 +666,7 @@ We apologize for the inconvenience. Previous releases were signed with different
   - "Add Music" button for quick access
 
 ### Technical
+
 - Added `flutter_local_notifications` package for notifications
 - Added notification permission request in setup screen for Android 13+
 - Enabled core library desugaring for all Android subprojects
@@ -390,6 +675,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 - Updated platform channel handlers for both Android (Kotlin) and iOS (Swift)
 
 ### Performance
+
 - Optimized SliverAppBar: Removed LayoutBuilder that was called every frame during scroll
 - Optimized image caching: Added `memCacheWidth/Height` to CachedNetworkImage for memory efficiency
 - Optimized state management: Use `select()` to only rebuild when specific state changes
@@ -398,6 +684,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 ## [1.2.0] - 2026-01-02
 
 ### Added
+
 - **Track Metadata Screen**: New detailed metadata view when tapping on downloaded tracks
   - Material Expressive 3 design with cover art header and gradient
   - Hero animation from list to detail view
@@ -410,12 +697,14 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Hi-Res Lossless MAX**: New highest quality option for maximum audio fidelity
 
 ### Fixed
+
 - **Hi-Res Quality Bug**: Fixed issue where Hi-Res downloads were stuck at Lossless quality
   - Users on previous versions are recommended to upgrade to get proper Hi-Res downloads
 - **Settings Navigation Bug**: Fixed issue where changing settings (like audio quality) would navigate back to Home tab
 - **Tidal Badge Color**: Fixed unreadable Tidal service badge (was too bright cyan, now darker blue)
 
 ### Changed
+
 - **Recent Downloads**: Tapping on a track now opens metadata screen instead of playing directly
   - Play button still available for quick playback
 - **Download History Model**: Extended with additional metadata fields (albumArtist, isrc, spotifyId, trackNumber, discNumber, duration, releaseDate, quality)
@@ -424,30 +713,34 @@ We apologize for the inconvenience. Previous releases were signed with different
 ## [1.1.2] - 2026-01-01
 
 ### Added
+
 - **Update Checker**: Automatic check for new versions from GitHub releases
   - Shows changelog in update dialog
   - Option to disable update notifications
 - **Release Changelog**: GitHub releases now include full changelog
 
 ### Changed
+
 - Updated version to 1.1.2
 
 ## [1.1.1] - 2026-01-01
 
 ### Fixed
+
 - **About Dialog**: Custom About dialog with cleaner layout
 - **Setup Screen**: Fixed step indicator line alignment
 - **Warning Text**: Fixed parallel downloads warning to use Material theme colors
 - **Copyright Year**: Updated to 2026
 
 ### Changed
+
 - Removed Theme Preview from Settings
 - Added MIT License
 
-
 ## [1.1.0] - 2026-01-01
 
 ### Added
+
 - **Parallel Downloads**: Download up to 3 tracks simultaneously (configurable in Settings)
   - Default: Sequential (1 at a time) for stability
   - Options: 1, 2, or 3 concurrent downloads
@@ -458,15 +751,18 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Connection Cleanup**: Automatic cleanup of idle connections every 50 downloads and at queue end
 
 ### Fixed
+
 - **Download Progress Bug**: Fixed 0% → 100% jump by adding proper progress tracking for BTS format downloads
 - **TCP Connection Exhaustion**: Fixed slow downloads after ~300 tracks by implementing connection pooling and periodic cleanup
 - **Trailing Space in Names**: Fixed download failures when playlist/album/track names have trailing spaces
 - **History Loss on Debug**: History no longer disappears when sideloading via `flutter run --debug`
 
 ### Changed
+
 - Updated version to 1.1.0
 
 ### Technical Details
+
 - Added `concurrentDownloads` field to `AppSettings` model (default: 1, max: 3)
 - Implemented worker pool pattern in `DownloadQueueNotifier` for parallel processing
 - Added `SetCurrentFile()`, `SetBytesTotal()`, and `ProgressWriter` for BTS downloads in Go backend
@@ -475,6 +771,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 - Added `CleanupConnections()` export for Flutter to call via method channel
 
 ## [1.0.5] - Previous Release
+
 - Material Expressive 3 UI
 - Dynamic color support
 - Swipe navigation with PageView

README.md

@@ -1,4 +1,5 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/zarzet/SpotiFLAC-Mobile/total?style=for-the-badge)](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
+[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/ca16289599f71b8e50d3726a8c64a202ea922a1893bcf21b9eca1a050736f1f5/)
 
 <div align="center">
 
@@ -22,11 +23,30 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
   <img src="assets/images/4.jpg?v=2" width="200" />
 </p>
 
+## Metadata Source
+
+SpotiFLAC supports two metadata sources for searching tracks:
+
+| Source | Pros | Cons |
+|--------|------|------|
+| **Deezer** (Default) | No developer account needed, rate limit per user IP | Slightly less comprehensive catalog |
+| **Spotify** | More comprehensive catalog, better search results | Requires developer API credentials to avoid rate limiting |
+
+### Using Spotify
+To use Spotify as your search source without hitting rate limits:
+1. Create a Spotify Developer account at [developer.spotify.com](https://developer.spotify.com)
+2. Create an app to get your Client ID and Client Secret
+3. Go to **Settings > Options > Spotify API > Change from Deezer to Spotify > Input Custom Credentials**
+4. Enter your Client ID and Secret
+5. Change **Search Source** to Spotify
+
 ## Other project
 
 ### [SpotiFLAC (Desktop)](https://github.com/afkarxyz/SpotiFLAC)
 Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux
 
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-Support%20Me-FF5E5B?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/zarzet)
+
 ## Disclaimer
 
 > **iOS Support**: This app is primarily tested on Android. iOS support is experimental and may have bugs — the developer is too poor to afford an iPhone for proper testing. If you encounter issues on iOS, please report them!

android/app/build.gradle.kts

@@ -1,3 +1,6 @@
+import java.util.Properties
+import java.io.FileInputStream
+
 plugins {
     id("com.android.application")
     id("kotlin-android")
@@ -7,9 +10,9 @@ plugins {
 
 // Load keystore properties for local builds
 val keystorePropertiesFile = rootProject.file("key.properties")
-val keystoreProperties = java.util.Properties()
+val keystoreProperties = Properties()
 if (keystorePropertiesFile.exists()) {
-    keystoreProperties.load(java.io.FileInputStream(keystorePropertiesFile))
+    keystoreProperties.load(FileInputStream(keystorePropertiesFile))
 }
 
 android {
@@ -32,10 +35,10 @@ android {
     signingConfigs {
         if (keystorePropertiesFile.exists()) {
             create("release") {
-                keyAlias = keystoreProperties["keyAlias"] as String
-                keyPassword = keystoreProperties["keyPassword"] as String
-                storeFile = file(keystoreProperties["storeFile"] as String)
-                storePassword = keystoreProperties["storePassword"] as String
+                keyAlias = keystoreProperties.getProperty("keyAlias")
+                keyPassword = keystoreProperties.getProperty("keyPassword")
+                storeFile = file(keystoreProperties.getProperty("storeFile"))
+                storePassword = keystoreProperties.getProperty("storePassword")
             }
         }
     }
@@ -94,8 +97,10 @@ repositories {
 
 dependencies {
     coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
-    implementation(files("libs/gobackend.aar"))
-    implementation(files("libs/ffmpeg-kit-with-lame.aar"))
+    
+    // Include all AAR and JAR files from libs folder
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
+    
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
 }

android/app/proguard-rules.pro

@@ -6,6 +6,14 @@
 -keep class io.flutter.** { *; }
 -keep class io.flutter.plugins.** { *; }
 
+# Ignore missing Play Core classes (not used, but referenced by Flutter)
+-dontwarn com.google.android.play.core.splitcompat.**
+-dontwarn com.google.android.play.core.splitinstall.**
+-dontwarn com.google.android.play.core.tasks.**
+
+# Ignore missing javax.xml.stream (not used on Android)
+-dontwarn javax.xml.stream.**
+
 # Go backend (gobackend.aar)
 -keep class gobackend.** { *; }
 -keep class go.** { *; }
@@ -14,6 +22,9 @@
 -keep class com.arthenica.ffmpegkit.** { *; }
 -keep class com.arthenica.smartexception.** { *; }
 
+# Apache Tika (if used by FFmpeg)
+-dontwarn org.apache.tika.**
+
 # Keep native methods
 -keepclasseswithmembernames class * {
     native <methods>;

android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt

@@ -211,6 +211,72 @@ class MainActivity: FlutterActivity() {
                             }
                             result.success(null)
                         }
+                        "preWarmTrackCache" -> {
+                            val tracksJson = call.argument<String>("tracks") ?: "[]"
+                            withContext(Dispatchers.IO) {
+                                Gobackend.preWarmTrackCacheJSON(tracksJson)
+                            }
+                            result.success(null)
+                        }
+                        "getTrackCacheSize" -> {
+                            val size = withContext(Dispatchers.IO) {
+                                Gobackend.getTrackCacheSize()
+                            }
+                            result.success(size.toInt())
+                        }
+                        "clearTrackCache" -> {
+                            withContext(Dispatchers.IO) {
+                                Gobackend.clearTrackIDCache()
+                            }
+                            result.success(null)
+                        }
+                        // Deezer API methods
+                        "searchDeezerAll" -> {
+                            val query = call.argument<String>("query") ?: ""
+                            val trackLimit = call.argument<Int>("track_limit") ?: 15
+                            val artistLimit = call.argument<Int>("artist_limit") ?: 3
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchDeezerAll(query, trackLimit.toLong(), artistLimit.toLong())
+                            }
+                            result.success(response)
+                        }
+                        "getDeezerMetadata" -> {
+                            val resourceType = call.argument<String>("resource_type") ?: ""
+                            val resourceId = call.argument<String>("resource_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getDeezerMetadata(resourceType, resourceId)
+                            }
+                            result.success(response)
+                        }
+                        "parseDeezerUrl" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.parseDeezerURLExport(url)
+                            }
+                            result.success(response)
+                        }
+                        "searchDeezerByISRC" -> {
+                            val isrc = call.argument<String>("isrc") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchDeezerByISRC(isrc)
+                            }
+                            result.success(response)
+                        }
+                        "convertSpotifyToDeezer" -> {
+                            val resourceType = call.argument<String>("resource_type") ?: ""
+                            val spotifyId = call.argument<String>("spotify_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.convertSpotifyToDeezer(resourceType, spotifyId)
+                            }
+                            result.success(response)
+                        }
+                        "getSpotifyMetadataWithFallback" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getSpotifyMetadataWithDeezerFallback(url)
+                            }
+                            result.success(response)
+                        }
                         else -> result.notImplemented()
                     }
                 } catch (e: Exception) {

build_assets/ffmpeg_service_ios.dart

@@ -105,6 +105,78 @@ class FFmpegServiceIOS {
     return null;
   }
 
+  /// Embed metadata and cover art to FLAC file
+  /// Returns the file path on success, null on failure
+  static Future<String?> embedMetadata({
+    required String flacPath,
+    String? coverPath,
+    Map<String, String>? metadata,
+  }) async {
+    final tempOutput = '$flacPath.tmp';
+    
+    // Construct command
+    final StringBuffer cmdBuffer = StringBuffer();
+    cmdBuffer.write('-i "$flacPath" ');
+    
+    // Add cover input if available
+    if (coverPath != null) {
+      cmdBuffer.write('-i "$coverPath" ');
+    }
+    
+    // Map audio stream
+    cmdBuffer.write('-map 0:a ');
+    
+    // Map cover stream if available
+    if (coverPath != null) {
+      cmdBuffer.write('-map 1:0 ');
+      cmdBuffer.write('-c:v copy ');
+      cmdBuffer.write('-disposition:v attached_pic ');
+      cmdBuffer.write('-metadata:s:v title="Album cover" ');
+      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
+    }
+    
+    // Copy audio codec (don't re-encode)
+    cmdBuffer.write('-c:a copy ');
+    
+    // Add text metadata
+    if (metadata != null) {
+      metadata.forEach((key, value) {
+        // Sanitize value: escape double quotes
+        final sanitizedValue = value.replaceAll('"', '\\"');
+        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
+      });
+    }
+    
+    cmdBuffer.write('"$tempOutput" -y');
+    
+    final command = cmdBuffer.toString();
+    _log.d('Executing FFmpeg command: $command');
+
+    final result = await _execute(command);
+
+    if (result.success) {
+      try {
+        await File(flacPath).delete();
+        await File(tempOutput).rename(flacPath);
+        return flacPath;
+      } catch (e) {
+        _log.e('Failed to replace file after metadata embed: $e');
+        return null;
+      }
+    }
+
+    // Clean up temp file if exists
+    try {
+      final tempFile = File(tempOutput);
+      if (await tempFile.exists()) {
+        await tempFile.delete();
+      }
+    } catch (_) {}
+
+    _log.e('Metadata/Cover embed failed: ${result.output}');
+    return null;
+  }
+
   /// Check if FFmpeg is available
   static Future<bool> isAvailable() async {
     try {

go_backend/amazon.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"bufio"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -10,15 +11,26 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 )
 
 // AmazonDownloader handles Amazon Music downloads using DoubleDouble service (same as PC)
 type AmazonDownloader struct {
-	client  *http.Client
-	regions []string // us, eu regions for DoubleDouble service
+	client           *http.Client
+	regions          []string // us, eu regions for DoubleDouble service
+	lastAPICallTime  time.Time // Rate limiting: track last API call
+	apiCallCount     int       // Rate limiting: counter per minute
+	apiCallResetTime time.Time // Rate limiting: reset time
 }
 
+var (
+	// Global Amazon downloader instance for connection reuse
+	globalAmazonDownloader *AmazonDownloader
+	amazonDownloaderOnce   sync.Once
+	amazonRateLimitMu      sync.Mutex // Mutex for rate limiting
+)
+
 // DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
 type DoubleDoubleSubmitResponse struct {
 	Success bool   `json:"success"`
@@ -93,12 +105,57 @@ func amazonIsASCIIString(s string) bool {
 	return true
 }
 
-// NewAmazonDownloader creates a new Amazon downloader using DoubleDouble service
+// NewAmazonDownloader creates a new Amazon downloader (returns singleton for connection reuse)
 func NewAmazonDownloader() *AmazonDownloader {
-	return &AmazonDownloader{
-		client:  NewHTTPClientWithTimeout(120 * time.Second), // 120s timeout like PC
-		regions: []string{"us", "eu"},                        // Same regions as PC
+	amazonDownloaderOnce.Do(func() {
+		globalAmazonDownloader = &AmazonDownloader{
+			client:           NewHTTPClientWithTimeout(120 * time.Second), // 120s timeout like PC
+			regions:          []string{"us", "eu"},                        // Same regions as PC
+			apiCallResetTime: time.Now(),
+		}
+	})
+	return globalAmazonDownloader
+}
+
+// waitForRateLimit implements rate limiting similar to PC version
+// Max 9 requests per minute with 7 second delay between requests
+func (a *AmazonDownloader) waitForRateLimit() {
+	amazonRateLimitMu.Lock()
+	defer amazonRateLimitMu.Unlock()
+
+	now := time.Now()
+	
+	// Reset counter every minute
+	if now.Sub(a.apiCallResetTime) >= time.Minute {
+		a.apiCallCount = 0
+		a.apiCallResetTime = now
 	}
+
+	// If we've hit the limit (9 requests per minute), wait until next minute
+	if a.apiCallCount >= 9 {
+		waitTime := time.Minute - now.Sub(a.apiCallResetTime)
+		if waitTime > 0 {
+			fmt.Printf("[Amazon] Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
+			time.Sleep(waitTime)
+			a.apiCallCount = 0
+			a.apiCallResetTime = time.Now()
+		}
+	}
+
+	// Add delay between requests (7 seconds like PC version)
+	if !a.lastAPICallTime.IsZero() {
+		timeSinceLastCall := now.Sub(a.lastAPICallTime)
+		minDelay := 7 * time.Second
+		if timeSinceLastCall < minDelay {
+			waitTime := minDelay - timeSinceLastCall
+			fmt.Printf("[Amazon] Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
+			time.Sleep(waitTime)
+		}
+	}
+
+	// Update tracking
+	a.lastAPICallTime = time.Now()
+	a.apiCallCount++
 }
 
 // GetAvailableAPIs returns list of available DoubleDouble regions
@@ -129,10 +186,13 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 		serviceDomain, _ := base64.StdEncoding.DecodeString("LmRvdWJsZWRvdWJsZS50b3A=") // .doubledouble.top
 		baseURL := fmt.Sprintf("%s%s%s", string(serviceBase), region, string(serviceDomain))
 
-		// Step 1: Submit download request
+		// Step 1: Submit download request with rate limiting
 		encodedURL := url.QueryEscape(amazonURL)
 		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)
 
+		// Apply rate limiting before request (like PC version)
+		a.waitForRateLimit()
+
 		req, err := http.NewRequest("GET", submitURL, nil)
 		if err != nil {
 			lastError = fmt.Errorf("failed to create request: %w", err)
@@ -142,15 +202,43 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 		req.Header.Set("User-Agent", getRandomUserAgent())
 
 		fmt.Println("[Amazon] Submitting download request...")
-		resp, err := a.client.Do(req)
-		if err != nil {
-			lastError = fmt.Errorf("failed to submit request: %w", err)
-			continue
+		
+		// Retry logic for 429 errors (like PC version: 3 retries with 15s wait)
+		var resp *http.Response
+		maxRetries := 3
+		for retry := 0; retry < maxRetries; retry++ {
+			resp, err = a.client.Do(req)
+			if err != nil {
+				lastError = fmt.Errorf("failed to submit request: %w", err)
+				break
+			}
+
+			if resp.StatusCode == 429 { // Too Many Requests
+				resp.Body.Close()
+				if retry < maxRetries-1 {
+					waitTime := 15 * time.Second
+					fmt.Printf("[Amazon] Rate limited (429), waiting %v before retry %d/%d...\n", waitTime, retry+2, maxRetries)
+					time.Sleep(waitTime)
+					continue
+				}
+				lastError = fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
+				break
+			}
+
+			if resp.StatusCode != 200 {
+				resp.Body.Close()
+				lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+				break
+			}
+
+			// Success - break retry loop
+			break
 		}
 
-		if resp.StatusCode != 200 {
-			resp.Body.Close()
-			lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+		if err != nil || lastError != nil {
+			if resp != nil {
+				resp.Body.Close()
+			}
 			continue
 		}
 
@@ -283,39 +371,69 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}
 
+	expectedSize := resp.ContentLength
 	// Set total bytes if available
-	if resp.ContentLength > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
 	}
 
 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
-	defer out.Close()
 
-	// Use item progress writer
-	var bytesWritten int64
+	// Use buffered writer for better performance (256KB buffer)
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
+
+	// Use item progress writer with buffered output
+	var written int64
 	if itemID != "" {
-		pw := NewItemProgressWriter(out, itemID)
-		bytesWritten, err = io.Copy(pw, resp.Body)
+		pw := NewItemProgressWriter(bufWriter, itemID)
+		written, err = io.Copy(pw, resp.Body)
 	} else {
 		// Fallback: direct copy without progress tracking
-		bytesWritten, err = io.Copy(out, resp.Body)
-	}
-	if err != nil {
-		return fmt.Errorf("failed to write file: %w", err)
+		written, err = io.Copy(bufWriter, resp.Body)
 	}
 
-	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(bytesWritten)/(1024*1024))
+	// Flush buffer before checking for errors
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	// Check for any errors
+	if err != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	// Verify file size if Content-Length was provided
+	if expectedSize > 0 && written != expectedSize {
+		os.Remove(outputPath)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(written)/(1024*1024))
 	return nil
 }
 
 // AmazonDownloadResult contains download result with quality info
 type AmazonDownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
 }
 
 // downloadFromAmazon downloads a track using the request parameters
@@ -330,7 +448,22 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 
 	// Get Amazon URL from SongLink
 	songlink := NewSongLinkClient()
-	availability, err := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	var availability *TrackAvailability
+	var err error
+	
+	// Check if SpotifyID is actually a Deezer ID (format: "deezer:xxxxx")
+	if strings.HasPrefix(req.SpotifyID, "deezer:") {
+		// Extract Deezer ID and use Deezer-based lookup
+		deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
+		fmt.Printf("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
+		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
+	} else if req.SpotifyID != "" {
+		// Use Spotify ID
+		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	} else {
+		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+	}
+	
 	if err != nil {
 		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
 	}
@@ -378,11 +511,29 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
 
-	// Download file with item ID for progress tracking
+	// START PARALLEL: Fetch cover and lyrics while downloading audio
+	var parallelResult *ParallelDownloadResult
+	parallelDone := make(chan struct{})
+	go func() {
+		defer close(parallelDone)
+		parallelResult = FetchCoverAndLyricsParallel(
+			req.CoverURL,
+			req.EmbedMaxQualityCover,
+			req.SpotifyID,
+			req.TrackName,
+			req.ArtistName,
+			req.EmbedLyrics,
+		)
+	}()
+
+	// Download audio file with item ID for progress tracking
 	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
 		return AmazonDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
+	// Wait for parallel operations to complete
+	<-parallelDone
+
 	// Set progress to 100% and status to finalizing (before embedding)
 	// This makes the UI show "Finalizing..." while embedding happens
 	if req.ItemID != "" {
@@ -408,41 +559,27 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		ISRC:        req.ISRC,
 	}
 
-	// Download cover to memory (avoids file permission issues on Android)
+	// Use cover data from parallel fetch
 	var coverData []byte
-	if req.CoverURL != "" {
-		fmt.Println("[Amazon] Downloading cover to memory...")
-		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
-		if err == nil {
-			coverData = data
-			fmt.Printf("[Amazon] Cover downloaded successfully (%d bytes)\n", len(coverData))
-		} else {
-			fmt.Printf("[Amazon] Warning: failed to download cover: %v\n", err)
-		}
+	if parallelResult != nil && parallelResult.CoverData != nil {
+		coverData = parallelResult.CoverData
+		fmt.Printf("[Amazon] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
 	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
 		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 	}
 
-	// Embed lyrics if enabled
-	if req.EmbedLyrics {
-		fmt.Println("[Amazon] Fetching lyrics...")
-		lyricsClient := NewLyricsClient()
-		lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
-		if lyricsErr != nil {
-			fmt.Printf("[Amazon] Warning: lyrics fetch error: %v\n", lyricsErr)
-		} else if lyrics == nil || len(lyrics.Lines) == 0 {
-			fmt.Println("[Amazon] No lyrics found for this track")
+	// Embed lyrics from parallel fetch
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		fmt.Printf("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+		if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+			fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
 		} else {
-			fmt.Printf("[Amazon] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-			lrcContent := convertToLRC(lyrics)
-			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
-				fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Amazon] Lyrics embedded successfully")
-			}
+			fmt.Println("[Amazon] Lyrics embedded successfully")
 		}
+	} else if req.EmbedLyrics {
+		fmt.Println("[Amazon] No lyrics available from parallel fetch")
 	}
 
 	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
@@ -452,6 +589,8 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	quality, err := GetAudioQuality(outputPath)
 	if err != nil {
 		fmt.Printf("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+		// Add to ISRC index for fast duplicate checking
+		AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
 		// Return 0 to indicate unknown quality
 		return AmazonDownloadResult{
 			FilePath:   outputPath,
@@ -461,9 +600,19 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	}
 	
 	fmt.Printf("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+
+	// Add to ISRC index for fast duplicate checking
+	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+
 	return AmazonDownloadResult{
-		FilePath:   outputPath,
-		BitDepth:   quality.BitDepth,
-		SampleRate: quality.SampleRate,
+		FilePath:    outputPath,
+		BitDepth:    quality.BitDepth,
+		SampleRate:  quality.SampleRate,
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		ReleaseDate: req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		DiscNumber:  req.DiscNumber,
 	}, nil
 }

go_backend/deezer.go

@@ -0,0 +1,709 @@
+package gobackend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	deezerBaseURL     = "https://api.deezer.com/2.0"
+	deezerSearchURL   = deezerBaseURL + "/search"
+	deezerTrackURL    = deezerBaseURL + "/track/%s"
+	deezerAlbumURL    = deezerBaseURL + "/album/%s"
+	deezerArtistURL   = deezerBaseURL + "/artist/%s"
+	deezerPlaylistURL = deezerBaseURL + "/playlist/%s"
+	
+	deezerCacheTTL = 10 * time.Minute
+	
+	// Parallel ISRC fetching settings
+	deezerMaxParallelISRC = 10 // Max concurrent ISRC fetches
+)
+
+// DeezerClient handles Deezer API interactions (no auth required)
+type DeezerClient struct {
+	httpClient  *http.Client
+	searchCache map[string]*cacheEntry
+	albumCache  map[string]*cacheEntry
+	artistCache map[string]*cacheEntry
+	isrcCache   map[string]string // trackID -> ISRC cache
+	cacheMu     sync.RWMutex
+}
+
+// Singleton instance
+var (
+	deezerClient     *DeezerClient
+	deezerClientOnce sync.Once
+)
+
+// GetDeezerClient returns singleton Deezer client
+func GetDeezerClient() *DeezerClient {
+	deezerClientOnce.Do(func() {
+		deezerClient = &DeezerClient{
+			httpClient:  NewHTTPClientWithTimeout(15 * time.Second),
+			searchCache: make(map[string]*cacheEntry),
+			albumCache:  make(map[string]*cacheEntry),
+			artistCache: make(map[string]*cacheEntry),
+			isrcCache:   make(map[string]string),
+		}
+	})
+	return deezerClient
+}
+
+// Deezer API response types
+type deezerTrack struct {
+	ID             int64  `json:"id"`
+	Title          string `json:"title"`
+	Duration       int    `json:"duration"` // in seconds
+	TrackPosition  int    `json:"track_position"`
+	DiskNumber     int    `json:"disk_number"`
+	ISRC           string `json:"isrc"`
+	Link           string `json:"link"`
+	ReleaseDate    string `json:"release_date"` // Sometimes at track level
+	Artist         deezerArtist `json:"artist"`
+	Album          deezerAlbumSimple `json:"album"`
+	Contributors   []deezerArtist `json:"contributors"`
+}
+
+type deezerArtist struct {
+	ID        int64  `json:"id"`
+	Name      string `json:"name"`
+	Picture   string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbFan     int    `json:"nb_fan"`
+}
+
+type deezerAlbumSimple struct {
+	ID          int64  `json:"id"`
+	Title       string `json:"title"`
+	Cover       string `json:"cover"`
+	CoverMedium string `json:"cover_medium"`
+	CoverBig    string `json:"cover_big"`
+	CoverXL     string `json:"cover_xl"`
+	ReleaseDate string `json:"release_date"` // Sometimes at album level
+}
+// ... (skip other structs as they are fine/unchanged) ...
+
+// ... (in convertTrack) ...
+func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
+	artistName := track.Artist.Name
+	if len(track.Contributors) > 0 {
+		names := make([]string, len(track.Contributors))
+		for i, a := range track.Contributors {
+			names[i] = a.Name
+		}
+		artistName = strings.Join(names, ", ")
+	}
+
+	albumImage := track.Album.CoverXL
+	if albumImage == "" {
+		albumImage = track.Album.CoverBig
+	}
+	if albumImage == "" {
+		albumImage = track.Album.CoverMedium
+	}
+	if albumImage == "" {
+		albumImage = track.Album.Cover
+	}
+	
+	// Try to find release date
+	releaseDate := track.ReleaseDate
+	if releaseDate == "" {
+		releaseDate = track.Album.ReleaseDate
+	}
+
+	return TrackMetadata{
+		SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+		Artists:     artistName,
+		Name:        track.Title,
+		AlbumName:   track.Album.Title,
+		AlbumArtist: track.Artist.Name,
+		DurationMS:  track.Duration * 1000,
+		Images:      albumImage,
+		ReleaseDate: releaseDate, // Added this
+		TrackNumber: track.TrackPosition,
+		DiscNumber:  track.DiskNumber,
+		ExternalURL: track.Link,
+		ISRC:        track.ISRC,
+	}
+}
+
+type deezerAlbumFull struct {
+	ID          int64  `json:"id"`
+	Title       string `json:"title"`
+	Cover       string `json:"cover"`
+	CoverMedium string `json:"cover_medium"`
+	CoverBig    string `json:"cover_big"`
+	CoverXL     string `json:"cover_xl"`
+	ReleaseDate string `json:"release_date"`
+	NbTracks    int    `json:"nb_tracks"`
+	Artist      deezerArtist `json:"artist"`
+	Contributors []deezerArtist `json:"contributors"`
+	Tracks      struct {
+		Data []deezerTrack `json:"data"`
+	} `json:"tracks"`
+}
+
+type deezerArtistFull struct {
+	ID            int64  `json:"id"`
+	Name          string `json:"name"`
+	Picture       string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbFan         int    `json:"nb_fan"`
+	NbAlbum       int    `json:"nb_album"`
+}
+
+type deezerPlaylistFull struct {
+	ID          int64  `json:"id"`
+	Title       string `json:"title"`
+	Picture     string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbTracks    int    `json:"nb_tracks"`
+	Creator     struct {
+		Name string `json:"name"`
+	} `json:"creator"`
+	Tracks      struct {
+		Data []deezerTrack `json:"data"`
+	} `json:"tracks"`
+}
+
+// SearchAll searches for tracks and artists on Deezer
+// NOTE: ISRC is NOT fetched during search for performance - use GetTrackISRC when needed for download
+func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
+	cacheKey := fmt.Sprintf("deezer:all:%s:%d:%d", query, trackLimit, artistLimit)
+	
+	c.cacheMu.RLock()
+	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		return entry.data.(*SearchAllResult), nil
+	}
+	c.cacheMu.RUnlock()
+
+	result := &SearchAllResult{
+		Tracks:  make([]TrackMetadata, 0),
+		Artists: make([]SearchArtistResult, 0),
+	}
+
+	// Search tracks - NO ISRC fetch for performance
+	trackURL := fmt.Sprintf("%s/track?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), trackLimit)
+	var trackResp struct {
+		Data []deezerTrack `json:"data"`
+	}
+	if err := c.getJSON(ctx, trackURL, &trackResp); err != nil {
+		return nil, fmt.Errorf("deezer track search failed: %w", err)
+	}
+
+	for _, track := range trackResp.Data {
+		// Convert directly without fetching ISRC - much faster
+		result.Tracks = append(result.Tracks, c.convertTrack(track))
+	}
+
+	// Search artists
+	artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
+	var artistResp struct {
+		Data []deezerArtist `json:"data"`
+	}
+	if err := c.getJSON(ctx, artistURL, &artistResp); err == nil {
+		for _, artist := range artistResp.Data {
+			result.Artists = append(result.Artists, SearchArtistResult{
+				ID:         fmt.Sprintf("deezer:%d", artist.ID),
+				Name:       artist.Name,
+				Images:     c.getBestArtistImage(artist),
+				Followers:  artist.NbFan,
+				Popularity: 0,
+			})
+		}
+	}
+
+	// Cache result
+	c.cacheMu.Lock()
+	c.searchCache[cacheKey] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetTrack fetches a single track by Deezer ID
+func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResponse, error) {
+	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
+	
+	var track deezerTrack
+	if err := c.getJSON(ctx, trackURL, &track); err != nil {
+		return nil, err
+	}
+
+	return &TrackResponse{
+		Track: c.convertTrack(track),
+	}, nil
+}
+
+// GetAlbum fetches album with tracks
+// ISRC is fetched in parallel for better performance
+func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResponsePayload, error) {
+	c.cacheMu.RLock()
+	if entry, ok := c.albumCache[albumID]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		return entry.data.(*AlbumResponsePayload), nil
+	}
+	c.cacheMu.RUnlock()
+
+	albumURL := fmt.Sprintf(deezerAlbumURL, albumID)
+	
+	var album deezerAlbumFull
+	if err := c.getJSON(ctx, albumURL, &album); err != nil {
+		return nil, err
+	}
+
+	albumImage := c.getBestAlbumImage(album)
+	artistName := album.Artist.Name
+	if len(album.Contributors) > 0 {
+		names := make([]string, len(album.Contributors))
+		for i, a := range album.Contributors {
+			names[i] = a.Name
+		}
+		artistName = strings.Join(names, ", ")
+	}
+
+	info := AlbumInfoMetadata{
+		TotalTracks: album.NbTracks,
+		Name:        album.Title,
+		ReleaseDate: album.ReleaseDate,
+		Artists:     artistName,
+		Images:      albumImage,
+	}
+
+	// Fetch ISRCs in parallel
+	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
+	for _, track := range album.Tracks.Data {
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
+
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+			Artists:     track.Artist.Name,
+			Name:        track.Title,
+			AlbumName:   album.Title,
+			AlbumArtist: artistName,
+			DurationMS:  track.Duration * 1000,
+			Images:      albumImage,
+			ReleaseDate: album.ReleaseDate,
+			TrackNumber: track.TrackPosition,
+			TotalTracks: album.NbTracks,
+			DiscNumber:  track.DiskNumber,
+			ExternalURL: track.Link,
+			ISRC:        isrc,
+			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
+		})
+	}
+
+	result := &AlbumResponsePayload{
+		AlbumInfo: info,
+		TrackList: tracks,
+	}
+
+	c.cacheMu.Lock()
+	c.albumCache[albumID] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetArtist fetches artist with albums
+func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistResponsePayload, error) {
+	c.cacheMu.RLock()
+	if entry, ok := c.artistCache[artistID]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		return entry.data.(*ArtistResponsePayload), nil
+	}
+	c.cacheMu.RUnlock()
+
+	// Fetch artist info
+	artistURL := fmt.Sprintf(deezerArtistURL, artistID)
+	var artist deezerArtistFull
+	if err := c.getJSON(ctx, artistURL, &artist); err != nil {
+		return nil, err
+	}
+
+	artistInfo := ArtistInfoMetadata{
+		ID:         fmt.Sprintf("deezer:%d", artist.ID),
+		Name:       artist.Name,
+		Images:     c.getBestArtistImageFull(artist),
+		Followers:  artist.NbFan,
+		Popularity: 0,
+	}
+
+	// Fetch artist albums
+	albumsURL := fmt.Sprintf("%s/albums?limit=100", fmt.Sprintf(deezerArtistURL, artistID))
+	var albumsResp struct {
+		Data []struct {
+			ID          int64  `json:"id"`
+			Title       string `json:"title"`
+			ReleaseDate string `json:"release_date"`
+			NbTracks    int    `json:"nb_tracks"`
+			Cover       string `json:"cover"`
+			CoverMedium string `json:"cover_medium"`
+			CoverBig    string `json:"cover_big"`
+			CoverXL     string `json:"cover_xl"`
+			RecordType  string `json:"record_type"` // album, single, ep, compile
+		} `json:"data"`
+	}
+
+	albums := make([]ArtistAlbumMetadata, 0)
+	if err := c.getJSON(ctx, albumsURL, &albumsResp); err == nil {
+		for _, album := range albumsResp.Data {
+			albumType := album.RecordType
+			if albumType == "compile" {
+				albumType = "compilation"
+			}
+			
+			coverURL := album.CoverXL
+			if coverURL == "" {
+				coverURL = album.CoverBig
+			}
+			if coverURL == "" {
+				coverURL = album.CoverMedium
+			}
+			if coverURL == "" {
+				coverURL = album.Cover
+			}
+
+			albums = append(albums, ArtistAlbumMetadata{
+				ID:          fmt.Sprintf("deezer:%d", album.ID),
+				Name:        album.Title,
+				ReleaseDate: album.ReleaseDate,
+				TotalTracks: album.NbTracks,
+				Images:      coverURL,
+				AlbumType:   albumType,
+				Artists:     artist.Name,
+			})
+		}
+	}
+
+	result := &ArtistResponsePayload{
+		ArtistInfo: artistInfo,
+		Albums:     albums,
+	}
+
+	c.cacheMu.Lock()
+	c.artistCache[artistID] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetPlaylist fetches playlist with tracks
+// ISRC is fetched in parallel for better performance
+func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*PlaylistResponsePayload, error) {
+	playlistURL := fmt.Sprintf(deezerPlaylistURL, playlistID)
+	
+	var playlist deezerPlaylistFull
+	if err := c.getJSON(ctx, playlistURL, &playlist); err != nil {
+		return nil, err
+	}
+
+	playlistImage := playlist.PictureXL
+	if playlistImage == "" {
+		playlistImage = playlist.PictureBig
+	}
+	if playlistImage == "" {
+		playlistImage = playlist.PictureMedium
+	}
+
+	var info PlaylistInfoMetadata
+	info.Tracks.Total = playlist.NbTracks
+	info.Owner.DisplayName = playlist.Creator.Name
+	info.Owner.Name = playlist.Title
+	info.Owner.Images = playlistImage
+
+	// Fetch ISRCs in parallel
+	isrcMap := c.fetchISRCsParallel(ctx, playlist.Tracks.Data)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(playlist.Tracks.Data))
+	for _, track := range playlist.Tracks.Data {
+		albumImage := track.Album.CoverXL
+		if albumImage == "" {
+			albumImage = track.Album.CoverBig
+		}
+		if albumImage == "" {
+			albumImage = track.Album.CoverMedium
+		}
+
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
+
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+			Artists:     track.Artist.Name,
+			Name:        track.Title,
+			AlbumName:   track.Album.Title,
+			AlbumArtist: track.Artist.Name,
+			DurationMS:  track.Duration * 1000,
+			Images:      albumImage,
+			ReleaseDate: "",
+			TrackNumber: track.TrackPosition,
+			DiscNumber:  track.DiskNumber,
+			ExternalURL: track.Link,
+			ISRC:        isrc,
+			AlbumID:     fmt.Sprintf("deezer:%d", track.Album.ID),
+		})
+	}
+
+	return &PlaylistResponsePayload{
+		PlaylistInfo: info,
+		TrackList:    tracks,
+	}, nil
+}
+
+// SearchByISRC searches for a track by ISRC using direct endpoint
+func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMetadata, error) {
+	// Use direct ISRC endpoint (API 2.0)
+	// https://api.deezer.com/2.0/track/isrc:{ISRC}
+	directURL := fmt.Sprintf("%s/track/isrc:%s", deezerBaseURL, isrc)
+	
+	var track deezerTrack
+	if err := c.getJSON(ctx, directURL, &track); err != nil {
+		// Fallback to search if direct endpoint fails
+		searchURL := fmt.Sprintf("%s/track?q=isrc:%s&limit=1", deezerSearchURL, isrc)
+		var resp struct {
+			Data []deezerTrack `json:"data"`
+		}
+		if err := c.getJSON(ctx, searchURL, &resp); err != nil {
+			return nil, err
+		}
+		if len(resp.Data) == 0 {
+			return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
+		}
+		result := c.convertTrack(resp.Data[0])
+		return &result, nil
+	}
+
+	// Check if we got a valid response (ID > 0)
+	if track.ID == 0 {
+		return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
+	}
+
+	result := c.convertTrack(track)
+	return &result, nil
+}
+
+func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*deezerTrack, error) {
+	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
+	var track deezerTrack
+	if err := c.getJSON(ctx, trackURL, &track); err != nil {
+		return nil, err
+	}
+	return &track, nil
+}
+
+// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel with caching
+func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTrack) map[string]string {
+	result := make(map[string]string)
+	var resultMu sync.Mutex
+	
+	// First, check cache for existing ISRCs
+	var tracksToFetch []deezerTrack
+	c.cacheMu.RLock()
+	for _, track := range tracks {
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		if isrc, ok := c.isrcCache[trackIDStr]; ok {
+			result[trackIDStr] = isrc
+		} else {
+			tracksToFetch = append(tracksToFetch, track)
+		}
+	}
+	c.cacheMu.RUnlock()
+	
+	if len(tracksToFetch) == 0 {
+		return result
+	}
+	
+	// Use semaphore to limit concurrent requests
+	sem := make(chan struct{}, deezerMaxParallelISRC)
+	var wg sync.WaitGroup
+	
+	for _, track := range tracksToFetch {
+		wg.Add(1)
+		go func(t deezerTrack) {
+			defer wg.Done()
+			
+			// Acquire semaphore
+			select {
+			case sem <- struct{}{}:
+				defer func() { <-sem }()
+			case <-ctx.Done():
+				return
+			}
+			
+			trackIDStr := fmt.Sprintf("%d", t.ID)
+			fullTrack, err := c.fetchFullTrack(ctx, trackIDStr)
+			if err != nil || fullTrack == nil {
+				return
+			}
+			
+			// Store in result and cache
+			resultMu.Lock()
+			result[trackIDStr] = fullTrack.ISRC
+			resultMu.Unlock()
+			
+			c.cacheMu.Lock()
+			c.isrcCache[trackIDStr] = fullTrack.ISRC
+			c.cacheMu.Unlock()
+		}(track)
+	}
+	
+	wg.Wait()
+	return result
+}
+
+// GetTrackISRC fetches ISRC for a single track (with caching)
+// Use this when you need ISRC for download
+func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string, error) {
+	// Check cache first
+	c.cacheMu.RLock()
+	if isrc, ok := c.isrcCache[trackID]; ok {
+		c.cacheMu.RUnlock()
+		return isrc, nil
+	}
+	c.cacheMu.RUnlock()
+	
+	// Fetch from API
+	fullTrack, err := c.fetchFullTrack(ctx, trackID)
+	if err != nil {
+		return "", err
+	}
+	
+	// Cache the result
+	c.cacheMu.Lock()
+	c.isrcCache[trackID] = fullTrack.ISRC
+	c.cacheMu.Unlock()
+	
+	return fullTrack.ISRC, nil
+}
+
+
+
+func (c *DeezerClient) getBestArtistImage(artist deezerArtist) string {
+	if artist.PictureXL != "" {
+		return artist.PictureXL
+	}
+	if artist.PictureBig != "" {
+		return artist.PictureBig
+	}
+	if artist.PictureMedium != "" {
+		return artist.PictureMedium
+	}
+	return artist.Picture
+}
+
+func (c *DeezerClient) getBestArtistImageFull(artist deezerArtistFull) string {
+	if artist.PictureXL != "" {
+		return artist.PictureXL
+	}
+	if artist.PictureBig != "" {
+		return artist.PictureBig
+	}
+	if artist.PictureMedium != "" {
+		return artist.PictureMedium
+	}
+	return artist.Picture
+}
+
+func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
+	if album.CoverXL != "" {
+		return album.CoverXL
+	}
+	if album.CoverBig != "" {
+		return album.CoverBig
+	}
+	if album.CoverMedium != "" {
+		return album.CoverMedium
+	}
+	return album.Cover
+}
+
+func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interface{}) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("deezer API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	return json.Unmarshal(body, dst)
+}
+
+// parseDeezerURL is internal function, returns type and ID
+func parseDeezerURL(input string) (string, string, error) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return "", "", fmt.Errorf("empty URL")
+	}
+
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", "", err
+	}
+
+	if parsed.Host != "www.deezer.com" && parsed.Host != "deezer.com" && parsed.Host != "deezer.page.link" {
+		return "", "", fmt.Errorf("not a Deezer URL")
+	}
+
+	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
+	
+	// Skip language prefix if present (e.g., /en/, /fr/)
+	if len(parts) > 0 && len(parts[0]) == 2 {
+		parts = parts[1:]
+	}
+
+	if len(parts) < 2 {
+		return "", "", fmt.Errorf("invalid Deezer URL format")
+	}
+
+	resourceType := parts[0]
+	resourceID := parts[1]
+
+	switch resourceType {
+	case "track", "album", "artist", "playlist":
+		return resourceType, resourceID, nil
+	default:
+		return "", "", fmt.Errorf("unsupported Deezer resource type: %s", resourceType)
+	}
+}

go_backend/duplicate.go

@@ -1,49 +1,144 @@
 package gobackend
 
 import (
+	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
+	"time"
 )
 
+// ISRCIndex holds a cached map of ISRC -> file path for fast duplicate checking
+type ISRCIndex struct {
+	index     map[string]string // ISRC (uppercase) -> file path
+	outputDir string
+	buildTime time.Time
+	mu        sync.RWMutex
+}
+
+// Global ISRC index cache (per output directory)
+var (
+	isrcIndexCache   = make(map[string]*ISRCIndex)
+	isrcIndexCacheMu sync.RWMutex
+	isrcIndexTTL     = 5 * time.Minute // Cache TTL - rebuild after 5 minutes
+)
+
+// GetISRCIndex returns or builds an ISRC index for the given directory
+func GetISRCIndex(outputDir string) *ISRCIndex {
+	isrcIndexCacheMu.RLock()
+	idx, exists := isrcIndexCache[outputDir]
+	isrcIndexCacheMu.RUnlock()
+
+	// Return cached index if still valid
+	if exists && time.Since(idx.buildTime) < isrcIndexTTL {
+		return idx
+	}
+
+	// Build new index
+	return buildISRCIndex(outputDir)
+}
+
+// buildISRCIndex scans a directory and builds a map of ISRC -> file path
+// Same implementation as PC version for consistency
+func buildISRCIndex(outputDir string) *ISRCIndex {
+	idx := &ISRCIndex{
+		index:     make(map[string]string),
+		outputDir: outputDir,
+		buildTime: time.Now(),
+	}
+
+	if outputDir == "" {
+		return idx
+	}
+
+	startTime := time.Now()
+	fileCount := 0
+
+	// Walk directory - only check .flac files
+	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil || info.IsDir() {
+			return nil
+		}
+
+		ext := strings.ToLower(filepath.Ext(path))
+		if ext != ".flac" {
+			return nil
+		}
+
+		// Read ISRC from file
+		metadata, err := ReadMetadata(path)
+		if err != nil || metadata.ISRC == "" {
+			return nil
+		}
+
+		// Store in index (uppercase for case-insensitive matching)
+		idx.index[strings.ToUpper(metadata.ISRC)] = path
+		fileCount++
+		return nil
+	})
+
+	fmt.Printf("[ISRCIndex] Built index for %s: %d files in %v\n", 
+		outputDir, fileCount, time.Since(startTime).Round(time.Millisecond))
+
+	// Cache the index
+	isrcIndexCacheMu.Lock()
+	isrcIndexCache[outputDir] = idx
+	isrcIndexCacheMu.Unlock()
+
+	return idx
+}
+
+// lookup checks if an ISRC exists in the index (internal, returns bool)
+func (idx *ISRCIndex) lookup(isrc string) (string, bool) {
+	if isrc == "" {
+		return "", false
+	}
+
+	idx.mu.RLock()
+	defer idx.mu.RUnlock()
+
+	path, exists := idx.index[strings.ToUpper(isrc)]
+	return path, exists
+}
+
+// Lookup checks if an ISRC exists in the index (gomobile compatible)
+// Returns filepath if found, empty string if not found
+func (idx *ISRCIndex) Lookup(isrc string) (string, error) {
+	path, _ := idx.lookup(isrc)
+	return path, nil
+}
+
+// Add adds a new ISRC to the index (call after successful download)
+func (idx *ISRCIndex) Add(isrc, filePath string) {
+	if isrc == "" || filePath == "" {
+		return
+	}
+
+	idx.mu.Lock()
+	defer idx.mu.Unlock()
+
+	idx.index[strings.ToUpper(isrc)] = filePath
+}
+
+// InvalidateCache clears the ISRC index cache for a directory
+func InvalidateISRCCache(outputDir string) {
+	isrcIndexCacheMu.Lock()
+	delete(isrcIndexCache, outputDir)
+	isrcIndexCacheMu.Unlock()
+}
+
 // checkISRCExistsInternal checks if a file with the given ISRC exists (internal use)
+// Uses ISRC index for fast lookup
 func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 	if isrc == "" || outputDir == "" {
 		return "", false
 	}
 
-	// Walk through directory looking for FLAC files
-	var foundFile string
-	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
-
-		// Only check FLAC files
-		if info.IsDir() || !strings.HasSuffix(strings.ToLower(path), ".flac") {
-			return nil
-		}
-
-		// Read metadata from file
-		metadata, err := ReadMetadata(path)
-		if err != nil {
-			return nil
-		}
-
-		// Check if ISRC matches
-		if metadata.ISRC == isrc {
-			foundFile = path
-			return filepath.SkipAll // Stop walking
-		}
-
-		return nil
-	})
-
-	if foundFile != "" {
-		return foundFile, true
-	}
-
-	return "", false
+	// Use index for fast lookup
+	idx := GetISRCIndex(outputDir)
+	return idx.lookup(isrc)
 }
 
 // CheckISRCExists is the exported version for gomobile (returns string, error)
@@ -61,3 +156,98 @@ func CheckFileExists(filePath string) bool {
 	}
 	return !info.IsDir() && info.Size() > 0
 }
+
+// FileExistenceResult represents the result of checking if a file exists
+type FileExistenceResult struct {
+	ISRC       string `json:"isrc"`
+	Exists     bool   `json:"exists"`
+	FilePath   string `json:"file_path,omitempty"`
+	TrackName  string `json:"track_name,omitempty"`
+	ArtistName string `json:"artist_name,omitempty"`
+}
+
+// CheckFilesExistParallel checks if multiple files exist in parallel
+// It builds an ISRC index from the output directory once, then checks all tracks against it
+// Same implementation as PC version for consistency
+func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error) {
+	// Parse input JSON
+	var tracks []struct {
+		ISRC       string `json:"isrc"`
+		TrackName  string `json:"track_name"`
+		ArtistName string `json:"artist_name"`
+	}
+	if err := json.Unmarshal([]byte(tracksJSON), &tracks); err != nil {
+		return "", fmt.Errorf("failed to parse tracks JSON: %w", err)
+	}
+
+	results := make([]FileExistenceResult, len(tracks))
+
+	// Build ISRC index from output directory (scan once)
+	isrcIdx := GetISRCIndex(outputDir)
+
+	// Check each track against the index (parallel)
+	var wg sync.WaitGroup
+	for i, track := range tracks {
+		wg.Add(1)
+		go func(resultIdx int, t struct {
+			ISRC       string `json:"isrc"`
+			TrackName  string `json:"track_name"`
+			ArtistName string `json:"artist_name"`
+		}) {
+			defer wg.Done()
+
+			result := FileExistenceResult{
+				ISRC:       t.ISRC,
+				TrackName:  t.TrackName,
+				ArtistName: t.ArtistName,
+				Exists:     false,
+			}
+
+			if t.ISRC != "" {
+				if filePath, exists := isrcIdx.lookup(t.ISRC); exists {
+					result.Exists = true
+					result.FilePath = filePath
+				}
+			}
+
+			results[resultIdx] = result
+		}(i, track)
+	}
+
+	wg.Wait()
+
+	// Return results as JSON
+	resultJSON, err := json.Marshal(results)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal results: %w", err)
+	}
+
+	return string(resultJSON), nil
+}
+
+// PreBuildISRCIndex pre-builds the ISRC index for a directory
+// Call this when app starts or when entering album/playlist screen
+func PreBuildISRCIndex(outputDir string) error {
+	if outputDir == "" {
+		return fmt.Errorf("output directory is required")
+	}
+
+	buildISRCIndex(outputDir)
+	return nil
+}
+
+// AddToISRCIndex adds a new file to the ISRC index after successful download
+// This avoids rebuilding the entire index
+func AddToISRCIndex(outputDir, isrc, filePath string) {
+	if outputDir == "" || isrc == "" || filePath == "" {
+		return
+	}
+
+	isrcIndexCacheMu.RLock()
+	idx, exists := isrcIndexCache[outputDir]
+	isrcIndexCacheMu.RUnlock()
+
+	if exists {
+		idx.Add(isrc, filePath)
+	}
+}

go_backend/exports.go

@@ -143,18 +143,32 @@ type DownloadResponse struct {
 	Message       string `json:"message"`
 	FilePath      string `json:"file_path,omitempty"`
 	Error         string `json:"error,omitempty"`
+	ErrorType     string `json:"error_type,omitempty"` // "not_found", "rate_limit", "network", "unknown"
 	AlreadyExists bool   `json:"already_exists,omitempty"`
 	// Actual quality info from the source
 	ActualBitDepth   int    `json:"actual_bit_depth,omitempty"`
 	ActualSampleRate int    `json:"actual_sample_rate,omitempty"`
 	Service          string `json:"service,omitempty"` // Actual service used (for fallback)
+	Title            string `json:"title,omitempty"`
+	Artist           string `json:"artist,omitempty"`
+	Album            string `json:"album,omitempty"`
+	ReleaseDate      string `json:"release_date,omitempty"`
+	TrackNumber      int    `json:"track_number,omitempty"`
+	DiscNumber       int    `json:"disc_number,omitempty"`
 }
 
+// DownloadResult is a generic result type for all downloaders
 // DownloadResult is a generic result type for all downloaders
 type DownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
 }
 
 // DownloadTrack downloads a track from the specified service
@@ -181,9 +195,15 @@ func DownloadTrack(requestJSON string) (string, error) {
 		tidalResult, tidalErr := downloadFromTidal(req)
 		if tidalErr == nil {
 			result = DownloadResult{
-				FilePath:   tidalResult.FilePath,
-				BitDepth:   tidalResult.BitDepth,
-				SampleRate: tidalResult.SampleRate,
+				FilePath:    tidalResult.FilePath,
+				BitDepth:    tidalResult.BitDepth,
+				SampleRate:  tidalResult.SampleRate,
+				Title:       tidalResult.Title,
+				Artist:      tidalResult.Artist,
+				Album:       tidalResult.Album,
+				ReleaseDate: tidalResult.ReleaseDate,
+				TrackNumber: tidalResult.TrackNumber,
+				DiscNumber:  tidalResult.DiscNumber,
 			}
 		}
 		err = tidalErr
@@ -191,9 +211,15 @@ func DownloadTrack(requestJSON string) (string, error) {
 		qobuzResult, qobuzErr := downloadFromQobuz(req)
 		if qobuzErr == nil {
 			result = DownloadResult{
-				FilePath:   qobuzResult.FilePath,
-				BitDepth:   qobuzResult.BitDepth,
-				SampleRate: qobuzResult.SampleRate,
+				FilePath:    qobuzResult.FilePath,
+				BitDepth:    qobuzResult.BitDepth,
+				SampleRate:  qobuzResult.SampleRate,
+				Title:       qobuzResult.Title,
+				Artist:      qobuzResult.Artist,
+				Album:       qobuzResult.Album,
+				ReleaseDate: qobuzResult.ReleaseDate,
+				TrackNumber: qobuzResult.TrackNumber,
+				DiscNumber:  qobuzResult.DiscNumber,
 			}
 		}
 		err = qobuzErr
@@ -201,9 +227,15 @@ func DownloadTrack(requestJSON string) (string, error) {
 		amazonResult, amazonErr := downloadFromAmazon(req)
 		if amazonErr == nil {
 			result = DownloadResult{
-				FilePath:   amazonResult.FilePath,
-				BitDepth:   amazonResult.BitDepth,
-				SampleRate: amazonResult.SampleRate,
+				FilePath:    amazonResult.FilePath,
+				BitDepth:    amazonResult.BitDepth,
+				SampleRate:  amazonResult.SampleRate,
+				Title:       amazonResult.Title,
+				Artist:      amazonResult.Artist,
+				Album:       amazonResult.Album,
+				ReleaseDate: amazonResult.ReleaseDate,
+				TrackNumber: amazonResult.TrackNumber,
+				DiscNumber:  amazonResult.DiscNumber,
 			}
 		}
 		err = amazonErr
@@ -254,6 +286,12 @@ func DownloadTrack(requestJSON string) (string, error) {
 		ActualBitDepth:   result.BitDepth,
 		ActualSampleRate: result.SampleRate,
 		Service:          req.Service,
+		Title:            result.Title,
+		Artist:           result.Artist,
+		Album:            result.Album,
+		ReleaseDate:      result.ReleaseDate,
+		TrackNumber:      result.TrackNumber,
+		DiscNumber:       result.DiscNumber,
 	}
 	
 	jsonBytes, _ := json.Marshal(resp)
@@ -276,12 +314,14 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
 	
 	// Build service order starting with preferred service
-	allServices := []string{"tidal", "qobuz", "amazon"}
+	allServices := []string{"qobuz", "tidal", "amazon"}
 	preferredService := req.Service
 	if preferredService == "" {
 		preferredService = "tidal"
 	}
 	
+	fmt.Printf("[DownloadWithFallback] Preferred service from request: '%s'\n", req.Service)
+	
 	// Create ordered list: preferred first, then others
 	services := []string{preferredService}
 	for _, s := range allServices {
@@ -290,9 +330,12 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 		}
 	}
 	
+	fmt.Printf("[DownloadWithFallback] Service order: %v\n", services)
+	
 	var lastErr error
 	
 	for _, service := range services {
+		fmt.Printf("[DownloadWithFallback] Trying service: %s\n", service)
 		req.Service = service
 		
 		var result DownloadResult
@@ -303,10 +346,18 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 			tidalResult, tidalErr := downloadFromTidal(req)
 			if tidalErr == nil {
 				result = DownloadResult{
-					FilePath:   tidalResult.FilePath,
-					BitDepth:   tidalResult.BitDepth,
-					SampleRate: tidalResult.SampleRate,
+					FilePath:    tidalResult.FilePath,
+					BitDepth:    tidalResult.BitDepth,
+					SampleRate:  tidalResult.SampleRate,
+					Title:       tidalResult.Title,
+					Artist:      tidalResult.Artist,
+					Album:       tidalResult.Album,
+					ReleaseDate: tidalResult.ReleaseDate,
+					TrackNumber: tidalResult.TrackNumber,
+					DiscNumber:  tidalResult.DiscNumber,
 				}
+			} else {
+				fmt.Printf("[DownloadWithFallback] Tidal error: %v\n", tidalErr)
 			}
 			err = tidalErr
 		case "qobuz":
@@ -317,16 +368,26 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 					BitDepth:   qobuzResult.BitDepth,
 					SampleRate: qobuzResult.SampleRate,
 				}
+			} else {
+				fmt.Printf("[DownloadWithFallback] Qobuz error: %v\n", qobuzErr)
 			}
 			err = qobuzErr
 		case "amazon":
 			amazonResult, amazonErr := downloadFromAmazon(req)
 			if amazonErr == nil {
 				result = DownloadResult{
-					FilePath:   amazonResult.FilePath,
-					BitDepth:   amazonResult.BitDepth,
-					SampleRate: amazonResult.SampleRate,
+					FilePath:    amazonResult.FilePath,
+					BitDepth:    amazonResult.BitDepth,
+					SampleRate:  amazonResult.SampleRate,
+					Title:       amazonResult.Title,
+					Artist:      amazonResult.Artist,
+					Album:       amazonResult.Album,
+					ReleaseDate: amazonResult.ReleaseDate,
+					TrackNumber: amazonResult.TrackNumber,
+					DiscNumber:  amazonResult.DiscNumber,
 				}
+			} else {
+				fmt.Printf("[DownloadWithFallback] Amazon error: %v\n", amazonErr)
 			}
 			err = amazonErr
 		}
@@ -438,6 +499,26 @@ func CheckDuplicate(outputDir, isrc string) (string, error) {
 	return string(jsonBytes), nil
 }
 
+// CheckDuplicatesBatch checks multiple files for duplicates in parallel
+// Uses ISRC index for fast lookup (builds index once, checks all tracks)
+// tracksJSON format: [{"isrc": "...", "track_name": "...", "artist_name": "..."}, ...]
+// Returns JSON array of results
+func CheckDuplicatesBatch(outputDir, tracksJSON string) (string, error) {
+	return CheckFilesExistParallel(outputDir, tracksJSON)
+}
+
+// PreBuildDuplicateIndex pre-builds the ISRC index for a directory
+// Call this when entering album/playlist screen for faster duplicate checking
+func PreBuildDuplicateIndex(outputDir string) error {
+	return PreBuildISRCIndex(outputDir)
+}
+
+// InvalidateDuplicateIndex clears the ISRC index cache for a directory
+// Call this when files are deleted or moved
+func InvalidateDuplicateIndex(outputDir string) {
+	InvalidateISRCCache(outputDir)
+}
+
 // BuildFilename builds a filename from template and metadata
 func BuildFilename(template string, metadataJSON string) (string, error) {
 	var metadata map[string]interface{}
@@ -478,7 +559,7 @@ func FetchLyrics(spotifyID, trackName, artistName string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// GetLyricsLRC fetches lyrics and converts to LRC format string
+// GetLyricsLRC fetches lyrics and converts to LRC format string with metadata headers
 // First tries to extract from file, then falls back to fetching from internet
 func GetLyricsLRC(spotifyID, trackName, artistName string, filePath string) (string, error) {
 	// Try to extract from file first (much faster)
@@ -496,7 +577,8 @@ func GetLyricsLRC(spotifyID, trackName, artistName string, filePath string) (str
 		return "", err
 	}
 
-	lrcContent := convertToLRC(lyricsData)
+	// Convert to LRC format with metadata headers (like PC version)
+	lrcContent := convertToLRCWithMetadata(lyricsData, trackName, artistName)
 	return lrcContent, nil
 }
 
@@ -516,10 +598,335 @@ func EmbedLyricsToFile(filePath, lyrics string) (string, error) {
 	return string(jsonBytes), nil
 }
 
+// PreWarmTrackCacheJSON pre-warms the track ID cache for album/playlist tracks
+// tracksJSON is a JSON array of objects with: isrc, track_name, artist_name, spotify_id, service
+// This runs in background and returns immediately
+func PreWarmTrackCacheJSON(tracksJSON string) (string, error) {
+	var tracks []struct {
+		ISRC       string `json:"isrc"`
+		TrackName  string `json:"track_name"`
+		ArtistName string `json:"artist_name"`
+		SpotifyID  string `json:"spotify_id"`
+		Service    string `json:"service"`
+	}
+
+	if err := json.Unmarshal([]byte(tracksJSON), &tracks); err != nil {
+		return errorResponse("Invalid JSON: " + err.Error())
+	}
+
+	// Convert to PreWarmCacheRequest
+	requests := make([]PreWarmCacheRequest, len(tracks))
+	for i, t := range tracks {
+		requests[i] = PreWarmCacheRequest{
+			ISRC:       t.ISRC,
+			TrackName:  t.TrackName,
+			ArtistName: t.ArtistName,
+			SpotifyID:  t.SpotifyID,
+			Service:    t.Service,
+		}
+	}
+
+	// Run in background
+	go PreWarmTrackCache(requests)
+
+	resp := map[string]interface{}{
+		"success": true,
+		"message": fmt.Sprintf("Pre-warming cache for %d tracks in background", len(tracks)),
+	}
+
+	jsonBytes, _ := json.Marshal(resp)
+	return string(jsonBytes), nil
+}
+
+// GetTrackCacheSize returns the current track ID cache size
+func GetTrackCacheSize() int {
+	return GetCacheSize()
+}
+
+// ClearTrackIDCache clears the track ID cache
+func ClearTrackIDCache() {
+	ClearTrackCache()
+}
+
+// ==================== DEEZER API ====================
+
+// SearchDeezerAll searches for tracks and artists on Deezer (no API key required)
+// Returns JSON with tracks and artists arrays
+func SearchDeezerAll(query string, trackLimit, artistLimit int) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	
+	client := GetDeezerClient()
+	results, err := client.SearchAll(ctx, query, trackLimit, artistLimit)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(results)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// GetDeezerMetadata fetches metadata from Deezer URL or ID
+// resourceType: track, album, artist, playlist
+// resourceID: Deezer ID
+func GetDeezerMetadata(resourceType, resourceID string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	client := GetDeezerClient()
+	var data interface{}
+	var err error
+	
+	switch resourceType {
+	case "track":
+		data, err = client.GetTrack(ctx, resourceID)
+	case "album":
+		data, err = client.GetAlbum(ctx, resourceID)
+	case "artist":
+		data, err = client.GetArtist(ctx, resourceID)
+	case "playlist":
+		data, err = client.GetPlaylist(ctx, resourceID)
+	default:
+		return "", fmt.Errorf("unsupported Deezer resource type: %s", resourceType)
+	}
+	
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// ParseDeezerURLExport parses a Deezer URL and returns type and ID
+func ParseDeezerURLExport(url string) (string, error) {
+	resourceType, resourceID, err := parseDeezerURL(url)
+	if err != nil {
+		return "", err
+	}
+	
+	result := map[string]string{
+		"type": resourceType,
+		"id":   resourceID,
+	}
+	
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// SearchDeezerByISRC searches for a track by ISRC on Deezer
+func SearchDeezerByISRC(isrc string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	
+	client := GetDeezerClient()
+	track, err := client.SearchByISRC(ctx, isrc)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(track)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// ConvertSpotifyToDeezer converts a Spotify track/album ID to Deezer and fetches metadata
+// This uses SongLink API to find the Deezer equivalent, then fetches from Deezer
+// Useful when Spotify API is rate limited
+func ConvertSpotifyToDeezer(resourceType, spotifyID string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	songlink := NewSongLinkClient()
+	deezerClient := GetDeezerClient()
+	
+	// For tracks, we can use SongLink to get Deezer ID
+	if resourceType == "track" {
+		deezerID, err := songlink.GetDeezerIDFromSpotify(spotifyID)
+		if err != nil {
+			return "", fmt.Errorf("could not find Deezer equivalent: %w", err)
+		}
+		
+		// Fetch metadata from Deezer
+		trackResp, err := deezerClient.GetTrack(ctx, deezerID)
+		if err != nil {
+			return "", fmt.Errorf("failed to fetch Deezer metadata: %w", err)
+		}
+		
+		jsonBytes, err := json.Marshal(trackResp)
+		if err != nil {
+			return "", err
+		}
+		
+		return string(jsonBytes), nil
+	}
+	
+	// For albums, SongLink also provides mapping
+	if resourceType == "album" {
+		deezerID, err := songlink.GetDeezerAlbumIDFromSpotify(spotifyID)
+		if err != nil {
+			return "", fmt.Errorf("could not find Deezer album: %w", err)
+		}
+		
+		// Fetch album metadata from Deezer
+		albumResp, err := deezerClient.GetAlbum(ctx, deezerID)
+		if err != nil {
+			return "", fmt.Errorf("failed to fetch Deezer album metadata: %w", err)
+		}
+		
+		jsonBytes, err := json.Marshal(albumResp)
+		if err != nil {
+			return "", err
+		}
+		
+		return string(jsonBytes), nil
+	}
+	
+	// For artists/playlists, SongLink doesn't provide direct mapping
+	return "", fmt.Errorf("Spotify to Deezer conversion only supported for tracks and albums. Please search by name for %s", resourceType)
+}
+
+// GetSpotifyMetadataWithDeezerFallback tries Spotify first, falls back to Deezer on rate limit
+func GetSpotifyMetadataWithDeezerFallback(spotifyURL string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	// Try Spotify first
+	client := NewSpotifyMetadataClient()
+	data, err := client.GetFilteredData(ctx, spotifyURL, false, 0)
+	if err == nil {
+		jsonBytes, err := json.Marshal(data)
+		if err != nil {
+			return "", err
+		}
+		return string(jsonBytes), nil
+	}
+	
+	// Check if it's a rate limit error
+	errStr := strings.ToLower(err.Error())
+	if !strings.Contains(errStr, "429") && !strings.Contains(errStr, "rate") && !strings.Contains(errStr, "limit") {
+		// Not a rate limit error, return original error
+		return "", err
+	}
+	
+	// Rate limited - try Deezer fallback for tracks and albums
+	parsed, parseErr := parseSpotifyURI(spotifyURL)
+	if parseErr != nil {
+		return "", fmt.Errorf("spotify rate limited and failed to parse URL: %w", parseErr)
+	}
+	
+	fmt.Printf("[Fallback] Spotify rate limited for %s, trying Deezer...\n", parsed.Type)
+	
+	if parsed.Type == "track" || parsed.Type == "album" {
+		// Convert to Deezer
+		return ConvertSpotifyToDeezer(parsed.Type, parsed.ID)
+	}
+	
+	// Artist and playlist not supported for fallback
+	if parsed.Type == "artist" {
+		return "", fmt.Errorf("spotify rate limited. Artist pages require Spotify API - please try again later")
+	}
+	
+	return "", fmt.Errorf("spotify rate limited. Playlists are user-specific and require Spotify API")
+}
+
+// ==================== SONGLINK DEEZER SUPPORT ====================
+
+// CheckAvailabilityFromDeezerID checks track availability using Deezer track ID as source
+// Returns JSON with availability info for Spotify, Tidal, Amazon, etc.
+func CheckAvailabilityFromDeezerID(deezerTrackID string) (string, error) {
+	client := NewSongLinkClient()
+	availability, err := client.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(availability)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// CheckAvailabilityByPlatformID checks track availability using any platform as source
+// platform: "spotify", "deezer", "tidal", "amazonMusic", "appleMusic", "youtube"
+// entityType: "song" or "album"
+// entityID: the ID on that platform
+func CheckAvailabilityByPlatformID(platform, entityType, entityID string) (string, error) {
+	client := NewSongLinkClient()
+	availability, err := client.CheckAvailabilityByPlatform(platform, entityType, entityID)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(availability)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// GetSpotifyIDFromDeezerTrack converts a Deezer track ID to Spotify track ID
+func GetSpotifyIDFromDeezerTrack(deezerTrackID string) (string, error) {
+	client := NewSongLinkClient()
+	return client.GetSpotifyIDFromDeezer(deezerTrackID)
+}
+
+// GetTidalURLFromDeezerTrack converts a Deezer track ID to Tidal URL
+func GetTidalURLFromDeezerTrack(deezerTrackID string) (string, error) {
+	client := NewSongLinkClient()
+	return client.GetTidalURLFromDeezer(deezerTrackID)
+}
+
+// GetAmazonURLFromDeezerTrack converts a Deezer track ID to Amazon Music URL
+func GetAmazonURLFromDeezerTrack(deezerTrackID string) (string, error) {
+	client := NewSongLinkClient()
+	return client.GetAmazonURLFromDeezer(deezerTrackID)
+}
+
 func errorResponse(msg string) (string, error) {
+	// Determine error type based on message
+	errorType := "unknown"
+	lowerMsg := strings.ToLower(msg)
+	
+	if strings.Contains(lowerMsg, "not found") || 
+	   strings.Contains(lowerMsg, "not available") ||
+	   strings.Contains(lowerMsg, "no results") ||
+	   strings.Contains(lowerMsg, "track not found") ||
+	   strings.Contains(lowerMsg, "all services failed") {
+		errorType = "not_found"
+	} else if strings.Contains(lowerMsg, "rate limit") || 
+	          strings.Contains(lowerMsg, "429") ||
+	          strings.Contains(lowerMsg, "too many requests") {
+		errorType = "rate_limit"
+	} else if strings.Contains(lowerMsg, "network") || 
+	          strings.Contains(lowerMsg, "connection") ||
+	          strings.Contains(lowerMsg, "timeout") ||
+	          strings.Contains(lowerMsg, "dial") {
+		errorType = "network"
+	}
+	
 	resp := DownloadResponse{
-		Success: false,
-		Error:   msg,
+		Success:   false,
+		Error:     msg,
+		ErrorType: errorType,
 	}
 	jsonBytes, _ := json.Marshal(resp)
 	return string(jsonBytes), nil

go_backend/httputil.go

@@ -12,25 +12,59 @@ import (
 
 // HTTP utility functions for consistent request handling across all downloaders
 
-// User-Agent pool for Android Chrome browsers
-var userAgentTemplates = []string{
-	"Mozilla/5.0 (Linux; Android %d; SM-G%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; Pixel %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; SM-A%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; Redmi Note %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+// getRandomUserAgent generates a random Windows Chrome User-Agent string
+// Uses same format as PC version (referensi/backend/spotify_metadata.go) for better API compatibility
+func getRandomUserAgent() string {
+	// Windows 10/11 Chrome format - same as PC version for maximum compatibility
+	// Some APIs may block mobile User-Agents, so we use desktop format
+	winMajor := rand.Intn(2) + 10  // Windows 10 or 11
+	
+	chromeVersion := rand.Intn(25) + 100 // Chrome 100-124
+	chromeBuild := rand.Intn(1500) + 3000 // Build 3000-4500
+	chromePatch := rand.Intn(65) + 60 // Patch 60-125
+	
+	return fmt.Sprintf(
+		"Mozilla/5.0 (Windows NT %d.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/537.36",
+		winMajor,
+		chromeVersion,
+		chromeBuild,
+		chromePatch,
+	)
 }
 
-// getRandomUserAgent generates a random browser-like User-Agent string (Android Chrome format)
-func getRandomUserAgent() string {
-	template := userAgentTemplates[rand.Intn(len(userAgentTemplates))]
+// getRandomMacUserAgent generates a random Mac Chrome User-Agent string
+// Alternative format matching referensi/backend/spotify_metadata.go exactly
+func getRandomMacUserAgent() string {
+	macMajor := rand.Intn(4) + 11  // macOS 11-14
+	macMinor := rand.Intn(5) + 4   // Minor 4-8
+	webkitMajor := rand.Intn(7) + 530
+	webkitMinor := rand.Intn(7) + 30
+	chromeMajor := rand.Intn(25) + 80
+	chromeBuild := rand.Intn(1500) + 3000
+	chromePatch := rand.Intn(65) + 60
+	safariMajor := rand.Intn(7) + 530
+	safariMinor := rand.Intn(6) + 30
 
-	androidVersion := rand.Intn(5) + 10 // Android 10-14
-	deviceModel := rand.Intn(900) + 100 // Random model number
-	chromeVersion := rand.Intn(25) + 100 // Chrome 100-124
-	chromeBuild := rand.Intn(5000) + 5000
-	chromePatch := rand.Intn(200) + 100
+	return fmt.Sprintf(
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
+		macMajor,
+		macMinor,
+		webkitMajor,
+		webkitMinor,
+		chromeMajor,
+		chromeBuild,
+		chromePatch,
+		safariMajor,
+		safariMinor,
+	)
+}
 
-	return fmt.Sprintf(template, androidVersion, deviceModel, chromeVersion, chromeBuild, chromePatch)
+// getRandomDesktopUserAgent randomly picks between Windows and Mac User-Agent
+func getRandomDesktopUserAgent() string {
+	if rand.Intn(2) == 0 {
+		return getRandomUserAgent() // Windows
+	}
+	return getRandomMacUserAgent() // Mac
 }
 
 // Default timeout values
@@ -43,6 +77,7 @@ const (
 )
 
 // Shared transport with connection pooling to prevent TCP exhaustion
+// Optimized for large file downloads (FLAC ~30-50MB)
 var sharedTransport = &http.Transport{
 	DialContext: (&net.Dialer{
 		Timeout:   30 * time.Second,
@@ -56,6 +91,9 @@ var sharedTransport = &http.Transport{
 	ExpectContinueTimeout: 1 * time.Second,
 	DisableKeepAlives:     false, // Enable keep-alives for connection reuse
 	ForceAttemptHTTP2:     true,
+	WriteBufferSize:       64 * 1024,  // 64KB write buffer
+	ReadBufferSize:        64 * 1024,  // 64KB read buffer
+	DisableCompression:    true,       // FLAC is already compressed
 }
 
 // Shared HTTP client for general requests (reuses connections)

go_backend/lyrics.go

@@ -248,6 +248,8 @@ func msToLRCTimestamp(ms int64) string {
 	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
 }
 
+// convertToLRC converts lyrics to LRC format string (without metadata headers)
+// Use convertToLRCWithMetadata for full LRC with headers
 func convertToLRC(lyrics *LyricsResponse) string {
 	if lyrics == nil || len(lyrics.Lines) == 0 {
 		return ""
@@ -272,6 +274,45 @@ func convertToLRC(lyrics *LyricsResponse) string {
 	return builder.String()
 }
 
+// convertToLRCWithMetadata converts lyrics to LRC format with metadata headers
+// Includes [ti:], [ar:], [by:] headers
+func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName string) string {
+	if lyrics == nil || len(lyrics.Lines) == 0 {
+		return ""
+	}
+
+	var builder strings.Builder
+
+	// Add metadata headers
+	builder.WriteString(fmt.Sprintf("[ti:%s]\n", trackName))
+	builder.WriteString(fmt.Sprintf("[ar:%s]\n", artistName))
+	builder.WriteString("[by:SpotiFLAC-Mobile]\n")
+	builder.WriteString("\n")
+
+	// Add lyrics lines
+	if lyrics.SyncType == "LINE_SYNCED" {
+		for _, line := range lyrics.Lines {
+			if line.Words == "" {
+				continue
+			}
+			timestamp := msToLRCTimestamp(line.StartTimeMs)
+			builder.WriteString(timestamp)
+			builder.WriteString(line.Words)
+			builder.WriteString("\n")
+		}
+	} else {
+		for _, line := range lyrics.Lines {
+			if line.Words == "" {
+				continue
+			}
+			builder.WriteString(line.Words)
+			builder.WriteString("\n")
+		}
+	}
+
+	return builder.String()
+}
+
 func simplifyTrackName(name string) string {
 	patterns := []string{
 		`\s*\(feat\..*?\)`,

go_backend/metadata.go

@@ -382,6 +382,7 @@ type AudioQuality struct {
 
 // GetAudioQuality reads bit depth and sample rate from a FLAC file's StreamInfo block
 // FLAC StreamInfo is always the first metadata block after the 4-byte "fLaC" marker
+// For M4A files, it delegates to GetM4AQuality
 func GetAudioQuality(filePath string) (AudioQuality, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -389,45 +390,401 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 	}
 	defer file.Close()
 
-	// Read FLAC marker (4 bytes: "fLaC")
+	// Read first 4 bytes to detect file type
 	marker := make([]byte, 4)
 	if _, err := file.Read(marker); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read marker: %w", err)
 	}
-	if string(marker) != "fLaC" {
-		return AudioQuality{}, fmt.Errorf("not a FLAC file")
-	}
+	
+	// Check if it's a FLAC file
+	if string(marker) == "fLaC" {
+		// Continue reading FLAC metadata
+		// Read metadata block header (4 bytes)
+		header := make([]byte, 4)
+		if _, err := file.Read(header); err != nil {
+			return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
+		}
 
-	// Read metadata block header (4 bytes)
-	// Byte 0: bit 7 = last block flag, bits 0-6 = block type (0 = STREAMINFO)
-	// Bytes 1-3: block length (24-bit big-endian)
-	header := make([]byte, 4)
-	if _, err := file.Read(header); err != nil {
+		blockType := header[0] & 0x7F
+		if blockType != 0 {
+			return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
+		}
+
+		// Read STREAMINFO block (34 bytes minimum)
+		streamInfo := make([]byte, 34)
+		if _, err := file.Read(streamInfo); err != nil {
+			return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
+		}
+
+		// Parse sample rate (20 bits starting at byte 10)
+		sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
+
+		// Parse bits per sample (5 bits)
+		bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
+
+		return AudioQuality{
+			BitDepth:   bitsPerSample,
+			SampleRate: sampleRate,
+		}, nil
+	}
+	
+	// Check if it's an M4A/MP4 file (starts with size + "ftyp")
+	// First 4 bytes are size, next 4 should be "ftyp"
+	file.Seek(0, 0) // Reset to beginning
+	header8 := make([]byte, 8)
+	if _, err := file.Read(header8); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
 	}
-
-	blockType := header[0] & 0x7F
-	if blockType != 0 {
-		return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
+	
+	if string(header8[4:8]) == "ftyp" {
+		// It's an M4A/MP4 file, use M4A quality reader
+		file.Close() // Close before calling GetM4AQuality which opens the file again
+		return GetM4AQuality(filePath)
 	}
-
-	// Read STREAMINFO block (34 bytes minimum)
-	// Bytes 10-13 contain sample rate (20 bits), channels (3 bits), bits per sample (5 bits)
-	streamInfo := make([]byte, 34)
-	if _, err := file.Read(streamInfo); err != nil {
-		return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
-	}
-
-	// Parse sample rate (20 bits starting at byte 10)
-	// Bytes 10-12: [SSSS SSSS] [SSSS SSSS] [SSSS CCCC] where S=sample rate, C=channels
-	sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
-
-	// Parse bits per sample (5 bits)
-	// Byte 12 bits 0-3 and byte 13 bit 7: [.... BBBB] [B...] where B=bits per sample - 1
-	bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
-
-	return AudioQuality{
-		BitDepth:   bitsPerSample,
-		SampleRate: sampleRate,
-	}, nil
+	
+	return AudioQuality{}, fmt.Errorf("unsupported file format (not FLAC or M4A)")
+}
+
+
+// ========================================
+// M4A (MP4/AAC) Metadata Embedding
+// ========================================
+
+// EmbedM4AMetadata embeds metadata into an M4A file using iTunes-style atoms
+// This is a simplified implementation that writes metadata to the file
+func EmbedM4AMetadata(filePath string, metadata Metadata, coverData []byte) error {
+	// Read the entire file
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to read M4A file: %w", err)
+	}
+
+	// Find moov atom position
+	moovPos := findAtom(data, "moov", 0)
+	if moovPos < 0 {
+		return fmt.Errorf("moov atom not found in M4A file")
+	}
+
+	// Find udta atom inside moov, or create one
+	moovSize := int(data[moovPos]<<24 | data[moovPos+1]<<16 | data[moovPos+2]<<8 | data[moovPos+3])
+	udtaPos := findAtom(data, "udta", moovPos+8)
+	
+	// Build new metadata atoms
+	metaAtom := buildMetaAtom(metadata, coverData)
+	
+	var newData []byte
+	if udtaPos >= 0 && udtaPos < moovPos+moovSize {
+		// udta exists, find meta inside it or replace
+		udtaSize := int(data[udtaPos]<<24 | data[udtaPos+1]<<16 | data[udtaPos+2]<<8 | data[udtaPos+3])
+		metaPos := findAtom(data, "meta", udtaPos+8)
+		
+		if metaPos >= 0 && metaPos < udtaPos+udtaSize {
+			// Replace existing meta atom
+			metaSize := int(data[metaPos]<<24 | data[metaPos+1]<<16 | data[metaPos+2]<<8 | data[metaPos+3])
+			newData = append(newData, data[:metaPos]...)
+			newData = append(newData, metaAtom...)
+			newData = append(newData, data[metaPos+metaSize:]...)
+		} else {
+			// Add meta atom to udta
+			newUdtaContent := append(data[udtaPos+8:udtaPos+udtaSize], metaAtom...)
+			newUdtaSize := 8 + len(newUdtaContent)
+			newUdta := make([]byte, 4)
+			newUdta[0] = byte(newUdtaSize >> 24)
+			newUdta[1] = byte(newUdtaSize >> 16)
+			newUdta[2] = byte(newUdtaSize >> 8)
+			newUdta[3] = byte(newUdtaSize)
+			newUdta = append(newUdta, []byte("udta")...)
+			newUdta = append(newUdta, newUdtaContent...)
+			
+			newData = append(newData, data[:udtaPos]...)
+			newData = append(newData, newUdta...)
+			newData = append(newData, data[udtaPos+udtaSize:]...)
+		}
+	} else {
+		// Create new udta with meta
+		udtaContent := metaAtom
+		udtaSize := 8 + len(udtaContent)
+		newUdta := make([]byte, 4)
+		newUdta[0] = byte(udtaSize >> 24)
+		newUdta[1] = byte(udtaSize >> 16)
+		newUdta[2] = byte(udtaSize >> 8)
+		newUdta[3] = byte(udtaSize)
+		newUdta = append(newUdta, []byte("udta")...)
+		newUdta = append(newUdta, udtaContent...)
+		
+		// Insert udta at end of moov
+		insertPos := moovPos + moovSize
+		newData = append(newData, data[:insertPos]...)
+		newData = append(newData, newUdta...)
+		newData = append(newData, data[insertPos:]...)
+	}
+	
+	// Update moov size
+	newMoovSize := moovSize + len(newData) - len(data)
+	newData[moovPos] = byte(newMoovSize >> 24)
+	newData[moovPos+1] = byte(newMoovSize >> 16)
+	newData[moovPos+2] = byte(newMoovSize >> 8)
+	newData[moovPos+3] = byte(newMoovSize)
+
+	// Write back to file
+	if err := os.WriteFile(filePath, newData, 0644); err != nil {
+		return fmt.Errorf("failed to write M4A file: %w", err)
+	}
+
+	fmt.Printf("[M4A] Metadata embedded successfully\n")
+	return nil
+}
+
+// findAtom finds an atom by name starting from offset
+func findAtom(data []byte, name string, offset int) int {
+	for i := offset; i < len(data)-8; {
+		size := int(data[i]<<24 | data[i+1]<<16 | data[i+2]<<8 | data[i+3])
+		if size < 8 {
+			break
+		}
+		atomName := string(data[i+4 : i+8])
+		if atomName == name {
+			return i
+		}
+		i += size
+	}
+	return -1
+}
+
+// buildMetaAtom builds a complete meta atom with ilst containing metadata
+func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
+	// Build ilst content
+	var ilst []byte
+	
+	// ©nam - Title
+	if metadata.Title != "" {
+		ilst = append(ilst, buildTextAtom("©nam", metadata.Title)...)
+	}
+	
+	// ©ART - Artist
+	if metadata.Artist != "" {
+		ilst = append(ilst, buildTextAtom("©ART", metadata.Artist)...)
+	}
+	
+	// ©alb - Album
+	if metadata.Album != "" {
+		ilst = append(ilst, buildTextAtom("©alb", metadata.Album)...)
+	}
+	
+	// aART - Album Artist
+	if metadata.AlbumArtist != "" {
+		ilst = append(ilst, buildTextAtom("aART", metadata.AlbumArtist)...)
+	}
+	
+	// ©day - Year/Date
+	if metadata.Date != "" {
+		ilst = append(ilst, buildTextAtom("©day", metadata.Date)...)
+	}
+	
+	// trkn - Track Number
+	if metadata.TrackNumber > 0 {
+		ilst = append(ilst, buildTrackNumberAtom(metadata.TrackNumber, metadata.TotalTracks)...)
+	}
+	
+	// disk - Disc Number
+	if metadata.DiscNumber > 0 {
+		ilst = append(ilst, buildDiscNumberAtom(metadata.DiscNumber, 0)...)
+	}
+	
+	// ©lyr - Lyrics
+	if metadata.Lyrics != "" {
+		ilst = append(ilst, buildTextAtom("©lyr", metadata.Lyrics)...)
+	}
+	
+	// covr - Cover Art
+	if len(coverData) > 0 {
+		ilst = append(ilst, buildCoverAtom(coverData)...)
+	}
+	
+	// Build ilst atom
+	ilstSize := 8 + len(ilst)
+	ilstAtom := make([]byte, 4)
+	ilstAtom[0] = byte(ilstSize >> 24)
+	ilstAtom[1] = byte(ilstSize >> 16)
+	ilstAtom[2] = byte(ilstSize >> 8)
+	ilstAtom[3] = byte(ilstSize)
+	ilstAtom = append(ilstAtom, []byte("ilst")...)
+	ilstAtom = append(ilstAtom, ilst...)
+	
+	// Build hdlr atom (required for meta)
+	hdlr := []byte{
+		0, 0, 0, 33, // size = 33
+		'h', 'd', 'l', 'r',
+		0, 0, 0, 0, // version + flags
+		0, 0, 0, 0, // predefined
+		'm', 'd', 'i', 'r', // handler type
+		'a', 'p', 'p', 'l', // manufacturer
+		0, 0, 0, 0, // component flags
+		0, 0, 0, 0, // component flags mask
+		0, // null terminator
+	}
+	
+	// Build meta atom
+	metaContent := append([]byte{0, 0, 0, 0}, hdlr...) // version + flags + hdlr
+	metaContent = append(metaContent, ilstAtom...)
+	
+	metaSize := 8 + len(metaContent)
+	metaAtom := make([]byte, 4)
+	metaAtom[0] = byte(metaSize >> 24)
+	metaAtom[1] = byte(metaSize >> 16)
+	metaAtom[2] = byte(metaSize >> 8)
+	metaAtom[3] = byte(metaSize)
+	metaAtom = append(metaAtom, []byte("meta")...)
+	metaAtom = append(metaAtom, metaContent...)
+	
+	return metaAtom
+}
+
+// buildTextAtom builds a text metadata atom (©nam, ©ART, etc.)
+func buildTextAtom(name, value string) []byte {
+	valueBytes := []byte(value)
+	
+	// data atom
+	dataSize := 16 + len(valueBytes)
+	dataAtom := make([]byte, 4)
+	dataAtom[0] = byte(dataSize >> 24)
+	dataAtom[1] = byte(dataSize >> 16)
+	dataAtom[2] = byte(dataSize >> 8)
+	dataAtom[3] = byte(dataSize)
+	dataAtom = append(dataAtom, []byte("data")...)
+	dataAtom = append(dataAtom, 0, 0, 0, 1) // type = UTF-8
+	dataAtom = append(dataAtom, 0, 0, 0, 0) // locale
+	dataAtom = append(dataAtom, valueBytes...)
+	
+	// container atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte(name)...)
+	atom = append(atom, dataAtom...)
+	
+	return atom
+}
+
+// buildTrackNumberAtom builds trkn atom
+func buildTrackNumberAtom(track, total int) []byte {
+	// data atom with track number
+	dataAtom := []byte{
+		0, 0, 0, 24, // size
+		'd', 'a', 't', 'a',
+		0, 0, 0, 0, // type = implicit
+		0, 0, 0, 0, // locale
+		0, 0, // padding
+		byte(track >> 8), byte(track), // track number
+		byte(total >> 8), byte(total), // total tracks
+		0, 0, // padding
+	}
+	
+	// trkn atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("trkn")...)
+	atom = append(atom, dataAtom...)
+	
+	return atom
+}
+
+// buildDiscNumberAtom builds disk atom
+func buildDiscNumberAtom(disc, total int) []byte {
+	// data atom with disc number
+	dataAtom := []byte{
+		0, 0, 0, 22, // size
+		'd', 'a', 't', 'a',
+		0, 0, 0, 0, // type = implicit
+		0, 0, 0, 0, // locale
+		0, 0, // padding
+		byte(disc >> 8), byte(disc), // disc number
+		byte(total >> 8), byte(total), // total discs
+	}
+	
+	// disk atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("disk")...)
+	atom = append(atom, dataAtom...)
+	
+	return atom
+}
+
+// buildCoverAtom builds covr atom with image data
+func buildCoverAtom(coverData []byte) []byte {
+	// Detect image type (JPEG = 13, PNG = 14)
+	imageType := byte(13) // default JPEG
+	if len(coverData) > 8 && coverData[0] == 0x89 && coverData[1] == 'P' && coverData[2] == 'N' && coverData[3] == 'G' {
+		imageType = 14 // PNG
+	}
+	
+	// data atom
+	dataSize := 16 + len(coverData)
+	dataAtom := make([]byte, 4)
+	dataAtom[0] = byte(dataSize >> 24)
+	dataAtom[1] = byte(dataSize >> 16)
+	dataAtom[2] = byte(dataSize >> 8)
+	dataAtom[3] = byte(dataSize)
+	dataAtom = append(dataAtom, []byte("data")...)
+	dataAtom = append(dataAtom, 0, 0, 0, imageType) // type = JPEG or PNG
+	dataAtom = append(dataAtom, 0, 0, 0, 0)         // locale
+	dataAtom = append(dataAtom, coverData...)
+	
+	// covr atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("covr")...)
+	atom = append(atom, dataAtom...)
+	
+	return atom
+}
+
+// GetM4AQuality reads audio quality from M4A file
+func GetM4AQuality(filePath string) (AudioQuality, error) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read M4A file: %w", err)
+	}
+
+	// Find moov -> trak -> mdia -> minf -> stbl -> stsd
+	moovPos := findAtom(data, "moov", 0)
+	if moovPos < 0 {
+		return AudioQuality{}, fmt.Errorf("moov atom not found")
+	}
+
+	// Search for mp4a or alac atom which contains audio info
+	// This is a simplified search - real implementation would traverse the atom tree
+	for i := moovPos; i < len(data)-20; i++ {
+		if string(data[i:i+4]) == "mp4a" || string(data[i:i+4]) == "alac" {
+			// Sample rate is at offset 22-23 from atom start (16-bit big-endian)
+			if i+24 < len(data) {
+				sampleRate := int(data[i+22])<<8 | int(data[i+23])
+				// For AAC, bit depth is typically 16
+				bitDepth := 16
+				if string(data[i:i+4]) == "alac" {
+					// ALAC can have higher bit depth, check esds or alac specific data
+					bitDepth = 24 // Assume 24-bit for ALAC
+				}
+				return AudioQuality{BitDepth: bitDepth, SampleRate: sampleRate}, nil
+			}
+		}
+	}
+
+	return AudioQuality{}, fmt.Errorf("audio info not found in M4A file")
 }

go_backend/parallel.go

@@ -0,0 +1,289 @@
+package gobackend
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+// ========================================
+// ISRC to Track ID Cache
+// ========================================
+
+// TrackIDCacheEntry holds cached track ID with metadata
+type TrackIDCacheEntry struct {
+	TidalTrackID  int64
+	QobuzTrackID  int64
+	AmazonTrackID string
+	ExpiresAt     time.Time
+}
+
+// TrackIDCache caches ISRC to track ID mappings
+type TrackIDCache struct {
+	cache map[string]*TrackIDCacheEntry
+	mu    sync.RWMutex
+	ttl   time.Duration
+}
+
+var (
+	globalTrackIDCache *TrackIDCache
+	trackIDCacheOnce   sync.Once
+)
+
+// GetTrackIDCache returns the global track ID cache
+func GetTrackIDCache() *TrackIDCache {
+	trackIDCacheOnce.Do(func() {
+		globalTrackIDCache = &TrackIDCache{
+			cache: make(map[string]*TrackIDCacheEntry),
+			ttl:   30 * time.Minute, // Cache for 30 minutes
+		}
+	})
+	return globalTrackIDCache
+}
+
+// Get retrieves a cached entry by ISRC
+func (c *TrackIDCache) Get(isrc string) *TrackIDCacheEntry {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	entry, exists := c.cache[isrc]
+	if !exists || time.Now().After(entry.ExpiresAt) {
+		return nil
+	}
+	return entry
+}
+
+// SetTidal caches Tidal track ID for an ISRC
+func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	entry, exists := c.cache[isrc]
+	if !exists {
+		entry = &TrackIDCacheEntry{}
+		c.cache[isrc] = entry
+	}
+	entry.TidalTrackID = trackID
+	entry.ExpiresAt = time.Now().Add(c.ttl)
+}
+
+// SetQobuz caches Qobuz track ID for an ISRC
+func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	entry, exists := c.cache[isrc]
+	if !exists {
+		entry = &TrackIDCacheEntry{}
+		c.cache[isrc] = entry
+	}
+	entry.QobuzTrackID = trackID
+	entry.ExpiresAt = time.Now().Add(c.ttl)
+}
+
+// SetAmazon caches Amazon track ID for an ISRC
+func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	entry, exists := c.cache[isrc]
+	if !exists {
+		entry = &TrackIDCacheEntry{}
+		c.cache[isrc] = entry
+	}
+	entry.AmazonTrackID = trackID
+	entry.ExpiresAt = time.Now().Add(c.ttl)
+}
+
+// Clear removes all cached entries
+func (c *TrackIDCache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.cache = make(map[string]*TrackIDCacheEntry)
+}
+
+// Size returns the number of cached entries
+func (c *TrackIDCache) Size() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.cache)
+}
+
+// ========================================
+// Parallel Download Helper
+// ========================================
+
+// ParallelDownloadResult holds results from parallel operations
+type ParallelDownloadResult struct {
+	CoverData  []byte
+	LyricsData *LyricsResponse
+	LyricsLRC  string
+	CoverErr   error
+	LyricsErr  error
+}
+
+// FetchCoverAndLyricsParallel downloads cover and fetches lyrics in parallel
+// This runs while the main audio download is happening
+func FetchCoverAndLyricsParallel(
+	coverURL string,
+	maxQualityCover bool,
+	spotifyID string,
+	trackName string,
+	artistName string,
+	embedLyrics bool,
+) *ParallelDownloadResult {
+	result := &ParallelDownloadResult{}
+	var wg sync.WaitGroup
+
+	// Download cover in parallel
+	if coverURL != "" {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			fmt.Println("[Parallel] Starting cover download...")
+			data, err := downloadCoverToMemory(coverURL, maxQualityCover)
+			if err != nil {
+				result.CoverErr = err
+				fmt.Printf("[Parallel] Cover download failed: %v\n", err)
+			} else {
+				result.CoverData = data
+				fmt.Printf("[Parallel] Cover downloaded: %d bytes\n", len(data))
+			}
+		}()
+	}
+
+	// Fetch lyrics in parallel
+	if embedLyrics {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			fmt.Println("[Parallel] Starting lyrics fetch...")
+			client := NewLyricsClient()
+			lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
+			if err != nil {
+				result.LyricsErr = err
+				fmt.Printf("[Parallel] Lyrics fetch failed: %v\n", err)
+			} else if lyrics != nil && len(lyrics.Lines) > 0 {
+				result.LyricsData = lyrics
+				// Use LRC with metadata headers (like PC version)
+				result.LyricsLRC = convertToLRCWithMetadata(lyrics, trackName, artistName)
+				fmt.Printf("[Parallel] Lyrics fetched: %d lines\n", len(lyrics.Lines))
+			} else {
+				result.LyricsErr = fmt.Errorf("no lyrics found")
+				fmt.Println("[Parallel] No lyrics found")
+			}
+		}()
+	}
+
+	wg.Wait()
+	return result
+}
+
+// ========================================
+// Pre-warm Cache for Album/Playlist
+// ========================================
+
+// PreWarmCacheRequest represents a track to pre-warm cache for
+type PreWarmCacheRequest struct {
+	ISRC       string
+	TrackName  string
+	ArtistName string
+	SpotifyID  string // Needed for Amazon (SongLink lookup)
+	Service    string // "tidal", "qobuz", "amazon"
+}
+
+// PreWarmTrackCache pre-fetches track IDs for multiple tracks (for album/playlist)
+// This runs in background while user is viewing the track list
+func PreWarmTrackCache(requests []PreWarmCacheRequest) {
+	if len(requests) == 0 {
+		return
+	}
+
+	fmt.Printf("[Cache] Pre-warming cache for %d tracks...\n", len(requests))
+	cache := GetTrackIDCache()
+
+	// Limit concurrent pre-warm requests
+	semaphore := make(chan struct{}, 3) // Max 3 concurrent
+	var wg sync.WaitGroup
+
+	for _, req := range requests {
+		// Skip if already cached
+		if cached := cache.Get(req.ISRC); cached != nil {
+			continue
+		}
+
+		wg.Add(1)
+		go func(r PreWarmCacheRequest) {
+			defer wg.Done()
+			semaphore <- struct{}{}        // Acquire
+			defer func() { <-semaphore }() // Release
+
+			switch r.Service {
+			case "tidal":
+				preWarmTidalCache(r.ISRC, r.TrackName, r.ArtistName)
+			case "qobuz":
+				preWarmQobuzCache(r.ISRC)
+			case "amazon":
+				preWarmAmazonCache(r.ISRC, r.SpotifyID)
+			}
+		}(req)
+	}
+
+	wg.Wait()
+	fmt.Printf("[Cache] Pre-warm complete. Cache size: %d\n", cache.Size())
+}
+
+func preWarmTidalCache(isrc, trackName, artistName string) {
+	downloader := NewTidalDownloader()
+	track, err := downloader.SearchTrackByISRC(isrc)
+	if err == nil && track != nil {
+		GetTrackIDCache().SetTidal(isrc, track.ID)
+		fmt.Printf("[Cache] Cached Tidal ID for ISRC %s: %d\n", isrc, track.ID)
+	}
+}
+
+func preWarmQobuzCache(isrc string) {
+	downloader := NewQobuzDownloader()
+	track, err := downloader.SearchTrackByISRC(isrc)
+	if err == nil && track != nil {
+		GetTrackIDCache().SetQobuz(isrc, track.ID)
+		fmt.Printf("[Cache] Cached Qobuz ID for ISRC %s: %d\n", isrc, track.ID)
+	}
+}
+
+func preWarmAmazonCache(isrc, spotifyID string) {
+	// Amazon uses SongLink to get URL, so we pre-warm by checking availability
+	client := NewSongLinkClient()
+	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
+	if err == nil && availability != nil && availability.Amazon {
+		// Store Amazon URL in cache (using ISRC as key)
+		GetTrackIDCache().SetAmazon(isrc, availability.AmazonURL)
+		fmt.Printf("[Cache] Cached Amazon URL for ISRC %s\n", isrc)
+	}
+}
+
+// ========================================
+// Exported Functions for Flutter
+// ========================================
+
+// PreWarmCache is called from Flutter to pre-warm cache for album/playlist tracks
+// tracksJSON is a JSON array of {isrc, track_name, artist_name, service}
+func PreWarmCache(tracksJSON string) error {
+	var requests []PreWarmCacheRequest
+	// Parse JSON (simplified - in production use proper JSON parsing)
+	// For now, this is called from exports.go with proper parsing
+	
+	go PreWarmTrackCache(requests) // Run in background
+	return nil
+}
+
+// ClearTrackCache clears the track ID cache
+func ClearTrackCache() {
+	GetTrackIDCache().Clear()
+	fmt.Println("[Cache] Track ID cache cleared")
+}
+
+// GetCacheSize returns the current cache size
+func GetCacheSize() int {
+	return GetTrackIDCache().Size()
+}

go_backend/progress.go

@@ -3,6 +3,7 @@ package gobackend
 import (
 	"encoding/json"
 	"sync"
+	"time"
 )
 
 // DownloadProgress represents current download progress
@@ -23,6 +24,7 @@ type ItemProgress struct {
 	BytesTotal    int64   `json:"bytes_total"`
 	BytesReceived int64   `json:"bytes_received"`
 	Progress      float64 `json:"progress"` // 0.0 to 1.0
+	SpeedMBps     float64 `json:"speed_mbps"` // Download speed in MB/s
 	IsDownloading bool    `json:"is_downloading"`
 	Status        string  `json:"status"` // "downloading", "finalizing", "completed"
 }
@@ -124,6 +126,20 @@ func SetItemBytesReceived(itemID string, received int64) {
 	}
 }
 
+// SetItemBytesReceivedWithSpeed sets bytes received and speed for an item
+func SetItemBytesReceivedWithSpeed(itemID string, received int64, speedMBps float64) {
+	multiMu.Lock()
+	defer multiMu.Unlock()
+
+	if item, ok := multiProgress.Items[itemID]; ok {
+		item.BytesReceived = received
+		item.SpeedMBps = speedMBps
+		if item.BytesTotal > 0 {
+			item.Progress = float64(received) / float64(item.BytesTotal)
+		}
+	}
+}
+
 // CompleteItemProgress marks an item as complete
 func CompleteItemProgress(itemID string) {
 	multiMu.Lock()
@@ -196,27 +212,55 @@ func getDownloadDir() string {
 
 // ItemProgressWriter wraps io.Writer to track download progress for a specific item
 type ItemProgressWriter struct {
-	writer  interface{ Write([]byte) (int, error) }
-	itemID  string
-	current int64
+	writer       interface{ Write([]byte) (int, error) }
+	itemID       string
+	current      int64
+	lastReported int64     // Track last reported bytes for threshold-based updates
+	startTime    time.Time // Track start time for speed calculation
+	lastTime     time.Time // Track last update time for speed calculation
+	lastBytes    int64     // Track bytes at last speed calculation
 }
 
+const progressUpdateThreshold = 64 * 1024 // Update progress every 64KB
+
 // NewItemProgressWriter creates a new progress writer for a specific item
 func NewItemProgressWriter(w interface{ Write([]byte) (int, error) }, itemID string) *ItemProgressWriter {
+	now := time.Now()
 	return &ItemProgressWriter{
-		writer:  w,
-		itemID:  itemID,
-		current: 0,
+		writer:       w,
+		itemID:       itemID,
+		current:      0,
+		lastReported: 0,
+		startTime:    now,
+		lastTime:     now,
+		lastBytes:    0,
 	}
 }
 
-// Write implements io.Writer
+// Write implements io.Writer with threshold-based progress updates and speed tracking
 func (pw *ItemProgressWriter) Write(p []byte) (int, error) {
 	n, err := pw.writer.Write(p)
 	if err != nil {
 		return n, err
 	}
 	pw.current += int64(n)
-	SetItemBytesReceived(pw.itemID, pw.current)
+
+	// Update progress when we've received at least 64KB since last update
+	// Also update on first write to show download has started
+	if pw.lastReported == 0 || pw.current-pw.lastReported >= progressUpdateThreshold {
+		// Calculate speed (MB/s) based on bytes received since last update
+		now := time.Now()
+		elapsed := now.Sub(pw.lastTime).Seconds()
+		var speedMBps float64
+		if elapsed > 0 {
+			bytesInInterval := pw.current - pw.lastBytes
+			speedMBps = float64(bytesInInterval) / (1024 * 1024) / elapsed
+		}
+		
+		SetItemBytesReceivedWithSpeed(pw.itemID, pw.current, speedMBps)
+		pw.lastReported = pw.current
+		pw.lastTime = now
+		pw.lastBytes = pw.current
+	}
 	return n, nil
 }

go_backend/qobuz.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"bufio"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -10,6 +11,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 )
 
 // QobuzDownloader handles Qobuz downloads
@@ -19,6 +21,12 @@ type QobuzDownloader struct {
 	apiURL string
 }
 
+var (
+	// Global Qobuz downloader instance for connection reuse
+	globalQobuzDownloader *QobuzDownloader
+	qobuzDownloaderOnce   sync.Once
+)
+
 // QobuzTrack represents a Qobuz track
 type QobuzTrack struct {
 	ID                  int64   `json:"id"`
@@ -97,12 +105,25 @@ func qobuzIsASCIIString(s string) bool {
 	return true
 }
 
-// NewQobuzDownloader creates a new Qobuz downloader
-func NewQobuzDownloader() *QobuzDownloader {
-	return &QobuzDownloader{
-		client: NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
-		appID:  "798273057",
+// containsQueryQobuz checks if a query already exists in the list
+func containsQueryQobuz(queries []string, query string) bool {
+	for _, q := range queries {
+		if q == query {
+			return true
+		}
 	}
+	return false
+}
+
+// NewQobuzDownloader creates a new Qobuz downloader (returns singleton for connection reuse)
+func NewQobuzDownloader() *QobuzDownloader {
+	qobuzDownloaderOnce.Do(func() {
+		globalQobuzDownloader = &QobuzDownloader{
+			client: NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
+			appID:  "798273057",
+		}
+	})
+	return globalQobuzDownloader
 }
 
 // GetAvailableAPIs returns list of available Qobuz APIs
@@ -259,10 +280,11 @@ func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 }
 
 // SearchTrackByMetadataWithDuration searches for a track with duration verification
+// Now includes romaji conversion for Japanese text (same as Tidal)
 func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistName string, expectedDurationSec int) (*QobuzTrack, error) {
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
 
-	// Try multiple search strategies
+	// Try multiple search strategies (same as Tidal/PC version)
 	queries := []string{}
 
 	// Strategy 1: Artist + Track name
@@ -275,10 +297,54 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		queries = append(queries, trackName)
 	}
 
+	// Strategy 3: Romaji versions if Japanese detected
+	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
+		// Convert to romaji (hiragana/katakana only, kanji stays)
+		romajiTrack := JapaneseToRomaji(trackName)
+		romajiArtist := JapaneseToRomaji(artistName)
+
+		// Clean and remove ALL non-ASCII characters (including kanji)
+		cleanRomajiTrack := CleanToASCII(romajiTrack)
+		cleanRomajiArtist := CleanToASCII(romajiArtist)
+
+		// Artist + Track romaji (cleaned to ASCII only)
+		if cleanRomajiArtist != "" && cleanRomajiTrack != "" {
+			romajiQuery := cleanRomajiArtist + " " + cleanRomajiTrack
+			if !containsQueryQobuz(queries, romajiQuery) {
+				queries = append(queries, romajiQuery)
+				fmt.Printf("[Qobuz] Japanese detected, adding romaji query: %s\n", romajiQuery)
+			}
+		}
+
+		// Track romaji only (cleaned)
+		if cleanRomajiTrack != "" && cleanRomajiTrack != trackName {
+			if !containsQueryQobuz(queries, cleanRomajiTrack) {
+				queries = append(queries, cleanRomajiTrack)
+			}
+		}
+	}
+
+	// Strategy 4: Artist only as last resort
+	if artistName != "" {
+		artistOnly := CleanToASCII(JapaneseToRomaji(artistName))
+		if artistOnly != "" && !containsQueryQobuz(queries, artistOnly) {
+			queries = append(queries, artistOnly)
+		}
+	}
+
 	var allTracks []QobuzTrack
+	searchedQueries := make(map[string]bool)
 
 	for _, query := range queries {
-		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(query), q.appID)
+		cleanQuery := strings.TrimSpace(query)
+		if cleanQuery == "" || searchedQueries[cleanQuery] {
+			continue
+		}
+		searchedQueries[cleanQuery] = true
+
+		fmt.Printf("[Qobuz] Searching for: %s\n", cleanQuery)
+
+		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(cleanQuery), q.appID)
 
 		req, err := http.NewRequest("GET", searchURL, nil)
 		if err != nil {
@@ -287,6 +353,7 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 
 		resp, err := DoRequestWithUserAgent(q.client, req)
 		if err != nil {
+			fmt.Printf("[Qobuz] Search error for '%s': %v\n", cleanQuery, err)
 			continue
 		}
 
@@ -307,6 +374,7 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		resp.Body.Close()
 
 		if len(result.Tracks.Items) > 0 {
+			fmt.Printf("[Qobuz] Found %d results for '%s'\n", len(result.Tracks.Items), cleanQuery)
 			allTracks = append(allTracks, result.Tracks.Items...)
 		}
 	}
@@ -462,33 +530,68 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}
 
+	expectedSize := resp.ContentLength
 	// Set total bytes if available
-	if resp.ContentLength > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
 	}
 
 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
-	defer out.Close()
 
-	// Use item progress writer
+	// Use buffered writer for better performance (256KB buffer)
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
+
+	// Use item progress writer with buffered output
+	var written int64
 	if itemID != "" {
-		progressWriter := NewItemProgressWriter(out, itemID)
-		_, err = io.Copy(progressWriter, resp.Body)
+		progressWriter := NewItemProgressWriter(bufWriter, itemID)
+		written, err = io.Copy(progressWriter, resp.Body)
 	} else {
 		// Fallback: direct copy without progress tracking
-		_, err = io.Copy(out, resp.Body)
+		written, err = io.Copy(bufWriter, resp.Body)
 	}
-	return err
+
+	// Flush buffer before checking for errors
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	// Check for any errors
+	if err != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	// Verify file size if Content-Length was provided
+	if expectedSize > 0 && written != expectedSize {
+		os.Remove(outputPath)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	return nil
 }
 
 // QobuzDownloadResult contains download result with quality info
 type QobuzDownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
 }
 
 // downloadFromQobuz downloads a track using the request parameters
@@ -506,8 +609,21 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	var track *QobuzTrack
 	var err error
 
-	// Strategy 1: Search by ISRC with duration verification
+	// OPTIMIZATION: Check cache first for track ID
 	if req.ISRC != "" {
+		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.QobuzTrackID > 0 {
+			fmt.Printf("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
+			// For Qobuz we need to search again to get full track info, but we can use the ID
+			track, err = downloader.SearchTrackByISRC(req.ISRC)
+			if err != nil {
+				fmt.Printf("[Qobuz] Cache hit but search failed: %v\n", err)
+				track = nil
+			}
+		}
+	}
+
+	// Strategy 1: Search by ISRC with duration verification
+	if track == nil && req.ISRC != "" {
 		track, err = downloader.SearchTrackByISRCWithDuration(req.ISRC, expectedDurationSec)
 		// Verify artist
 		if track != nil && !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
@@ -536,8 +652,11 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		return QobuzDownloadResult{}, fmt.Errorf("qobuz search failed: %s", errMsg)
 	}
 
-	// Log match found
+	// Log match found and cache the track ID
 	fmt.Printf("[Qobuz] Match found: '%s' by '%s' (duration: %ds)\n", track.Title, track.Performer.Name, track.Duration)
+	if req.ISRC != "" {
+		GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
+	}
 
 	// Build filename
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
@@ -581,11 +700,29 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		return QobuzDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
-	// Download file with item ID for progress tracking
+	// START PARALLEL: Fetch cover and lyrics while downloading audio
+	var parallelResult *ParallelDownloadResult
+	parallelDone := make(chan struct{})
+	go func() {
+		defer close(parallelDone)
+		parallelResult = FetchCoverAndLyricsParallel(
+			req.CoverURL,
+			req.EmbedMaxQualityCover,
+			req.SpotifyID,
+			req.TrackName,
+			req.ArtistName,
+			req.EmbedLyrics,
+		)
+	}()
+
+	// Download audio file with item ID for progress tracking
 	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
 		return QobuzDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
+	// Wait for parallel operations to complete
+	<-parallelDone
+
 	// Set progress to 100% and status to finalizing (before embedding)
 	// This makes the UI show "Finalizing..." while embedding happens
 	if req.ItemID != "" {
@@ -593,59 +730,55 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		SetItemFinalizing(req.ItemID)
 	}
 
-	// Embed metadata
+	// Embed metadata using parallel-fetched cover data
+	// Use metadata from the actual Qobuz track found (more accurate than request)
 	metadata := Metadata{
-		Title:       req.TrackName,
-		Artist:      req.ArtistName,
-		Album:       req.AlbumName,
-		AlbumArtist: req.AlbumArtist,
-		Date:        req.ReleaseDate,
-		TrackNumber: req.TrackNumber,
+		Title:       track.Title,
+		Artist:      track.Performer.Name,
+		Album:       track.Album.Title,
+		AlbumArtist: req.AlbumArtist, // Qobuz track struct might not have this handy, keep req or check album struct
+		Date:        track.Album.ReleaseDate,
+		TrackNumber: track.TrackNumber,
 		TotalTracks: req.TotalTracks,
-		DiscNumber:  req.DiscNumber,
-		ISRC:        req.ISRC,
+		DiscNumber:  req.DiscNumber, // QobuzTrack struct usually doesn't have disc info in simple search result
+		ISRC:        track.ISRC,
 	}
 
-	// Download cover to memory (avoids file permission issues on Android)
+	// Use cover data from parallel fetch
 	var coverData []byte
-	if req.CoverURL != "" {
-		fmt.Println("[Qobuz] Downloading cover to memory...")
-		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
-		if err == nil {
-			coverData = data
-			fmt.Printf("[Qobuz] Cover downloaded successfully (%d bytes)\n", len(coverData))
-		} else {
-			fmt.Printf("[Qobuz] Warning: failed to download cover: %v\n", err)
-		}
+	if parallelResult != nil && parallelResult.CoverData != nil {
+		coverData = parallelResult.CoverData
+		fmt.Printf("[Qobuz] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
 	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
 		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 	}
 
-	// Embed lyrics if enabled
-	if req.EmbedLyrics {
-		fmt.Println("[Qobuz] Fetching lyrics...")
-		lyricsClient := NewLyricsClient()
-		lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
-		if lyricsErr != nil {
-			fmt.Printf("[Qobuz] Warning: lyrics fetch error: %v\n", lyricsErr)
-		} else if lyrics == nil || len(lyrics.Lines) == 0 {
-			fmt.Println("[Qobuz] No lyrics found for this track")
+	// Embed lyrics from parallel fetch
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		fmt.Printf("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+		if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+			fmt.Printf("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
 		} else {
-			fmt.Printf("[Qobuz] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-			lrcContent := convertToLRC(lyrics)
-			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
-				fmt.Printf("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Qobuz] Lyrics embedded successfully")
-			}
+			fmt.Println("[Qobuz] Lyrics embedded successfully")
 		}
+	} else if req.EmbedLyrics {
+		fmt.Println("[Qobuz] No lyrics available from parallel fetch")
 	}
 
+	// Add to ISRC index for fast duplicate checking
+	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+
 	return QobuzDownloadResult{
-		FilePath:   outputPath,
-		BitDepth:   actualBitDepth,
-		SampleRate: actualSampleRate,
+		FilePath:    outputPath,
+		BitDepth:    actualBitDepth,
+		SampleRate:  actualSampleRate,
+		Title:       track.Title,
+		Artist:      track.Performer.Name,
+		Album:       track.Album.Title,
+		ReleaseDate: track.Album.ReleaseDate,
+		TrackNumber: track.TrackNumber,
+		DiscNumber:  req.DiscNumber, // Qobuz track struct limitations
 	}, nil
 }

go_backend/romaji.go

@@ -0,0 +1,222 @@
+package gobackend
+
+import (
+	"strings"
+	"unicode"
+)
+
+// Hiragana to Romaji mapping
+var hiraganaToRomaji = map[rune]string{
+	'あ': "a", 'い': "i", 'う': "u", 'え': "e", 'お': "o",
+	'か': "ka", 'き': "ki", 'く': "ku", 'け': "ke", 'こ': "ko",
+	'さ': "sa", 'し': "shi", 'す': "su", 'せ': "se", 'そ': "so",
+	'た': "ta", 'ち': "chi", 'つ': "tsu", 'て': "te", 'と': "to",
+	'な': "na", 'に': "ni", 'ぬ': "nu", 'ね': "ne", 'の': "no",
+	'は': "ha", 'ひ': "hi", 'ふ': "fu", 'へ': "he", 'ほ': "ho",
+	'ま': "ma", 'み': "mi", 'む': "mu", 'め': "me", 'も': "mo",
+	'や': "ya", 'ゆ': "yu", 'よ': "yo",
+	'ら': "ra", 'り': "ri", 'る': "ru", 'れ': "re", 'ろ': "ro",
+	'わ': "wa", 'を': "wo", 'ん': "n",
+	// Dakuten (voiced)
+	'が': "ga", 'ぎ': "gi", 'ぐ': "gu", 'げ': "ge", 'ご': "go",
+	'ざ': "za", 'じ': "ji", 'ず': "zu", 'ぜ': "ze", 'ぞ': "zo",
+	'だ': "da", 'ぢ': "ji", 'づ': "zu", 'で': "de", 'ど': "do",
+	'ば': "ba", 'び': "bi", 'ぶ': "bu", 'べ': "be", 'ぼ': "bo",
+	// Handakuten (semi-voiced)
+	'ぱ': "pa", 'ぴ': "pi", 'ぷ': "pu", 'ぺ': "pe", 'ぽ': "po",
+	// Small characters
+	'ゃ': "ya", 'ゅ': "yu", 'ょ': "yo",
+	'っ': "", // Double consonant marker
+	'ぁ': "a", 'ぃ': "i", 'ぅ': "u", 'ぇ': "e", 'ぉ': "o",
+}
+
+// Katakana to Romaji mapping
+var katakanaToRomaji = map[rune]string{
+	'ア': "a", 'イ': "i", 'ウ': "u", 'エ': "e", 'オ': "o",
+	'カ': "ka", 'キ': "ki", 'ク': "ku", 'ケ': "ke", 'コ': "ko",
+	'サ': "sa", 'シ': "shi", 'ス': "su", 'セ': "se", 'ソ': "so",
+	'タ': "ta", 'チ': "chi", 'ツ': "tsu", 'テ': "te", 'ト': "to",
+	'ナ': "na", 'ニ': "ni", 'ヌ': "nu", 'ネ': "ne", 'ノ': "no",
+	'ハ': "ha", 'ヒ': "hi", 'フ': "fu", 'ヘ': "he", 'ホ': "ho",
+	'マ': "ma", 'ミ': "mi", 'ム': "mu", 'メ': "me", 'モ': "mo",
+	'ヤ': "ya", 'ユ': "yu", 'ヨ': "yo",
+	'ラ': "ra", 'リ': "ri", 'ル': "ru", 'レ': "re", 'ロ': "ro",
+	'ワ': "wa", 'ヲ': "wo", 'ン': "n",
+	// Dakuten (voiced)
+	'ガ': "ga", 'ギ': "gi", 'グ': "gu", 'ゲ': "ge", 'ゴ': "go",
+	'ザ': "za", 'ジ': "ji", 'ズ': "zu", 'ゼ': "ze", 'ゾ': "zo",
+	'ダ': "da", 'ヂ': "ji", 'ヅ': "zu", 'デ': "de", 'ド': "do",
+	'バ': "ba", 'ビ': "bi", 'ブ': "bu", 'ベ': "be", 'ボ': "bo",
+	// Handakuten (semi-voiced)
+	'パ': "pa", 'ピ': "pi", 'プ': "pu", 'ペ': "pe", 'ポ': "po",
+	// Small characters
+	'ャ': "ya", 'ュ': "yu", 'ョ': "yo",
+	'ッ': "", // Double consonant marker
+	'ァ': "a", 'ィ': "i", 'ゥ': "u", 'ェ': "e", 'ォ': "o",
+	// Extended katakana
+	'ー': "", // Long vowel mark
+	'ヴ': "vu",
+}
+
+// Combination mappings for きゃ, しゃ, etc.
+var combinationHiragana = map[string]string{
+	"きゃ": "kya", "きゅ": "kyu", "きょ": "kyo",
+	"しゃ": "sha", "しゅ": "shu", "しょ": "sho",
+	"ちゃ": "cha", "ちゅ": "chu", "ちょ": "cho",
+	"にゃ": "nya", "にゅ": "nyu", "にょ": "nyo",
+	"ひゃ": "hya", "ひゅ": "hyu", "ひょ": "hyo",
+	"みゃ": "mya", "みゅ": "myu", "みょ": "myo",
+	"りゃ": "rya", "りゅ": "ryu", "りょ": "ryo",
+	"ぎゃ": "gya", "ぎゅ": "gyu", "ぎょ": "gyo",
+	"じゃ": "ja", "じゅ": "ju", "じょ": "jo",
+	"びゃ": "bya", "びゅ": "byu", "びょ": "byo",
+	"ぴゃ": "pya", "ぴゅ": "pyu", "ぴょ": "pyo",
+}
+
+var combinationKatakana = map[string]string{
+	"キャ": "kya", "キュ": "kyu", "キョ": "kyo",
+	"シャ": "sha", "シュ": "shu", "ショ": "sho",
+	"チャ": "cha", "チュ": "chu", "チョ": "cho",
+	"ニャ": "nya", "ニュ": "nyu", "ニョ": "nyo",
+	"ヒャ": "hya", "ヒュ": "hyu", "ヒョ": "hyo",
+	"ミャ": "mya", "ミュ": "myu", "ミョ": "myo",
+	"リャ": "rya", "リュ": "ryu", "リョ": "ryo",
+	"ギャ": "gya", "ギュ": "gyu", "ギョ": "gyo",
+	"ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
+	"ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
+	"ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
+	// Extended combinations
+	"ティ": "ti", "ディ": "di", "トゥ": "tu", "ドゥ": "du",
+	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
+	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
+}
+
+// ContainsJapanese checks if a string contains Japanese characters
+func ContainsJapanese(s string) bool {
+	for _, r := range s {
+		if isHiragana(r) || isKatakana(r) || isKanji(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func isHiragana(r rune) bool {
+	return r >= 0x3040 && r <= 0x309F
+}
+
+func isKatakana(r rune) bool {
+	return r >= 0x30A0 && r <= 0x30FF
+}
+
+func isKanji(r rune) bool {
+	return (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
+		(r >= 0x3400 && r <= 0x4DBF) // CJK Unified Ideographs Extension A
+}
+
+// JapaneseToRomaji converts Japanese text (hiragana/katakana) to romaji
+// Note: Kanji cannot be converted without a dictionary, so they are kept as-is
+func JapaneseToRomaji(text string) string {
+	if !ContainsJapanese(text) {
+		return text
+	}
+
+	var result strings.Builder
+	runes := []rune(text)
+	i := 0
+
+	for i < len(runes) {
+		// Check for っ/ッ (double consonant)
+		if i < len(runes)-1 && (runes[i] == 'っ' || runes[i] == 'ッ') {
+			nextRomaji := ""
+			if romaji, ok := hiraganaToRomaji[runes[i+1]]; ok {
+				nextRomaji = romaji
+			} else if romaji, ok := katakanaToRomaji[runes[i+1]]; ok {
+				nextRomaji = romaji
+			}
+			if len(nextRomaji) > 0 {
+				result.WriteByte(nextRomaji[0]) // Double the first consonant
+			}
+			i++
+			continue
+		}
+
+		// Check for two-character combinations
+		if i < len(runes)-1 {
+			combo := string(runes[i : i+2])
+			if romaji, ok := combinationHiragana[combo]; ok {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+			if romaji, ok := combinationKatakana[combo]; ok {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+		}
+
+		// Single character conversion
+		r := runes[i]
+		if romaji, ok := hiraganaToRomaji[r]; ok {
+			result.WriteString(romaji)
+		} else if romaji, ok := katakanaToRomaji[r]; ok {
+			result.WriteString(romaji)
+		} else if isKanji(r) {
+			// Keep kanji as-is (would need dictionary for proper conversion)
+			result.WriteRune(r)
+		} else {
+			// Keep other characters (punctuation, spaces, etc.)
+			result.WriteRune(r)
+		}
+		i++
+	}
+
+	return result.String()
+}
+
+// BuildSearchQuery creates a search query from track name and artist
+// Converts Japanese to romaji if present
+func BuildSearchQuery(trackName, artistName string) string {
+	// Convert Japanese to romaji
+	trackRomaji := JapaneseToRomaji(trackName)
+	artistRomaji := JapaneseToRomaji(artistName)
+
+	// Clean up the query - remove special characters that might interfere with search
+	trackClean := cleanSearchQuery(trackRomaji)
+	artistClean := cleanSearchQuery(artistRomaji)
+
+	return strings.TrimSpace(artistClean + " " + trackClean)
+}
+
+// cleanSearchQuery removes special characters that might interfere with search
+func cleanSearchQuery(s string) string {
+	var result strings.Builder
+	for _, r := range s {
+		if unicode.IsLetter(r) || unicode.IsNumber(r) || unicode.IsSpace(r) {
+			result.WriteRune(r)
+		} else if r == '-' || r == '\'' {
+			result.WriteRune(r)
+		}
+	}
+	return strings.TrimSpace(result.String())
+}
+
+// CleanToASCII removes all non-ASCII characters and keeps only letters, numbers, spaces
+// This is useful for creating search queries that work better with Tidal's search
+func CleanToASCII(s string) string {
+	var result strings.Builder
+	for _, r := range s {
+		// Keep only ASCII letters, numbers, spaces, and basic punctuation
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
+			(r >= '0' && r <= '9') || r == ' ' || r == '-' || r == '\'' {
+			result.WriteRune(r)
+		} else if r == ',' || r == '.' {
+			// Convert punctuation to space
+			result.WriteRune(' ')
+		}
+	}
+	// Clean up multiple spaces
+	cleaned := strings.Join(strings.Fields(result.String()), " ")
+	return strings.TrimSpace(cleaned)
+}

go_backend/songlink.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+	"strings"
+	"sync"
 	"time"
 )
 
@@ -20,20 +22,37 @@ type TrackAvailability struct {
 	Tidal     bool   `json:"tidal"`
 	Amazon    bool   `json:"amazon"`
 	Qobuz     bool   `json:"qobuz"`
+	Deezer    bool   `json:"deezer"`
 	TidalURL  string `json:"tidal_url,omitempty"`
 	AmazonURL string `json:"amazon_url,omitempty"`
 	QobuzURL  string `json:"qobuz_url,omitempty"`
+	DeezerURL string `json:"deezer_url,omitempty"`
+	DeezerID  string `json:"deezer_id,omitempty"`
 }
 
-// NewSongLinkClient creates a new SongLink client
+var (
+	// Global SongLink client instance for connection reuse
+	globalSongLinkClient *SongLinkClient
+	songLinkClientOnce   sync.Once
+)
+
+// NewSongLinkClient creates a new SongLink client (returns singleton for connection reuse)
 func NewSongLinkClient() *SongLinkClient {
-	return &SongLinkClient{
-		client: NewHTTPClientWithTimeout(SongLinkTimeout), // 30s timeout
-	}
+	songLinkClientOnce.Do(func() {
+		globalSongLinkClient = &SongLinkClient{
+			client: NewHTTPClientWithTimeout(SongLinkTimeout), // 30s timeout
+		}
+	})
+	return globalSongLinkClient
 }
 
 // CheckTrackAvailability checks track availability on streaming platforms
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
+	// Validate Spotify ID format (should be 22 characters alphanumeric)
+	if spotifyTrackID == "" {
+		return nil, fmt.Errorf("spotify track ID is empty")
+	}
+	
 	// Use global rate limiter - blocks until request is allowed
 	songLinkRateLimiter.WaitForSlot()
 
@@ -57,8 +76,18 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	}
 	defer resp.Body.Close()
 
+	// Handle specific error codes
+	if resp.StatusCode == 400 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid Spotify ID or track unavailable)")
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	if resp.StatusCode == 429 {
+		return nil, fmt.Errorf("SongLink rate limit exceeded")
+	}
 	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
 	}
 
 	body, err := ReadResponseBody(resp)
@@ -92,7 +121,15 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		availability.AmazonURL = amazonLink.URL
 	}
 
-	// Check Qobuz using ISRC
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		// Extract Deezer ID from URL (e.g., https://www.deezer.com/track/123456)
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	// Check Qobuz using ISRC (SongLink doesn't support Qobuz directly)
 	if isrc != "" {
 		availability.Qobuz = checkQobuzAvailability(isrc)
 	}
@@ -151,3 +188,357 @@ func checkQobuzAvailability(isrc string) bool {
 
 	return searchResp.Tracks.Total > 0
 }
+
+// extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
+func extractDeezerIDFromURL(deezerURL string) string {
+	// URL format: https://www.deezer.com/track/123456 or https://www.deezer.com/en/track/123456
+	parts := strings.Split(deezerURL, "/")
+	if len(parts) > 0 {
+		// Get the last part which should be the ID
+		lastPart := parts[len(parts)-1]
+		// Remove any query parameters
+		if idx := strings.Index(lastPart, "?"); idx > 0 {
+			lastPart = lastPart[:idx]
+		}
+		return lastPart
+	}
+	return ""
+}
+
+// GetDeezerIDFromSpotify converts a Spotify track ID to Deezer track ID using SongLink
+func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
+	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Deezer || availability.DeezerID == "" {
+		return "", fmt.Errorf("track not found on Deezer")
+	}
+	
+	return availability.DeezerID, nil
+}
+
+// AlbumAvailability represents album availability on different platforms
+type AlbumAvailability struct {
+	SpotifyID string `json:"spotify_id"`
+	Deezer    bool   `json:"deezer"`
+	DeezerURL string `json:"deezer_url,omitempty"`
+	DeezerID  string `json:"deezer_id,omitempty"`
+}
+
+// CheckAlbumAvailability checks album availability on streaming platforms using SongLink
+func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build API URL for album
+	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLw==")
+	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyAlbumID)
+
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check album availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &AlbumAvailability{
+		SpotifyID: spotifyAlbumID,
+	}
+
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	return availability, nil
+}
+
+// GetDeezerAlbumIDFromSpotify converts a Spotify album ID to Deezer album ID using SongLink
+func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (string, error) {
+	availability, err := s.CheckAlbumAvailability(spotifyAlbumID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Deezer || availability.DeezerID == "" {
+		return "", fmt.Errorf("album not found on Deezer")
+	}
+	
+	return availability.DeezerID, nil
+}
+
+// ========================================
+// Deezer ID Support - Query SongLink using Deezer as source
+// ========================================
+
+// CheckAvailabilityFromDeezer checks track availability using Deezer track ID as source
+// This is useful when we have Deezer metadata and want to find the track on other platforms
+func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*TrackAvailability, error) {
+	if deezerTrackID == "" {
+		return nil, fmt.Errorf("deezer track ID is empty")
+	}
+	
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build Deezer URL
+	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
+
+	// Build API URL using Deezer URL as source
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s&userCountry=US", string(apiBase), url.QueryEscape(deezerURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Handle specific error codes
+	if resp.StatusCode == 400 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid Deezer ID)")
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	if resp.StatusCode == 429 {
+		return nil, fmt.Errorf("SongLink rate limit exceeded")
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `json:"linksByPlatform"`
+		EntitiesByUniqueId map[string]struct {
+			ID         string `json:"id"`
+			Type       string `json:"type"`
+			Title      string `json:"title"`
+			ArtistName string `json:"artistName"`
+		} `json:"entitiesByUniqueId"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{
+		Deezer:   true,
+		DeezerID: deezerTrackID,
+	}
+
+	// Check Spotify
+	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
+		// Extract Spotify ID from URL
+		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+	}
+
+	// Check Tidal
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+	}
+
+	// Check Amazon
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+
+	// Check Deezer URL
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.DeezerURL = deezerLink.URL
+	}
+
+	return availability, nil
+}
+
+// CheckAvailabilityByPlatform checks track availability using any supported platform
+// platform: "spotify", "deezer", "tidal", "amazonMusic", "appleMusic", "youtube", etc.
+// entityType: "song" or "album"
+// entityID: the ID on that platform
+func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entityID string) (*TrackAvailability, error) {
+	if entityID == "" {
+		return nil, fmt.Errorf("%s ID is empty", platform)
+	}
+	
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build API URL using platform, type, and id parameters (as per API docs)
+	// https://api.song.link/v1-alpha.1/links?platform=deezer&type=song&id=123456
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?platform=%s&type=%s&id=%s&userCountry=US",
+		url.QueryEscape(platform),
+		url.QueryEscape(entityType),
+		url.QueryEscape(entityID))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Handle specific error codes
+	if resp.StatusCode == 400 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid %s ID)", platform)
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	if resp.StatusCode == 429 {
+		return nil, fmt.Errorf("SongLink rate limit exceeded")
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{}
+
+	// Check Spotify
+	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
+		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+	}
+
+	// Check Tidal
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+	}
+
+	// Check Amazon
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	return availability, nil
+}
+
+// extractSpotifyIDFromURL extracts Spotify track ID from URL
+func extractSpotifyIDFromURL(spotifyURL string) string {
+	// URL format: https://open.spotify.com/track/0Jcij1eWd5bDMU5iPbxe2i
+	parts := strings.Split(spotifyURL, "/track/")
+	if len(parts) > 1 {
+		// Get the ID part and remove any query parameters
+		idPart := parts[1]
+		if idx := strings.Index(idPart, "?"); idx > 0 {
+			idPart = idPart[:idx]
+		}
+		return idPart
+	}
+	return ""
+}
+
+// GetSpotifyIDFromDeezer converts a Deezer track ID to Spotify track ID using SongLink
+func (s *SongLinkClient) GetSpotifyIDFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if availability.SpotifyID == "" {
+		return "", fmt.Errorf("track not found on Spotify")
+	}
+	
+	return availability.SpotifyID, nil
+}
+
+// GetTidalURLFromDeezer converts a Deezer track ID to Tidal URL using SongLink
+func (s *SongLinkClient) GetTidalURLFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Tidal || availability.TidalURL == "" {
+		return "", fmt.Errorf("track not found on Tidal")
+	}
+	
+	return availability.TidalURL, nil
+}
+
+// GetAmazonURLFromDeezer converts a Deezer track ID to Amazon Music URL using SongLink
+func (s *SongLinkClient) GetAmazonURLFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Amazon || availability.AmazonURL == "" {
+		return "", fmt.Errorf("track not found on Amazon Music")
+	}
+	
+	return availability.AmazonURL, nil
+}

go_backend/spotify.go

@@ -495,6 +495,17 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	}
 	c.cacheMu.RUnlock()
 
+	// Track item structure for pagination
+	type trackItem struct {
+		ID          string      `json:"id"`
+		Name        string      `json:"name"`
+		DurationMS  int         `json:"duration_ms"`
+		TrackNumber int         `json:"track_number"`
+		DiscNumber  int         `json:"disc_number"`
+		ExternalURL externalURL `json:"external_urls"`
+		Artists     []artist    `json:"artists"`
+	}
+
 	var data struct {
 		Name        string   `json:"name"`
 		ReleaseDate string   `json:"release_date"`
@@ -502,15 +513,8 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images      []image  `json:"images"`
 		Artists     []artist `json:"artists"`
 		Tracks      struct {
-			Items []struct {
-				ID          string      `json:"id"`
-				Name        string      `json:"name"`
-				DurationMS  int         `json:"duration_ms"`
-				TrackNumber int         `json:"track_number"`
-				DiscNumber  int         `json:"disc_number"`
-				ExternalURL externalURL `json:"external_urls"`
-				Artists     []artist    `json:"artists"`
-			} `json:"items"`
+			Items []trackItem `json:"items"`
+			Next  string      `json:"next"`
 		} `json:"tracks"`
 	}
 
@@ -527,10 +531,38 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images:      albumImage,
 	}
 
-	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
-	for _, item := range data.Tracks.Items {
-		// Fetch ISRC for each track
-		isrc := c.fetchTrackISRC(ctx, item.ID, token)
+	// Collect all tracks (including paginated)
+	allTrackItems := data.Tracks.Items
+	nextURL := data.Tracks.Next
+	
+	// Fetch remaining tracks using pagination (no limit)
+	for nextURL != "" {
+		var pageData struct {
+			Items []trackItem `json:"items"`
+			Next  string      `json:"next"`
+		}
+		if err := c.getJSON(ctx, nextURL, token, &pageData); err != nil {
+			fmt.Printf("[Spotify] Warning: failed to fetch album tracks page: %v\n", err)
+			break
+		}
+		allTrackItems = append(allTrackItems, pageData.Items...)
+		nextURL = pageData.Next
+	}
+
+	fmt.Printf("[Spotify] Album has %d tracks (total: %d)\n", len(allTrackItems), data.TotalTracks)
+
+	// Collect track IDs for parallel ISRC fetching
+	trackIDs := make([]string, len(allTrackItems))
+	for i, item := range allTrackItems {
+		trackIDs[i] = item.ID
+	}
+
+	// Fetch ISRCs in parallel for ALL tracks (like Deezer implementation)
+	isrcMap := c.fetchISRCsParallel(ctx, trackIDs, token)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(allTrackItems))
+	for _, item := range allTrackItems {
+		isrc := isrcMap[item.ID]
 		
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   item.ID,
@@ -566,6 +598,47 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	return result, nil
 }
 
+// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel
+// Similar to Deezer implementation for consistency
+func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs []string, token string) map[string]string {
+	const maxParallelISRC = 10 // Max concurrent ISRC fetches
+	
+	result := make(map[string]string)
+	var resultMu sync.Mutex
+	
+	if len(trackIDs) == 0 {
+		return result
+	}
+	
+	// Use semaphore to limit concurrent requests
+	sem := make(chan struct{}, maxParallelISRC)
+	var wg sync.WaitGroup
+	
+	for _, trackID := range trackIDs {
+		wg.Add(1)
+		go func(id string) {
+			defer wg.Done()
+			
+			// Acquire semaphore
+			select {
+			case sem <- struct{}{}:
+				defer func() { <-sem }()
+			case <-ctx.Done():
+				return
+			}
+			
+			isrc := c.fetchTrackISRC(ctx, id, token)
+			
+			resultMu.Lock()
+			result[id] = isrc
+			resultMu.Unlock()
+		}(trackID)
+	}
+	
+	wg.Wait()
+	return result
+}
+
 func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, token string) (*PlaylistResponsePayload, error) {
 	// First request to get playlist info and first batch of tracks
 	var data struct {
@@ -620,11 +693,10 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		})
 	}
 
-	// Fetch remaining tracks using pagination (up to 1000 tracks max)
+	// Fetch remaining tracks using pagination (NO LIMIT - fetch all tracks)
 	nextURL := data.Tracks.Next
-	maxTracks := 1000
 	
-	for nextURL != "" && len(tracks) < maxTracks {
+	for nextURL != "" {
 		var pageData struct {
 			Items []struct {
 				Track *trackFull `json:"track"`
@@ -642,9 +714,6 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 			if item.Track == nil {
 				continue
 			}
-			if len(tracks) >= maxTracks {
-				break
-			}
 			tracks = append(tracks, AlbumTrackMetadata{
 				SpotifyID:   item.Track.ID,
 				Artists:     joinArtists(item.Track.Artists),
@@ -835,8 +904,16 @@ func (c *SpotifyMetadataClient) getJSON(ctx context.Context, endpoint, token str
 		return err
 	}
 
+	// Set headers (same as PC version baseHeaders)
 	req.Header.Set("User-Agent", c.userAgent)
 	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
+	req.Header.Set("sec-ch-ua-platform", "\"Windows\"")
+	req.Header.Set("sec-fetch-dest", "empty")
+	req.Header.Set("sec-fetch-mode", "cors")
+	req.Header.Set("sec-fetch-site", "same-origin")
+	req.Header.Set("Referer", "https://open.spotify.com/")
+	req.Header.Set("Origin", "https://open.spotify.com")
 	if token != "" {
 		req.Header.Set("Authorization", "Bearer "+token)
 	}
@@ -863,13 +940,23 @@ func (c *SpotifyMetadataClient) randomUserAgent() string {
 	c.rngMu.Lock()
 	defer c.rngMu.Unlock()
 
-	chromeMajor := 80 + c.rng.Intn(25)
-	chromeBuild := 3000 + c.rng.Intn(1500)
-	chromePatch := 60 + c.rng.Intn(65)
+	// Use Mac User-Agent format (same as PC version)
+	macMajor := c.rng.Intn(4) + 11    // 11-14
+	macMinor := c.rng.Intn(5) + 4     // 4-8
+	webkitMajor := c.rng.Intn(7) + 530 // 530-536
+	webkitMinor := c.rng.Intn(7) + 30  // 30-36
+	chromeMajor := c.rng.Intn(25) + 80 // 80-104
+	chromeBuild := c.rng.Intn(1500) + 3000 // 3000-4499
+	chromePatch := c.rng.Intn(65) + 60 // 60-124
+	safariMajor := c.rng.Intn(7) + 530 // 530-536
+	safariMinor := c.rng.Intn(6) + 30  // 30-35
 
 	return fmt.Sprintf(
-		"Mozilla/5.0 (Linux; Android 12) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
+		macMajor, macMinor,
+		webkitMajor, webkitMinor,
 		chromeMajor, chromeBuild, chromePatch,
+		safariMajor, safariMinor,
 	)
 }
 

go_backend/tidal.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"bufio"
 	"encoding/base64"
 	"encoding/json"
 	"encoding/xml"
@@ -12,17 +13,27 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 )
 
 // TidalDownloader handles Tidal downloads
 type TidalDownloader struct {
-	client       *http.Client
-	clientID     string
-	clientSecret string
-	apiURL       string
+	client         *http.Client
+	clientID       string
+	clientSecret   string
+	apiURL         string
+	cachedToken    string
+	tokenExpiresAt time.Time
+	tokenMu        sync.Mutex
 }
 
+var (
+	// Global Tidal downloader instance for token reuse
+	globalTidalDownloader *TidalDownloader
+	tidalDownloaderOnce   sync.Once
+)
+
 // TidalTrack represents a Tidal track
 type TidalTrack struct {
 	ID           int64  `json:"id"`
@@ -93,37 +104,40 @@ type MPD struct {
 	} `xml:"Period"`
 }
 
-// NewTidalDownloader creates a new Tidal downloader
+// NewTidalDownloader creates a new Tidal downloader (returns singleton for token reuse)
 func NewTidalDownloader() *TidalDownloader {
-	clientID, _ := base64.StdEncoding.DecodeString("NkJEU1JkcEs5aHFFQlRnVQ==")
-	clientSecret, _ := base64.StdEncoding.DecodeString("eGV1UG1ZN25icFo5SUliTEFjUTkzc2hrYTFWTmhlVUFxTjZJY3N6alRHOD0=")
+	tidalDownloaderOnce.Do(func() {
+		clientID, _ := base64.StdEncoding.DecodeString("NkJEU1JkcEs5aHFFQlRnVQ==")
+		clientSecret, _ := base64.StdEncoding.DecodeString("eGV1UG1ZN25icFo5SUliTEFjUTkzc2hrYTFWTmhlVUFxTjZJY3N6alRHOD0=")
 
-	downloader := &TidalDownloader{
-		client:       NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
-		clientID:     string(clientID),
-		clientSecret: string(clientSecret),
-	}
+		globalTidalDownloader = &TidalDownloader{
+			client:       NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
+			clientID:     string(clientID),
+			clientSecret: string(clientSecret),
+		}
 
-	// Get first available API
-	apis := downloader.GetAvailableAPIs()
-	if len(apis) > 0 {
-		downloader.apiURL = apis[0]
-	}
-
-	return downloader
+		// Get first available API
+		apis := globalTidalDownloader.GetAvailableAPIs()
+		if len(apis) > 0 {
+			globalTidalDownloader.apiURL = apis[0]
+		}
+	})
+	return globalTidalDownloader
 }
 
 // GetAvailableAPIs returns list of available Tidal APIs
 func (t *TidalDownloader) GetAvailableAPIs() []string {
 	encodedAPIs := []string{
-		"dm9nZWwucXFkbC5zaXRl",         // API 1 - vogel.qqdl.site
-		"bWF1cy5xcWRsLnNpdGU=",         // API 2 - maus.qqdl.site
-		"aHVuZC5xcWRsLnNpdGU=",         // API 3 - hund.qqdl.site
-		"a2F0emUucXFkbC5zaXRl",         // API 4 - katze.qqdl.site
-		"d29sZi5xcWRsLnNpdGU=",         // API 5 - wolf.qqdl.site
-		"dGlkYWwua2lub3BsdXMub25saW5l", // API 6 - tidal.kinoplus.online
-		"dGlkYWwtYXBpLmJpbmltdW0ub3Jn", // API 7 - tidal-api.binimum.org
-		"dHJpdG9uLnNxdWlkLnd0Zg==",     // API 8 - triton.squid.wtf
+		// Priority 1: APIs that return FULL tracks (not PREVIEW)
+		"dGlkYWwua2lub3BsdXMub25saW5l", // tidal.kinoplus.online - returns FULL
+		"dGlkYWwtYXBpLmJpbmltdW0ub3Jn", // tidal-api.binimum.org
+		"dHJpdG9uLnNxdWlkLnd0Zg==",     // triton.squid.wtf
+		// Priority 2: qqdl.site APIs (often return PREVIEW only)
+		"dm9nZWwucXFkbC5zaXRl",         // vogel.qqdl.site
+		"bWF1cy5xcWRsLnNpdGU=",         // maus.qqdl.site
+		"aHVuZC5xcWRsLnNpdGU=",         // hund.qqdl.site
+		"a2F0emUucXFkbC5zaXRl",         // katze.qqdl.site
+		"d29sZi5xcWRsLnNpdGU=",         // wolf.qqdl.site
 	}
 
 	var apis []string
@@ -138,8 +152,16 @@ func (t *TidalDownloader) GetAvailableAPIs() []string {
 	return apis
 }
 
-// GetAccessToken gets Tidal access token
+// GetAccessToken gets Tidal access token (with caching)
 func (t *TidalDownloader) GetAccessToken() (string, error) {
+	t.tokenMu.Lock()
+	defer t.tokenMu.Unlock()
+
+	// Return cached token if still valid (with 60s buffer)
+	if t.cachedToken != "" && time.Now().Add(60*time.Second).Before(t.tokenExpiresAt) {
+		return t.cachedToken, nil
+	}
+
 	data := fmt.Sprintf("client_id=%s&grant_type=client_credentials", t.clientID)
 
 	authURL, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hdXRoLnRpZGFsLmNvbS92MS9vYXV0aDIvdG9rZW4=")
@@ -163,12 +185,21 @@ func (t *TidalDownloader) GetAccessToken() (string, error) {
 
 	var result struct {
 		AccessToken string `json:"access_token"`
+		ExpiresIn   int    `json:"expires_in"`
 	}
 
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
 		return "", err
 	}
 
+	// Cache the token
+	t.cachedToken = result.AccessToken
+	if result.ExpiresIn > 0 {
+		t.tokenExpiresAt = time.Now().Add(time.Duration(result.ExpiresIn) * time.Second)
+	} else {
+		t.tokenExpiresAt = time.Now().Add(55 * time.Minute) // Default 55 min
+	}
+
 	return result.AccessToken, nil
 }
 
@@ -338,13 +369,14 @@ func normalizeTitle(title string) string {
 }
 
 // SearchTrackByMetadataWithISRC searches for a track with ISRC matching priority
+// Now includes romaji conversion for Japanese text (4 search strategies like PC)
 func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, spotifyISRC string, expectedDuration int) (*TidalTrack, error) {
 	token, err := t.GetAccessToken()
 	if err != nil {
 		return nil, err
 	}
 
-	// Build search queries - multiple strategies
+	// Build search queries - multiple strategies (same as PC version)
 	queries := []string{}
 
 	// Strategy 1: Artist + Track name (original)
@@ -357,9 +389,47 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		queries = append(queries, trackName)
 	}
 
-	// Strategy 3: Artist only as last resort
+	// Strategy 3: Romaji versions if Japanese detected (NEW - from PC version)
+	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
+		// Convert to romaji (hiragana/katakana only, kanji stays)
+		romajiTrack := JapaneseToRomaji(trackName)
+		romajiArtist := JapaneseToRomaji(artistName)
+
+		// Clean and remove ALL non-ASCII characters (including kanji)
+		cleanRomajiTrack := CleanToASCII(romajiTrack)
+		cleanRomajiArtist := CleanToASCII(romajiArtist)
+
+		// Artist + Track romaji (cleaned to ASCII only)
+		if cleanRomajiArtist != "" && cleanRomajiTrack != "" {
+			romajiQuery := cleanRomajiArtist + " " + cleanRomajiTrack
+			if !containsQuery(queries, romajiQuery) {
+				queries = append(queries, romajiQuery)
+				fmt.Printf("[Tidal] Japanese detected, adding romaji query: %s\n", romajiQuery)
+			}
+		}
+
+		// Track romaji only (cleaned)
+		if cleanRomajiTrack != "" && cleanRomajiTrack != trackName {
+			if !containsQuery(queries, cleanRomajiTrack) {
+				queries = append(queries, cleanRomajiTrack)
+			}
+		}
+
+		// Also try with partial romaji (artist + cleaned track)
+		if artistName != "" && cleanRomajiTrack != "" {
+			partialQuery := artistName + " " + cleanRomajiTrack
+			if !containsQuery(queries, partialQuery) {
+				queries = append(queries, partialQuery)
+			}
+		}
+	}
+
+	// Strategy 4: Artist only as last resort
 	if artistName != "" {
-		queries = append(queries, artistName)
+		artistOnly := CleanToASCII(JapaneseToRomaji(artistName))
+		if artistOnly != "" && !containsQuery(queries, artistOnly) {
+			queries = append(queries, artistOnly)
+		}
 	}
 
 	searchBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkudGlkYWwuY29tL3YxL3NlYXJjaC90cmFja3M/cXVlcnk9")
@@ -375,6 +445,8 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		}
 		searchedQueries[cleanQuery] = true
 
+		fmt.Printf("[Tidal] Searching for: %s\n", cleanQuery)
+
 		searchURL := fmt.Sprintf("%s%s&limit=100&countryCode=US", string(searchBase), url.QueryEscape(cleanQuery))
 
 		req, err := http.NewRequest("GET", searchURL, nil)
@@ -386,6 +458,7 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 
 		resp, err := DoRequestWithUserAgent(t.client, req)
 		if err != nil {
+			fmt.Printf("[Tidal] Search error for '%s': %v\n", cleanQuery, err)
 			continue
 		}
 
@@ -404,6 +477,7 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		resp.Body.Close()
 
 		if len(result.Items) > 0 {
+			fmt.Printf("[Tidal] Found %d results for '%s'\n", len(result.Items), cleanQuery)
 			allTracks = append(allTracks, result.Items...)
 		}
 	}
@@ -414,6 +488,7 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 
 	// Priority 1: Match by ISRC (exact match) WITH title verification
 	if spotifyISRC != "" {
+		fmt.Printf("[Tidal] Looking for ISRC match: %s\n", spotifyISRC)
 		var isrcMatches []*TidalTrack
 		for i := range allTracks {
 			track := &allTracks[i]
@@ -431,15 +506,15 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 					if durationDiff < 0 {
 						durationDiff = -durationDiff
 					}
-					// Allow 30 seconds tolerance for duration
-					if durationDiff <= 30 {
+					// Allow 3 seconds tolerance for duration (same as PC version)
+					if durationDiff <= 3 {
 						durationVerifiedMatches = append(durationVerifiedMatches, track)
 					}
 				}
 				
 				if len(durationVerifiedMatches) > 0 {
 					// Return first duration-verified match
-					fmt.Printf("[Tidal] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n", 
+					fmt.Printf("[Tidal] ✓ ISRC match with duration verification: '%s' (expected %ds, found %ds)\n", 
 						durationVerifiedMatches[0].Title, expectedDuration, durationVerifiedMatches[0].Duration)
 					return durationVerifiedMatches[0], nil
 				}
@@ -452,11 +527,12 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 			}
 			
 			// No duration to verify, just return first ISRC match
-			fmt.Printf("[Tidal] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
+			fmt.Printf("[Tidal] ✓ ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
 			return isrcMatches[0], nil
 		}
 		
 		// If ISRC was provided but no match found, return error
+		fmt.Printf("[Tidal] ✗ No ISRC match found for: %s\n", spotifyISRC)
 		return nil, fmt.Errorf("ISRC mismatch: no track found with ISRC %s on Tidal", spotifyISRC)
 	}
 
@@ -487,6 +563,8 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 					}
 				}
 			}
+			fmt.Printf("[Tidal] Found via duration match: %s - %s (%s)\n",
+				bestMatch.Artist.Name, bestMatch.Title, bestMatch.AudioQuality)
 			return bestMatch, nil
 		}
 	}
@@ -506,9 +584,22 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		}
 	}
 
+	fmt.Printf("[Tidal] Found via search (no ISRC provided): %s - %s (ISRC: %s, Quality: %s)\n",
+		bestMatch.Artist.Name, bestMatch.Title, bestMatch.ISRC, bestMatch.AudioQuality)
+
 	return bestMatch, nil
 }
 
+// containsQuery checks if a query already exists in the list
+func containsQuery(queries []string, query string) bool {
+	for _, q := range queries {
+		if q == query {
+			return true
+		}
+	}
+	return false
+}
+
 // SearchTrackByMetadata searches for a track using artist name and track name
 func (t *TidalDownloader) SearchTrackByMetadata(trackName, artistName string) (*TidalTrack, error) {
 	return t.SearchTrackByMetadataWithISRC(trackName, artistName, "", 0)
@@ -535,6 +626,7 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 
 	for _, apiURL := range apis {
 		reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", apiURL, trackID, quality)
+		fmt.Printf("[Tidal] Trying API: %s\n", reqURL)
 
 		req, err := http.NewRequest("GET", reqURL, nil)
 		if err != nil {
@@ -544,6 +636,7 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 
 		resp, err := DoRequestWithRetry(client, req, retryConfig)
 		if err != nil {
+			fmt.Printf("[Tidal] API error: %v\n", err)
 			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
 			continue
 		}
@@ -551,13 +644,32 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 		body, err := ReadResponseBody(resp)
 		resp.Body.Close()
 		if err != nil {
+			fmt.Printf("[Tidal] Read body error: %v\n", err)
 			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, err.Error()))
 			continue
 		}
+		
+		// Log response preview
+		bodyPreview := string(body)
+		if len(bodyPreview) > 300 {
+			bodyPreview = bodyPreview[:300] + "..."
+		}
+		fmt.Printf("[Tidal] API response (HTTP %d): %s\n", resp.StatusCode, bodyPreview)
 
 		// Try v2 format first (object with manifest)
 		var v2Response TidalAPIResponseV2
 		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
+			fmt.Printf("[Tidal] Got v2 response from %s - Quality: %d-bit/%dHz, AssetPresentation: %s\n", 
+				apiURL, v2Response.Data.BitDepth, v2Response.Data.SampleRate, v2Response.Data.AssetPresentation)
+			
+			// IMPORTANT: Reject PREVIEW responses - we need FULL tracks
+			if v2Response.Data.AssetPresentation == "PREVIEW" {
+				fmt.Printf("[Tidal] ✗ Rejecting PREVIEW response from %s, trying next API...\n", apiURL)
+				errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "returned PREVIEW instead of FULL"))
+				continue
+			}
+			
+			fmt.Printf("[Tidal] ✓ Got FULL track from %s\n", apiURL)
 			info := TidalDownloadInfo{
 				URL:        "MANIFEST:" + v2Response.Data.Manifest,
 				BitDepth:   v2Response.Data.BitDepth,
@@ -613,6 +725,13 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	}
 
 	manifestStr := string(manifestBytes)
+	
+	// Debug: log first 500 chars of manifest for debugging
+	manifestPreview := manifestStr
+	if len(manifestPreview) > 500 {
+		manifestPreview = manifestPreview[:500] + "..."
+	}
+	fmt.Printf("[Tidal] Manifest content: %s\n", manifestPreview)
 
 	// Check if it's BTS format (JSON) or DASH format (XML)
 	if strings.HasPrefix(manifestStr, "{") {
@@ -662,21 +781,31 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 
 	// Calculate segment count from timeline
 	segmentCount := 0
-	for _, seg := range segTemplate.Timeline.Segments {
+	fmt.Printf("[Tidal] XML parsed segments: %d entries in timeline\n", len(segTemplate.Timeline.Segments))
+	for i, seg := range segTemplate.Timeline.Segments {
+		fmt.Printf("[Tidal] Segment[%d]: d=%d, r=%d\n", i, seg.Duration, seg.Repeat)
 		segmentCount += seg.Repeat + 1
 	}
+	fmt.Printf("[Tidal] Segment count from XML: %d\n", segmentCount)
 
 	// If no segments found via XML, try regex
 	if segmentCount == 0 {
-		segRe := regexp.MustCompile(`<S d="\d+"(?: r="(\d+)")?`)
+		fmt.Println("[Tidal] No segments from XML, trying regex...")
+		// Match <S d="..." /> or <S d="..." r="..." />
+		segRe := regexp.MustCompile(`<S\s+d="(\d+)"(?:\s+r="(\d+)")?`)
 		matches := segRe.FindAllStringSubmatch(manifestStr, -1)
-		for _, match := range matches {
+		fmt.Printf("[Tidal] Regex found %d segment entries\n", len(matches))
+		for i, match := range matches {
 			repeat := 0
-			if len(match) > 1 && match[1] != "" {
-				fmt.Sscanf(match[1], "%d", &repeat)
+			if len(match) > 2 && match[2] != "" {
+				fmt.Sscanf(match[2], "%d", &repeat)
+			}
+			if i < 5 || i == len(matches)-1 {
+				fmt.Printf("[Tidal] Regex segment[%d]: d=%s, r=%d\n", i, match[1], repeat)
 			}
 			segmentCount += repeat + 1
 		}
+		fmt.Printf("[Tidal] Total segments from regex: %d\n", segmentCount)
 	}
 
 	// Generate media URLs for each segment
@@ -691,12 +820,17 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 
 // DownloadFile downloads a file from URL with progress tracking
 func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
-	// Handle manifest-based download
+	// Handle manifest-based download (DASH/BTS)
 	if strings.HasPrefix(downloadURL, "MANIFEST:") {
+		// Initialize progress tracking for manifest downloads
+		if itemID != "" {
+			StartItemProgress(itemID)
+			defer CompleteItemProgress(itemID)
+		}
 		return t.downloadFromManifest(strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, itemID)
 	}
 
-	// Initialize item progress (required for all downloads)
+	// Initialize item progress for direct downloads
 	if itemID != "" {
 		StartItemProgress(itemID)
 		defer CompleteItemProgress(itemID)
@@ -717,33 +851,66 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}
 
+	expectedSize := resp.ContentLength
 	// Set total bytes if available
-	if resp.ContentLength > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
 	}
 
 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
-	defer out.Close()
 
-	// Use item progress writer
+	// Use buffered writer for better performance (256KB buffer)
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
+
+	// Use item progress writer with buffered output
+	var written int64
 	if itemID != "" {
-		progressWriter := NewItemProgressWriter(out, itemID)
-		_, err = io.Copy(progressWriter, resp.Body)
+		progressWriter := NewItemProgressWriter(bufWriter, itemID)
+		written, err = io.Copy(progressWriter, resp.Body)
 	} else {
 		// Fallback: direct copy without progress tracking
-		_, err = io.Copy(out, resp.Body)
+		written, err = io.Copy(bufWriter, resp.Body)
 	}
-	return err
+
+	// Flush buffer before checking for errors
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	// Check for any errors
+	if err != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	// Verify file size if Content-Length was provided
+	if expectedSize > 0 && written != expectedSize {
+		os.Remove(outputPath)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	return nil
 }
 
 func (t *TidalDownloader) downloadFromManifest(manifestB64, outputPath, itemID string) error {
+	fmt.Println("[Tidal] Parsing manifest...")
 	directURL, initURL, mediaURLs, err := parseManifest(manifestB64)
 	if err != nil {
+		fmt.Printf("[Tidal] Manifest parse error: %v\n", err)
 		return fmt.Errorf("failed to parse manifest: %w", err)
 	}
+	fmt.Printf("[Tidal] Manifest parsed - directURL: %v, initURL: %v, mediaURLs count: %d\n", 
+		directURL != "", initURL != "", len(mediaURLs))
 
 	client := &http.Client{
 		Timeout: 120 * time.Second,
@@ -751,122 +918,165 @@ func (t *TidalDownloader) downloadFromManifest(manifestB64, outputPath, itemID s
 
 	// If we have a direct URL (BTS format), download directly with progress tracking
 	if directURL != "" {
-		// Initialize item progress (required for all downloads)
-		if itemID != "" {
-			StartItemProgress(itemID)
-			defer CompleteItemProgress(itemID)
-		}
+		fmt.Printf("[Tidal] BTS format - downloading from direct URL: %s...\n", directURL[:min(80, len(directURL))])
+		// Note: Progress tracking is initialized by the caller (DownloadFile)
 
 		req, err := http.NewRequest("GET", directURL, nil)
 		if err != nil {
+			fmt.Printf("[Tidal] BTS request creation failed: %v\n", err)
 			return fmt.Errorf("failed to create request: %w", err)
 		}
 
 		resp, err := client.Do(req)
 		if err != nil {
+			fmt.Printf("[Tidal] BTS download failed: %v\n", err)
 			return fmt.Errorf("failed to download file: %w", err)
 		}
 		defer resp.Body.Close()
 
 		if resp.StatusCode != 200 {
+			fmt.Printf("[Tidal] BTS download HTTP error: %d\n", resp.StatusCode)
 			return fmt.Errorf("download failed with status %d", resp.StatusCode)
 		}
+		fmt.Printf("[Tidal] BTS response OK, Content-Length: %d\n", resp.ContentLength)
 
+		expectedSize := resp.ContentLength
 		// Set total bytes for progress tracking
-		if resp.ContentLength > 0 && itemID != "" {
-			SetItemBytesTotal(itemID, resp.ContentLength)
+		if expectedSize > 0 && itemID != "" {
+			SetItemBytesTotal(itemID, expectedSize)
 		}
 
 		out, err := os.Create(outputPath)
 		if err != nil {
 			return fmt.Errorf("failed to create file: %w", err)
 		}
-		defer out.Close()
 
 		// Use item progress writer
+		var written int64
 		if itemID != "" {
 			progressWriter := NewItemProgressWriter(out, itemID)
-			_, err = io.Copy(progressWriter, resp.Body)
+			written, err = io.Copy(progressWriter, resp.Body)
 		} else {
-			// Fallback: direct copy without progress tracking
-			_, err = io.Copy(out, resp.Body)
+			written, err = io.Copy(out, resp.Body)
 		}
-		return err
+
+		closeErr := out.Close()
+
+		if err != nil {
+			os.Remove(outputPath)
+			return fmt.Errorf("download interrupted: %w", err)
+		}
+		if closeErr != nil {
+			os.Remove(outputPath)
+			return fmt.Errorf("failed to close file: %w", closeErr)
+		}
+
+		// Verify file size if Content-Length was provided
+		if expectedSize > 0 && written != expectedSize {
+			os.Remove(outputPath)
+			return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+		}
+
+		return nil
 	}
 
-	// DASH format - download segments to temporary file
-	// Note: On Android, we can't use ffmpeg, so we'll try to download as M4A
-	// and hope the player can handle it, or we save as .m4a instead of .flac
-	tempPath := outputPath + ".m4a.tmp"
-	out, err := os.Create(tempPath)
+	// DASH format - download segments directly to M4A file (no temp file to avoid Android permission issues)
+	// On Android, we can't use ffmpeg, so we save as M4A directly
+	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	fmt.Printf("[Tidal] DASH format - downloading %d segments directly to: %s\n", len(mediaURLs), m4aPath)
+	
+	// Note: Progress tracking is initialized by the caller (DownloadFile or downloadFromTidal)
+	// We just update progress here based on segment count
+	
+	out, err := os.Create(m4aPath)
 	if err != nil {
-		return fmt.Errorf("failed to create temp file: %w", err)
+		fmt.Printf("[Tidal] Failed to create M4A file: %v\n", err)
+		return fmt.Errorf("failed to create M4A file: %w", err)
 	}
 
 	// Download initialization segment
+	fmt.Printf("[Tidal] Downloading init segment...\n")
 	resp, err := client.Get(initURL)
 	if err != nil {
 		out.Close()
-		os.Remove(tempPath)
+		os.Remove(m4aPath)
+		fmt.Printf("[Tidal] Init segment download failed: %v\n", err)
 		return fmt.Errorf("failed to download init segment: %w", err)
 	}
 	if resp.StatusCode != 200 {
 		resp.Body.Close()
 		out.Close()
-		os.Remove(tempPath)
+		os.Remove(m4aPath)
+		fmt.Printf("[Tidal] Init segment HTTP error: %d\n", resp.StatusCode)
 		return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
 	}
 	_, err = io.Copy(out, resp.Body)
 	resp.Body.Close()
 	if err != nil {
 		out.Close()
-		os.Remove(tempPath)
+		os.Remove(m4aPath)
+		fmt.Printf("[Tidal] Init segment write failed: %v\n", err)
 		return fmt.Errorf("failed to write init segment: %w", err)
 	}
 
-	// Download media segments
+	// Download media segments with progress
+	totalSegments := len(mediaURLs)
 	for i, mediaURL := range mediaURLs {
+		if i%10 == 0 || i == totalSegments-1 {
+			fmt.Printf("[Tidal] Downloading segment %d/%d...\n", i+1, totalSegments)
+		}
+		
+		// Update progress based on segment count
+		if itemID != "" {
+			progress := float64(i+1) / float64(totalSegments)
+			SetItemProgress(itemID, progress, 0, 0)
+		}
+		
 		resp, err := client.Get(mediaURL)
 		if err != nil {
 			out.Close()
-			os.Remove(tempPath)
+			os.Remove(m4aPath)
+			fmt.Printf("[Tidal] Segment %d download failed: %v\n", i+1, err)
 			return fmt.Errorf("failed to download segment %d: %w", i+1, err)
 		}
 		if resp.StatusCode != 200 {
 			resp.Body.Close()
 			out.Close()
-			os.Remove(tempPath)
+			os.Remove(m4aPath)
+			fmt.Printf("[Tidal] Segment %d HTTP error: %d\n", i+1, resp.StatusCode)
 			return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
 		}
 		_, err = io.Copy(out, resp.Body)
 		resp.Body.Close()
 		if err != nil {
 			out.Close()
-			os.Remove(tempPath)
+			os.Remove(m4aPath)
+			fmt.Printf("[Tidal] Segment %d write failed: %v\n", i+1, err)
 			return fmt.Errorf("failed to write segment %d: %w", i+1, err)
 		}
 	}
 
-	out.Close()
-
-	// For Android, we'll save as M4A since we can't use ffmpeg
-	// Rename temp file to final output (change extension to .m4a if needed)
-	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
-	if err := os.Rename(tempPath, m4aPath); err != nil {
-		os.Remove(tempPath)
-		return fmt.Errorf("failed to rename temp file: %w", err)
+	if err := out.Close(); err != nil {
+		os.Remove(m4aPath)
+		fmt.Printf("[Tidal] Failed to close M4A file: %v\n", err)
+		return fmt.Errorf("failed to close M4A file: %w", err)
 	}
 
-	// If the original output was .flac, we need to indicate this is actually m4a
-	// For now, we'll just keep it as m4a
+	fmt.Printf("[Tidal] DASH download completed: %s\n", m4aPath)
 	return nil
 }
 
 // TidalDownloadResult contains download result with quality info
 type TidalDownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
 }
 
 // artistsMatch checks if the artist names are similar enough
@@ -942,8 +1152,44 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	var track *TidalTrack
 	var err error
 
-	// Strategy 1: Try to get Tidal URL from SongLink (using Spotify ID)
-	if req.SpotifyID != "" {
+	// OPTIMIZATION: Check cache first for track ID
+	if req.ISRC != "" {
+		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.TidalTrackID > 0 {
+			fmt.Printf("[Tidal] Cache hit! Using cached track ID: %d\n", cached.TidalTrackID)
+			track, err = downloader.GetTrackInfoByID(cached.TidalTrackID)
+			if err != nil {
+				fmt.Printf("[Tidal] Cache hit but failed to get track info: %v\n", err)
+				track = nil // Fall through to normal search
+			}
+		}
+	}
+
+	// OPTIMIZED: Try ISRC search first (faster than SongLink API)
+	// Strategy 1: Search by ISRC with duration verification (FASTEST)
+	if track == nil && req.ISRC != "" {
+		fmt.Printf("[Tidal] Trying ISRC search first (faster): %s\n", req.ISRC)
+		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, expectedDurationSec)
+		// Verify artist for ISRC match
+		if track != nil {
+			tidalArtist := track.Artist.Name
+			if len(track.Artists) > 0 {
+				var artistNames []string
+				for _, a := range track.Artists {
+					artistNames = append(artistNames, a.Name)
+				}
+				tidalArtist = strings.Join(artistNames, ", ")
+			}
+			if !artistsMatch(req.ArtistName, tidalArtist) {
+				fmt.Printf("[Tidal] Artist mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n", 
+					req.ArtistName, tidalArtist)
+				track = nil
+			}
+		}
+	}
+
+	// Strategy 2: Try SongLink only if ISRC search failed (slower but more accurate)
+	if track == nil && req.SpotifyID != "" {
+		fmt.Printf("[Tidal] ISRC search failed, trying SongLink...\n")
 		tidalURL, slErr := downloader.GetTidalURLFromSpotify(req.SpotifyID)
 		if slErr == nil && tidalURL != "" {
 			// Extract track ID and get track info
@@ -974,8 +1220,8 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 						if durationDiff < 0 {
 							durationDiff = -durationDiff
 						}
-						// Allow 30 seconds tolerance
-						if durationDiff > 30 {
+						// Allow 3 seconds tolerance (same as PC version)
+						if durationDiff > 3 {
 							fmt.Printf("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n", 
 								expectedDurationSec, track.Duration)
 							track = nil // Reject this match
@@ -986,29 +1232,9 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	// Strategy 2: Search by ISRC with duration verification
-	if track == nil && req.ISRC != "" {
-		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, expectedDurationSec)
-		// Verify artist for ISRC match too
-		if track != nil {
-			tidalArtist := track.Artist.Name
-			if len(track.Artists) > 0 {
-				var artistNames []string
-				for _, a := range track.Artists {
-					artistNames = append(artistNames, a.Name)
-				}
-				tidalArtist = strings.Join(artistNames, ", ")
-			}
-			if !artistsMatch(req.ArtistName, tidalArtist) {
-				fmt.Printf("[Tidal] Artist mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n", 
-					req.ArtistName, tidalArtist)
-				track = nil
-			}
-		}
-	}
-
-	// Strategy 3: Search by metadata only (no ISRC requirement)
+	// Strategy 3: Search by metadata only (no ISRC requirement) - last resort
 	if track == nil {
+		fmt.Printf("[Tidal] Trying metadata search as last resort...\n")
 		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, "", expectedDurationSec)
 		// Verify artist for metadata search too
 		if track != nil {
@@ -1047,6 +1273,11 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	}
 	fmt.Printf("[Tidal] Match found: '%s' by '%s' (duration: %ds)\n", track.Title, tidalArtist, track.Duration)
 
+	// Cache the track ID for future use
+	if req.ISRC != "" {
+		GetTrackIDCache().SetTidal(req.ISRC, track.ID)
+	}
+
 	// Build filename
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
@@ -1059,10 +1290,21 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	filename = sanitizeFilename(filename) + ".flac"
 	outputPath := filepath.Join(req.OutputDir, filename)
 
-	// Check if file already exists
+	// Check if file already exists (both FLAC and M4A)
 	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
 		return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
+	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	if fileInfo, statErr := os.Stat(m4aPath); statErr == nil && fileInfo.Size() > 0 {
+		return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
+	}
+	
+	// Clean up any leftover .tmp files from previous failed downloads
+	tmpPath := outputPath + ".m4a.tmp"
+	if _, err := os.Stat(tmpPath); err == nil {
+		fmt.Printf("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
+		os.Remove(tmpPath)
+	}
 
 	// Determine quality to use (default to LOSSLESS if not specified)
 	quality := req.Quality
@@ -1080,10 +1322,38 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	// Log actual quality received
 	fmt.Printf("[Tidal] Actual quality: %d-bit/%dHz\n", downloadInfo.BitDepth, downloadInfo.SampleRate)
 
-	// Download file with item ID for progress tracking
+	// START PARALLEL: Fetch cover and lyrics while downloading audio
+	var parallelResult *ParallelDownloadResult
+	parallelDone := make(chan struct{})
+	go func() {
+		defer close(parallelDone)
+		parallelResult = FetchCoverAndLyricsParallel(
+			req.CoverURL,
+			req.EmbedMaxQualityCover,
+			req.SpotifyID,
+			req.TrackName,
+			req.ArtistName,
+			req.EmbedLyrics,
+		)
+	}()
+
+	// Download audio file with item ID for progress tracking
+	fmt.Printf("[Tidal] Starting download to: %s\n", outputPath)
+	fmt.Printf("[Tidal] Download URL type: %s\n", func() string {
+		if strings.HasPrefix(downloadInfo.URL, "MANIFEST:") {
+			return "MANIFEST (DASH/BTS)"
+		}
+		return "Direct URL"
+	}())
+	
 	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.ItemID); err != nil {
+		fmt.Printf("[Tidal] Download failed with error: %v\n", err)
 		return TidalDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
+	fmt.Println("[Tidal] Download completed successfully")
+
+	// Wait for parallel operations to complete
+	<-parallelDone
 
 	// Set progress to 100% and status to finalizing (before embedding)
 	// This makes the UI show "Finalizing..." while embedding happens
@@ -1093,9 +1363,8 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	}
 
 	// Check if file was saved as M4A (DASH stream) instead of FLAC
-	// downloadFromManifest saves DASH streams as .m4a
+	// downloadFromManifest saves DASH streams as .m4a (m4aPath already defined above)
 	actualOutputPath := outputPath
-	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
 	if _, err := os.Stat(m4aPath); err == nil {
 		// File was saved as M4A, use that path
 		actualOutputPath = m4aPath
@@ -1105,7 +1374,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
 	}
 
-	// Embed metadata
+	// Embed metadata using parallel-fetched cover data
 	metadata := Metadata{
 		Title:       req.TrackName,
 		Artist:      req.ArtistName,
@@ -1118,51 +1387,64 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		ISRC:        req.ISRC,
 	}
 
-	// Download cover to memory (avoids file permission issues on Android)
+	// Use cover data from parallel fetch
 	var coverData []byte
-	if req.CoverURL != "" {
-		fmt.Println("[Tidal] Downloading cover to memory...")
-		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
-		if err == nil {
-			coverData = data
-			fmt.Printf("[Tidal] Cover downloaded successfully (%d bytes)\n", len(coverData))
-		} else {
-			fmt.Printf("[Tidal] Warning: failed to download cover: %v\n", err)
-		}
+	if parallelResult != nil && parallelResult.CoverData != nil {
+		coverData = parallelResult.CoverData
+		fmt.Printf("[Tidal] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
-	// Only embed metadata to FLAC files (M4A will be converted by Flutter)
+	// Embed metadata based on file type
 	if strings.HasSuffix(actualOutputPath, ".flac") {
 		if err := EmbedMetadataWithCoverData(actualOutputPath, metadata, coverData); err != nil {
 			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 		}
 
-		// Embed lyrics if enabled
-		if req.EmbedLyrics {
-			fmt.Println("[Tidal] Fetching lyrics...")
-			lyricsClient := NewLyricsClient()
-			lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
-			if lyricsErr != nil {
-				fmt.Printf("[Tidal] Warning: lyrics fetch error: %v\n", lyricsErr)
-			} else if lyrics == nil || len(lyrics.Lines) == 0 {
-				fmt.Println("[Tidal] No lyrics found for this track")
+		// Embed lyrics from parallel fetch
+		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+			fmt.Printf("[Tidal] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+			if embedErr := EmbedLyrics(actualOutputPath, parallelResult.LyricsLRC); embedErr != nil {
+				fmt.Printf("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
 			} else {
-				fmt.Printf("[Tidal] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-				lrcContent := convertToLRC(lyrics)
-				if embedErr := EmbedLyrics(actualOutputPath, lrcContent); embedErr != nil {
-					fmt.Printf("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
-				} else {
-					fmt.Println("[Tidal] Lyrics embedded successfully")
-				}
+				fmt.Println("[Tidal] Lyrics embedded successfully")
 			}
+		} else if req.EmbedLyrics {
+			fmt.Println("[Tidal] No lyrics available from parallel fetch")
 		}
-	} else {
-		fmt.Printf("[Tidal] Skipping metadata embed for M4A file (will be handled after conversion): %s\n", actualOutputPath)
+	} else if strings.HasSuffix(actualOutputPath, ".m4a") {
+		// Embed metadata to M4A file
+		// fmt.Printf("[Tidal] Embedding metadata to M4A file...\n")
+		
+		// Add lyrics to metadata if available
+		// if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		// 	metadata.Lyrics = parallelResult.LyricsLRC
+		// }
+		
+		// SKIP metadata embedding for M4A to prevent issues with FFmpeg conversion
+		// M4A files from DASH are often fragmented and editing metadata might corrupt the container
+		// structure that FFmpeg expects. Metadata will be re-embedded after conversion to FLAC in Flutter.
+		
+		fmt.Println("[Tidal] Skipping metadata embedding for M4A file (will be handled after FFmpeg conversion)")
+		
+		// if err := EmbedM4AMetadata(actualOutputPath, metadata, coverData); err != nil {
+		// 	fmt.Printf("[Tidal] Warning: failed to embed M4A metadata: %v\n", err)
+		// } else {
+		// 	fmt.Println("[Tidal] M4A metadata embedded successfully")
+		// }
 	}
 
+	// Add to ISRC index for fast duplicate checking
+	AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
+
 	return TidalDownloadResult{
-		FilePath:   actualOutputPath,
-		BitDepth:   downloadInfo.BitDepth,
-		SampleRate: downloadInfo.SampleRate,
+		FilePath:    actualOutputPath,
+		BitDepth:    downloadInfo.BitDepth,
+		SampleRate:  downloadInfo.SampleRate,
+		Title:       track.Title,
+		Artist:      track.Artist.Name,
+		Album:       track.Album.Title,
+		ReleaseDate: track.Album.ReleaseDate,
+		TrackNumber: track.TrackNumber,
+		DiscNumber:  track.VolumeNumber,
 	}, nil
 }

lib/constants/app_info.dart

@@ -1,8 +1,8 @@
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '2.0.7-preview';
-  static const String buildNumber = '37';
+  static const String version = '2.1.6';
+  static const String buildNumber = '44';
   static const String fullVersion = '$version+$buildNumber';
   
   
@@ -15,4 +15,6 @@ class AppInfo {
   static const String githubRepo = 'zarzet/SpotiFLAC-Mobile';
   static const String githubUrl = 'https://github.com/$githubRepo';
   static const String originalGithubUrl = 'https://github.com/afkarxyz/SpotiFLAC';
+  
+  static const String kofiUrl = 'https://ko-fi.com/zarzet';
 }

lib/models/download_item.dart

@@ -13,6 +13,14 @@ enum DownloadStatus {
   skipped,
 }
 
+/// Error type enum for better error handling
+enum DownloadErrorType {
+  unknown,
+  notFound,    // Track not found on any service
+  rateLimit,   // Rate limited by service
+  network,     // Network/connection error
+}
+
 @JsonSerializable()
 class DownloadItem {
   final String id;
@@ -20,8 +28,10 @@ class DownloadItem {
   final String service;
   final DownloadStatus status;
   final double progress;
+  final double speedMBps; // Download speed in MB/s
   final String? filePath;
   final String? error;
+  final DownloadErrorType? errorType;
   final DateTime createdAt;
   final String? qualityOverride; // Override quality for this specific download
 
@@ -31,8 +41,10 @@ class DownloadItem {
     required this.service,
     this.status = DownloadStatus.queued,
     this.progress = 0.0,
+    this.speedMBps = 0.0,
     this.filePath,
     this.error,
+    this.errorType,
     required this.createdAt,
     this.qualityOverride,
   });
@@ -43,8 +55,10 @@ class DownloadItem {
     String? service,
     DownloadStatus? status,
     double? progress,
+    double? speedMBps,
     String? filePath,
     String? error,
+    DownloadErrorType? errorType,
     DateTime? createdAt,
     String? qualityOverride,
   }) {
@@ -54,13 +68,31 @@ class DownloadItem {
       service: service ?? this.service,
       status: status ?? this.status,
       progress: progress ?? this.progress,
+      speedMBps: speedMBps ?? this.speedMBps,
       filePath: filePath ?? this.filePath,
       error: error ?? this.error,
+      errorType: errorType ?? this.errorType,
       createdAt: createdAt ?? this.createdAt,
       qualityOverride: qualityOverride ?? this.qualityOverride,
     );
   }
 
+  /// Get user-friendly error message based on error type
+  String get errorMessage {
+    if (error == null) return '';
+    
+    switch (errorType) {
+      case DownloadErrorType.notFound:
+        return 'Song not found on any service';
+      case DownloadErrorType.rateLimit:
+        return 'Rate limit reached, try again later';
+      case DownloadErrorType.network:
+        return 'Connection failed, check your internet';
+      default:
+        return error ?? 'An error occurred';
+    }
+  }
+
   factory DownloadItem.fromJson(Map<String, dynamic> json) =>
       _$DownloadItemFromJson(json);
   Map<String, dynamic> toJson() => _$DownloadItemToJson(this);

lib/models/download_item.g.dart

@@ -14,8 +14,10 @@ DownloadItem _$DownloadItemFromJson(Map<String, dynamic> json) => DownloadItem(
       $enumDecodeNullable(_$DownloadStatusEnumMap, json['status']) ??
       DownloadStatus.queued,
   progress: (json['progress'] as num?)?.toDouble() ?? 0.0,
+  speedMBps: (json['speedMBps'] as num?)?.toDouble() ?? 0.0,
   filePath: json['filePath'] as String?,
   error: json['error'] as String?,
+  errorType: $enumDecodeNullable(_$DownloadErrorTypeEnumMap, json['errorType']),
   createdAt: DateTime.parse(json['createdAt'] as String),
   qualityOverride: json['qualityOverride'] as String?,
 );
@@ -27,8 +29,10 @@ Map<String, dynamic> _$DownloadItemToJson(DownloadItem instance) =>
       'service': instance.service,
       'status': _$DownloadStatusEnumMap[instance.status]!,
       'progress': instance.progress,
+      'speedMBps': instance.speedMBps,
       'filePath': instance.filePath,
       'error': instance.error,
+      'errorType': _$DownloadErrorTypeEnumMap[instance.errorType],
       'createdAt': instance.createdAt.toIso8601String(),
       'qualityOverride': instance.qualityOverride,
     };
@@ -41,3 +45,10 @@ const _$DownloadStatusEnumMap = {
   DownloadStatus.failed: 'failed',
   DownloadStatus.skipped: 'skipped',
 };
+
+const _$DownloadErrorTypeEnumMap = {
+  DownloadErrorType.unknown: 'unknown',
+  DownloadErrorType.notFound: 'notFound',
+  DownloadErrorType.rateLimit: 'rateLimit',
+  DownloadErrorType.network: 'network',
+};

lib/models/settings.dart

@@ -14,6 +14,7 @@ class AppSettings {
   final bool isFirstLaunch;
   final int concurrentDownloads; // 1 = sequential (default), max 3
   final bool checkForUpdates; // Check for updates on app start
+  final String updateChannel; // stable, preview
   final bool hasSearchedBefore; // Hide helper text after first search
   final String folderOrganization; // none, artist, album, artist_album
   final String historyViewMode; // list, grid
@@ -21,9 +22,10 @@ class AppSettings {
   final String spotifyClientId; // Custom Spotify client ID (empty = use default)
   final String spotifyClientSecret; // Custom Spotify client secret (empty = use default)
   final bool useCustomSpotifyCredentials; // Whether to use custom credentials (if set)
+  final String metadataSource; // spotify, deezer - source for search and metadata
 
   const AppSettings({
-    this.defaultService = 'tidal',
+    this.defaultService = 'qobuz',
     this.audioQuality = 'LOSSLESS',
     this.filenameFormat = '{title} - {artist}',
     this.downloadDirectory = '',
@@ -33,6 +35,7 @@ class AppSettings {
     this.isFirstLaunch = true,
     this.concurrentDownloads = 1, // Default: sequential (off)
     this.checkForUpdates = true, // Default: enabled
+    this.updateChannel = 'stable', // Default: stable releases only
     this.hasSearchedBefore = false, // Default: show helper text
     this.folderOrganization = 'none', // Default: no folder organization
     this.historyViewMode = 'grid', // Default: grid view
@@ -40,6 +43,7 @@ class AppSettings {
     this.spotifyClientId = '', // Default: use built-in credentials
     this.spotifyClientSecret = '', // Default: use built-in credentials
     this.useCustomSpotifyCredentials = true, // Default: use custom if set
+    this.metadataSource = 'deezer', // Default: Deezer (no rate limit)
   });
 
   AppSettings copyWith({
@@ -53,6 +57,7 @@ class AppSettings {
     bool? isFirstLaunch,
     int? concurrentDownloads,
     bool? checkForUpdates,
+    String? updateChannel,
     bool? hasSearchedBefore,
     String? folderOrganization,
     String? historyViewMode,
@@ -60,6 +65,7 @@ class AppSettings {
     String? spotifyClientId,
     String? spotifyClientSecret,
     bool? useCustomSpotifyCredentials,
+    String? metadataSource,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -72,6 +78,7 @@ class AppSettings {
       isFirstLaunch: isFirstLaunch ?? this.isFirstLaunch,
       concurrentDownloads: concurrentDownloads ?? this.concurrentDownloads,
       checkForUpdates: checkForUpdates ?? this.checkForUpdates,
+      updateChannel: updateChannel ?? this.updateChannel,
       hasSearchedBefore: hasSearchedBefore ?? this.hasSearchedBefore,
       folderOrganization: folderOrganization ?? this.folderOrganization,
       historyViewMode: historyViewMode ?? this.historyViewMode,
@@ -79,6 +86,7 @@ class AppSettings {
       spotifyClientId: spotifyClientId ?? this.spotifyClientId,
       spotifyClientSecret: spotifyClientSecret ?? this.spotifyClientSecret,
       useCustomSpotifyCredentials: useCustomSpotifyCredentials ?? this.useCustomSpotifyCredentials,
+      metadataSource: metadataSource ?? this.metadataSource,
     );
   }
 

lib/models/settings.g.dart

@@ -7,7 +7,7 @@ part of 'settings.dart';
 // **************************************************************************
 
 AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
-  defaultService: json['defaultService'] as String? ?? 'tidal',
+  defaultService: json['defaultService'] as String? ?? 'qobuz',
   audioQuality: json['audioQuality'] as String? ?? 'LOSSLESS',
   filenameFormat: json['filenameFormat'] as String? ?? '{title} - {artist}',
   downloadDirectory: json['downloadDirectory'] as String? ?? '',
@@ -17,6 +17,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   isFirstLaunch: json['isFirstLaunch'] as bool? ?? true,
   concurrentDownloads: (json['concurrentDownloads'] as num?)?.toInt() ?? 1,
   checkForUpdates: json['checkForUpdates'] as bool? ?? true,
+  updateChannel: json['updateChannel'] as String? ?? 'stable',
   hasSearchedBefore: json['hasSearchedBefore'] as bool? ?? false,
   folderOrganization: json['folderOrganization'] as String? ?? 'none',
   historyViewMode: json['historyViewMode'] as String? ?? 'grid',
@@ -25,6 +26,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   spotifyClientSecret: json['spotifyClientSecret'] as String? ?? '',
   useCustomSpotifyCredentials:
       json['useCustomSpotifyCredentials'] as bool? ?? true,
+  metadataSource: json['metadataSource'] as String? ?? 'deezer',
 );
 
 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -39,6 +41,7 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'isFirstLaunch': instance.isFirstLaunch,
       'concurrentDownloads': instance.concurrentDownloads,
       'checkForUpdates': instance.checkForUpdates,
+      'updateChannel': instance.updateChannel,
       'hasSearchedBefore': instance.hasSearchedBefore,
       'folderOrganization': instance.folderOrganization,
       'historyViewMode': instance.historyViewMode,
@@ -46,4 +49,5 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'spotifyClientId': instance.spotifyClientId,
       'spotifyClientSecret': instance.spotifyClientSecret,
       'useCustomSpotifyCredentials': instance.useCustomSpotifyCredentials,
+      'metadataSource': instance.metadataSource,
     };

lib/models/theme_settings.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 const String kThemeModeKey = 'theme_mode';
 const String kUseDynamicColorKey = 'use_dynamic_color';
 const String kSeedColorKey = 'seed_color';
+const String kUseAmoledKey = 'use_amoled';
 
 /// Default Spotify green color for fallback
 const int kDefaultSeedColor = 0xFF1DB954;
@@ -13,11 +14,13 @@ class ThemeSettings {
   final ThemeMode themeMode;
   final bool useDynamicColor;
   final int seedColorValue;
+  final bool useAmoled; // Pure black background for OLED screens
 
   const ThemeSettings({
     this.themeMode = ThemeMode.system,
     this.useDynamicColor = true,
     this.seedColorValue = kDefaultSeedColor,
+    this.useAmoled = false,
   });
 
   /// Get seed color as Color object
@@ -28,11 +31,13 @@ class ThemeSettings {
     ThemeMode? themeMode,
     bool? useDynamicColor,
     int? seedColorValue,
+    bool? useAmoled,
   }) {
     return ThemeSettings(
       themeMode: themeMode ?? this.themeMode,
       useDynamicColor: useDynamicColor ?? this.useDynamicColor,
       seedColorValue: seedColorValue ?? this.seedColorValue,
+      useAmoled: useAmoled ?? this.useAmoled,
     );
   }
 
@@ -41,6 +46,7 @@ class ThemeSettings {
         kThemeModeKey: themeMode.name,
         kUseDynamicColorKey: useDynamicColor,
         kSeedColorKey: seedColorValue,
+        kUseAmoledKey: useAmoled,
       };
 
   /// Create from JSON map
@@ -49,6 +55,7 @@ class ThemeSettings {
       themeMode: _themeModeFromString(json[kThemeModeKey] as String?),
       useDynamicColor: json[kUseDynamicColorKey] as bool? ?? true,
       seedColorValue: json[kSeedColorKey] as int? ?? kDefaultSeedColor,
+      useAmoled: json[kUseAmoledKey] as bool? ?? false,
     );
   }
 
@@ -58,12 +65,13 @@ class ThemeSettings {
     return other is ThemeSettings &&
         other.themeMode == themeMode &&
         other.useDynamicColor == useDynamicColor &&
-        other.seedColorValue == seedColorValue;
+        other.seedColorValue == seedColorValue &&
+        other.useAmoled == useAmoled;
   }
 
   @override
   int get hashCode =>
-      themeMode.hashCode ^ useDynamicColor.hashCode ^ seedColorValue.hashCode;
+      themeMode.hashCode ^ useDynamicColor.hashCode ^ seedColorValue.hashCode ^ useAmoled.hashCode;
 }
 
 /// Helper to convert string to ThemeMode

lib/models/track.dart

@@ -16,6 +16,7 @@ class Track {
   final int? trackNumber;
   final int? discNumber;
   final String? releaseDate;
+  final String? deezerId;
   final ServiceAvailability? availability;
 
   const Track({
@@ -30,6 +31,7 @@ class Track {
     this.trackNumber,
     this.discNumber,
     this.releaseDate,
+    this.deezerId,
     this.availability,
   });
 
@@ -42,17 +44,23 @@ class ServiceAvailability {
   final bool tidal;
   final bool qobuz;
   final bool amazon;
+  final bool deezer;
   final String? tidalUrl;
   final String? qobuzUrl;
   final String? amazonUrl;
+  final String? deezerUrl;
+  final String? deezerId;
 
   const ServiceAvailability({
     this.tidal = false,
     this.qobuz = false,
     this.amazon = false,
+    this.deezer = false,
     this.tidalUrl,
     this.qobuzUrl,
     this.amazonUrl,
+    this.deezerUrl,
+    this.deezerId,
   });
 
   factory ServiceAvailability.fromJson(Map<String, dynamic> json) =>

lib/models/track.g.dart

@@ -18,6 +18,7 @@ Track _$TrackFromJson(Map<String, dynamic> json) => Track(
   trackNumber: (json['trackNumber'] as num?)?.toInt(),
   discNumber: (json['discNumber'] as num?)?.toInt(),
   releaseDate: json['releaseDate'] as String?,
+  deezerId: json['deezerId'] as String?,
   availability: json['availability'] == null
       ? null
       : ServiceAvailability.fromJson(
@@ -37,6 +38,7 @@ Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
   'trackNumber': instance.trackNumber,
   'discNumber': instance.discNumber,
   'releaseDate': instance.releaseDate,
+  'deezerId': instance.deezerId,
   'availability': instance.availability,
 };
 
@@ -45,9 +47,12 @@ ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>
       tidal: json['tidal'] as bool? ?? false,
       qobuz: json['qobuz'] as bool? ?? false,
       amazon: json['amazon'] as bool? ?? false,
+      deezer: json['deezer'] as bool? ?? false,
       tidalUrl: json['tidalUrl'] as String?,
       qobuzUrl: json['qobuzUrl'] as String?,
       amazonUrl: json['amazonUrl'] as String?,
+      deezerUrl: json['deezerUrl'] as String?,
+      deezerId: json['deezerId'] as String?,
     );
 
 Map<String, dynamic> _$ServiceAvailabilityToJson(
@@ -56,7 +61,10 @@ Map<String, dynamic> _$ServiceAvailabilityToJson(
   'tidal': instance.tidal,
   'qobuz': instance.qobuz,
   'amazon': instance.amazon,
+  'deezer': instance.deezer,
   'tidalUrl': instance.tidalUrl,
   'qobuzUrl': instance.qobuzUrl,
   'amazonUrl': instance.amazonUrl,
+  'deezerUrl': instance.deezerUrl,
+  'deezerId': instance.deezerId,
 };

lib/providers/download_queue_provider.dart

@@ -371,6 +371,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           final itemProgress = entry.value as Map<String, dynamic>;
           final bytesReceived = itemProgress['bytes_received'] as int? ?? 0;
           final bytesTotal = itemProgress['bytes_total'] as int? ?? 0;
+          final speedMBps = (itemProgress['speed_mbps'] as num?)?.toDouble() ?? 0.0;
           final isDownloading = itemProgress['is_downloading'] as bool? ?? false;
           final status = itemProgress['status'] as String? ?? 'downloading';
           
@@ -389,14 +390,29 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
             continue;
           }
           
-          if (isDownloading && bytesTotal > 0) {
-            final percentage = bytesReceived / bytesTotal;
-            updateProgress(itemId, percentage);
+          // Use progress from backend if available (handles both explicit progress and byte-based)
+          final progressFromBackend = (itemProgress['progress'] as num?)?.toDouble() ?? 0.0;
+          
+          if (isDownloading) {
+            double percentage = 0.0;
+            if (bytesTotal > 0) {
+               // Calculate from bytes if available for precision
+               percentage = bytesReceived / bytesTotal;
+            } else {
+               // Fallback to backend-reported progress (e.g. for DASH segments)
+               percentage = progressFromBackend;
+            }
             
-            // Log progress for each item
+            updateProgress(itemId, percentage, speedMBps: speedMBps);
+            
+            // Log progress for each item with speed
             final mbReceived = bytesReceived / (1024 * 1024);
             final mbTotal = bytesTotal / (1024 * 1024);
-            _log.d('Progress [$itemId]: ${(percentage * 100).toStringAsFixed(1)}% (${mbReceived.toStringAsFixed(2)}/${mbTotal.toStringAsFixed(2)} MB)');
+            if (bytesTotal > 0) {
+              _log.d('Progress [$itemId]: ${(percentage * 100).toStringAsFixed(1)}% (${mbReceived.toStringAsFixed(2)}/${mbTotal.toStringAsFixed(2)} MB) @ ${speedMBps.toStringAsFixed(2)} MB/s');
+            } else {
+              _log.d('Progress [$itemId]: ${(percentage * 100).toStringAsFixed(1)}% (DASH segments/unknown size) @ ${speedMBps.toStringAsFixed(2)} MB/s');
+            }
           }
         }
         
@@ -427,11 +443,22 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                 ? downloadingItems.first.track.artistName 
                 : 'Downloading...';
             
+            // Calculate notification progress values
+            int notifProgress = bytesReceived;
+            int notifTotal = bytesTotal;
+            
+            if (bytesTotal <= 0) {
+              // Fallback to percentage for DASH/unknown size
+              final progressPercent = (firstProgress['progress'] as num?)?.toDouble() ?? 0.0;
+              notifProgress = (progressPercent * 100).toInt();
+              notifTotal = 100;
+            }
+            
             _notificationService.showDownloadProgress(
               trackName: trackName,
               artistName: artistName,
-              progress: bytesReceived,
-              total: bytesTotal > 0 ? bytesTotal : 1,
+              progress: notifProgress,
+              total: notifTotal > 0 ? notifTotal : 1,
             );
             
             // Update foreground service notification (Android)
@@ -439,8 +466,8 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
               PlatformBridge.updateDownloadServiceProgress(
                 trackName: downloadingItems.first.track.name,
                 artistName: downloadingItems.first.track.artistName,
-                progress: bytesReceived,
-                total: bytesTotal > 0 ? bytesTotal : 1,
+                progress: notifProgress,
+                total: notifTotal > 0 ? notifTotal : 1,
                 queueCount: state.queuedCount,
               ).catchError((_) {}); // Ignore errors
             }
@@ -609,14 +636,16 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  void updateItemStatus(String id, DownloadStatus status, {double? progress, String? filePath, String? error}) {
+  void updateItemStatus(String id, DownloadStatus status, {double? progress, double? speedMBps, String? filePath, String? error, DownloadErrorType? errorType}) {
     final items = state.items.map((item) {
       if (item.id == id) {
         return item.copyWith(
           status: status,
           progress: progress ?? item.progress,
+          speedMBps: speedMBps ?? item.speedMBps,
           filePath: filePath,
           error: error,
+          errorType: errorType,
         );
       }
       return item;
@@ -632,8 +661,8 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  void updateProgress(String id, double progress) {
-    updateItemStatus(id, DownloadStatus.downloading, progress: progress);
+  void updateProgress(String id, double progress, {double? speedMBps}) {
+    updateItemStatus(id, DownloadStatus.downloading, progress: progress, speedMBps: speedMBps);
   }
 
   void cancelItem(String id) {
@@ -686,20 +715,37 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Retry a failed download
+  /// Retry a failed or skipped download
   void retryItem(String id) {
-    final items = state.items.map((item) {
-      if (item.id == id && item.status == DownloadStatus.failed) {
-        return item.copyWith(status: DownloadStatus.queued, progress: 0, error: null);
+    final item = state.items.where((i) => i.id == id).firstOrNull;
+    if (item == null) {
+      _log.w('retryItem: Item not found: $id');
+      return;
+    }
+    
+    // Only retry if status is failed or skipped
+    if (item.status != DownloadStatus.failed && item.status != DownloadStatus.skipped) {
+      _log.w('retryItem: Item status is ${item.status}, not retrying');
+      return;
+    }
+    
+    _log.i('Retrying item: ${item.track.name} (id: $id)');
+    
+    final items = state.items.map((i) {
+      if (i.id == id) {
+        return i.copyWith(status: DownloadStatus.queued, progress: 0, error: null);
       }
-      return item;
+      return i;
     }).toList();
     state = state.copyWith(items: items);
     _saveQueueToStorage(); // Persist queue
     
-    // Start processing if not already
+    // Start processing if not already running
     if (!state.isProcessing) {
+      _log.d('Starting queue processing for retry');
       Future.microtask(() => _processQueue());
+    } else {
+      _log.d('Queue already processing, item will be picked up');
     }
   }
 
@@ -715,18 +761,21 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     // Download cover first
     String? coverPath;
     if (track.coverUrl != null && track.coverUrl!.isNotEmpty) {
-      coverPath = '$flacPath.cover.jpg';
       try {
+        final tempDir = await getTemporaryDirectory();
+        final uniqueId = DateTime.now().millisecondsSinceEpoch;
+        coverPath = '${tempDir.path}/cover_$uniqueId.jpg';
+        
         // Download cover using HTTP
         final httpClient = HttpClient();
         final request = await httpClient.getUrl(Uri.parse(track.coverUrl!));
         final response = await request.close();
         if (response.statusCode == 200) {
-          final file = File(coverPath);
+          final file = File(coverPath!);
           final sink = file.openWrite();
           await response.pipe(sink);
           await sink.close();
-          _log.d('Cover downloaded to: $coverPath');
+          _log.d('Cover downloaded to temp: $coverPath');
         } else {
           _log.w('Failed to download cover: HTTP ${response.statusCode}');
           coverPath = null;
@@ -740,20 +789,85 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
 
     // Use Go backend to embed metadata
     try {
-      // For now, we'll use FFmpeg to embed cover since Go backend expects to download the file
-      // FFmpeg can embed cover art to FLAC
-      if (coverPath != null && await File(coverPath).exists()) {
-        final result = await FFmpegService.embedCover(flacPath, coverPath);
+      // Use FFmpeg to embed cover art AND text metadata
+      // FFmpeg can embed cover art to FLAC and also set tags
+      
+      // Construct metadata map
+      final metadata = <String, String>{
+        'TITLE': track.name,
+        'ARTIST': track.artistName,
+        'ALBUM': track.albumName,
+      };
+      
+      if (track.albumArtist != null) {
+        metadata['ALBUMARTIST'] = track.albumArtist!;
+      }
+      
+      if (track.trackNumber != null) {
+        metadata['TRACKNUMBER'] = track.trackNumber.toString();
+        metadata['TRACK'] = track.trackNumber.toString(); // Compatibility
+      }
+      
+      if (track.discNumber != null) {
+        metadata['DISCNUMBER'] = track.discNumber.toString();
+        metadata['DISC'] = track.discNumber.toString(); // Compatibility
+      }
+      
+      if (track.releaseDate != null) {
+        metadata['DATE'] = track.releaseDate!;
+        metadata['YEAR'] = track.releaseDate!.split('-').first;
+      }
+      
+      if (track.isrc != null) {
+        metadata['ISRC'] = track.isrc!;
+      }
+
+      // Fetch Lyrics (Critical for M4A->FLAC conversion parity)
+      // Since we are in the Flutter context, we can call the bridge to get lyrics
+      // This ensures even converted files have lyrics embedded if available
+      try {
+        final lrcContent = await PlatformBridge.getLyricsLRC(
+          track.id, // spotifyID
+          track.name,
+          track.artistName,
+          filePath: '', // No local file path yet (processed in memory)
+        );
         
-        if (result != null) {
-          _log.d('Cover embedded via FFmpeg');
-        } else {
-          _log.w('FFmpeg cover embed failed');
+        if (lrcContent != null && lrcContent.isNotEmpty) {
+          metadata['LYRICS'] = lrcContent;
+          metadata['UNSYNCEDLYRICS'] = lrcContent; // Fallback for some players
+          _log.d('Lyrics fetched for embedding (${lrcContent.length} chars)');
         }
-        
-        // Clean up cover file
+      } catch (e) {
+         _log.w('Failed to fetch lyrics for embedding: $e');
+      }
+      
+      _log.d('Generating tags for FLAC: $metadata');
+      
+      // Perform embedding (cover + text metadata)
+      // Note: FFmpegService.embedMetadata handles safe temp file creation
+      final result = await FFmpegService.embedMetadata(
+        flacPath: flacPath,
+        coverPath: coverPath != null && await File(coverPath).exists() ? coverPath : null,
+        metadata: metadata,
+      );
+      
+      if (result != null) {
+        _log.d('Metadata and cover embedded via FFmpeg');
+      } else {
+        _log.w('FFmpeg metadata/cover embed failed');
+      }
+      
+      // Clean up cover file if it exists
+      if (coverPath != null) {
         try {
-          await File(coverPath).delete();
+          final coverFile = File(coverPath);
+          if (await coverFile.exists()) {
+             // In Android 10+ scoped storage, we can't easily delete if we didn't create it 
+             // in this session or if it's not in our app dir. 
+             // But coverPath is typically in temp dir now.
+            await coverFile.delete();
+          }
         } catch (_) {}
       }
     } catch (e) {
@@ -851,6 +965,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     
     _log.i('Queue processing finished');
     state = state.copyWith(isProcessing: false, currentDownload: null);
+    
+    // Check if there are new queued items (e.g., from retry) and restart if needed
+    final hasQueuedItems = state.items.any((item) => item.status == DownloadStatus.queued);
+    if (hasQueuedItems) {
+      _log.i('Found queued items after processing finished, restarting queue...');
+      Future.microtask(() => _processQueue());
+    }
   }
 
   /// Sequential download processing (uses multi-progress system with single item)
@@ -866,7 +987,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         continue;
       }
       
-      final nextItem = state.items.firstWhere(
+      // Re-read state to get latest items (important for retry)
+      final currentItems = state.items;
+      final nextItem = currentItems.firstWhere(
         (item) => item.status == DownloadStatus.queued,
         orElse: () => DownloadItem(
           id: '',
@@ -877,10 +1000,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       );
 
       if (nextItem.id.isEmpty) {
-        _log.d('No more items to process');
+        _log.d('No more items to process (checked ${currentItems.length} items)');
         break;
       }
 
+      _log.d('Processing next item: ${nextItem.track.name} (id: ${nextItem.id})');
       await _downloadSingleItem(nextItem);
       
       // Clear item progress after download completes
@@ -965,7 +1089,49 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     try {
       // Get folder organization setting and build output directory
       final settings = ref.read(settingsProvider);
-      final outputDir = await _buildOutputDir(item.track, settings.folderOrganization);
+      
+      // Metadata Enrichment:
+      // If track number is missing/0 (common from Search results), fetch full metadata
+      // This ensures the downloaded file has correct tags (Track, Disc, Year)
+      Track trackToDownload = item.track;
+      if (trackToDownload.trackNumber == null || trackToDownload.trackNumber == 0) {
+        try {
+          if (trackToDownload.id.startsWith('deezer:')) {
+            _log.d('Enriching incomplete metadata for Deezer track: ${trackToDownload.name}');
+            final rawId = trackToDownload.id.split(':')[1];
+            final fullData = await PlatformBridge.getDeezerMetadata('track', rawId);
+            
+            if (fullData.containsKey('track')) {
+               final fullTrack = Track.fromJson(fullData['track'] as Map<String, dynamic>);
+               // Merge with existing (keep override quality/service if any, but update metadata)
+               trackToDownload = Track(
+                 id: fullTrack.id.isNotEmpty ? fullTrack.id : trackToDownload.id,
+                 name: fullTrack.name,
+                 artistName: fullTrack.artistName,
+                 albumName: fullTrack.albumName,
+                 albumArtist: fullTrack.albumArtist,
+                 coverUrl: fullTrack.coverUrl,
+                 duration: fullTrack.duration,
+                 isrc: fullTrack.isrc ?? trackToDownload.isrc,
+                 trackNumber: fullTrack.trackNumber,
+                 discNumber: fullTrack.discNumber,
+                 releaseDate: fullTrack.releaseDate,
+                 deezerId: fullTrack.deezerId,
+                 availability: trackToDownload.availability,
+               );
+               _log.d('Metadata enriched: Track ${trackToDownload.trackNumber}, Disc ${trackToDownload.discNumber}, Year ${trackToDownload.releaseDate}');
+               
+               // Update item in state with enriched track
+               // This is important so the UI (and history) reflects the enriched data
+               // We don't perform a full `updateItemStatus` here to avoid UI flicker, just local var
+            }
+          }
+        } catch (e) {
+          _log.w('Failed to enrich metadata: $e');
+        }
+      }
+      
+      final outputDir = await _buildOutputDir(trackToDownload, settings.folderOrganization);
       
       // Use quality override if set, otherwise use default from settings
       final quality = item.qualityOverride ?? state.audioQuality;
@@ -977,41 +1143,41 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         _log.d('Quality: $quality${item.qualityOverride != null ? ' (override)' : ''}');
         _log.d('Output dir: $outputDir');
         result = await PlatformBridge.downloadWithFallback(
-          isrc: item.track.isrc ?? '',
-          spotifyId: item.track.id,
-          trackName: item.track.name,
-          artistName: item.track.artistName,
-          albumName: item.track.albumName,
-          albumArtist: item.track.albumArtist,
-          coverUrl: item.track.coverUrl,
+          isrc: trackToDownload.isrc ?? '',
+          spotifyId: trackToDownload.id,
+          trackName: trackToDownload.name,
+          artistName: trackToDownload.artistName,
+          albumName: trackToDownload.albumName,
+          albumArtist: trackToDownload.albumArtist,
+          coverUrl: trackToDownload.coverUrl,
           outputDir: outputDir,
           filenameFormat: state.filenameFormat,
           quality: quality,
-          trackNumber: item.track.trackNumber ?? 1,
-          discNumber: item.track.discNumber ?? 1,
-          releaseDate: item.track.releaseDate,
+          trackNumber: trackToDownload.trackNumber ?? 1,
+          discNumber: trackToDownload.discNumber ?? 1,
+          releaseDate: trackToDownload.releaseDate,
           preferredService: item.service,
           itemId: item.id, // Pass item ID for progress tracking
-          durationMs: item.track.duration, // Duration in ms for verification
+          durationMs: trackToDownload.duration, // Duration in ms for verification
         );
       } else {
         result = await PlatformBridge.downloadTrack(
-          isrc: item.track.isrc ?? '',
+          isrc: trackToDownload.isrc ?? '',
           service: item.service,
-          spotifyId: item.track.id,
-          trackName: item.track.name,
-          artistName: item.track.artistName,
-          albumName: item.track.albumName,
-          albumArtist: item.track.albumArtist,
-          coverUrl: item.track.coverUrl,
+          spotifyId: trackToDownload.id,
+          trackName: trackToDownload.name,
+          artistName: trackToDownload.artistName,
+          albumName: trackToDownload.albumName,
+          albumArtist: trackToDownload.albumArtist,
+          coverUrl: trackToDownload.coverUrl,
           outputDir: outputDir,
           filenameFormat: state.filenameFormat,
           quality: quality,
-          trackNumber: item.track.trackNumber ?? 1,
-          discNumber: item.track.discNumber ?? 1,
-          releaseDate: item.track.releaseDate,
+          trackNumber: trackToDownload.trackNumber ?? 1,
+          discNumber: trackToDownload.discNumber ?? 1,
+          releaseDate: trackToDownload.releaseDate,
           itemId: item.id, // Pass item ID for progress tracking
-          durationMs: item.track.duration, // Duration in ms for verification
+          durationMs: trackToDownload.duration, // Duration in ms for verification
         );
       }
       
@@ -1055,26 +1221,74 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           _log.i('Actual quality: $actualQuality');
         }
         
-        // Check if file is M4A (DASH stream from Tidal) and needs remuxing to FLAC
-        if (filePath != null && filePath.endsWith('.m4a')) {
-          _log.d('Converting M4A to FLAC...');
-          updateItemStatus(item.id, DownloadStatus.downloading, progress: 0.9);
-          final flacPath = await FFmpegService.convertM4aToFlac(filePath);
-          if (flacPath != null) {
-            filePath = flacPath;
-            _log.d('Converted to: $flacPath');
-            
-            // After conversion, embed metadata and cover to the new FLAC file
-            _log.d('Embedding metadata and cover to converted FLAC...');
-            try {
-              await _embedMetadataAndCover(
-                flacPath,
-                item.track,
-              );
-              _log.d('Metadata and cover embedded successfully');
-            } catch (e) {
-              _log.w('Warning: Failed to embed metadata/cover: $e');
+        // M4A files from Tidal DASH streams - try to convert to FLAC
+        // M4A files from Tidal DASH streams - try to convert to FLAC
+        if (filePath != null && filePath!.endsWith('.m4a')) {
+          _log.d('M4A file detected (Hi-Res DASH stream), attempting conversion to FLAC...');
+          
+          try {
+            final file = File(filePath!);
+            if (!await file.exists()) {
+               _log.e('File does not exist at path: $filePath');
+            } else {
+              final length = await file.length();
+              _log.i('File size before conversion: ${length / 1024} KB');
+              
+              if (length < 1024) {
+                 _log.w('File is too small (<1KB), skipping conversion. Download might be corrupt.');
+              } else {
+                updateItemStatus(item.id, DownloadStatus.downloading, progress: 0.95);
+                final flacPath = await FFmpegService.convertM4aToFlac(filePath!);
+                
+                if (flacPath != null) {
+                  filePath = flacPath;
+                  _log.d('Converted to FLAC: $flacPath');
+                  
+                  // After conversion, embed metadata and cover to the new FLAC file
+                  _log.d('Embedding metadata and cover to converted FLAC...');
+                  try {
+                    // Update track with actual metadata from backend result (if available)
+                    // This creates the most accurate metadata possible (from the service itself)
+                    Track finalTrack = trackToDownload;
+                    if (result.containsKey('track_number') || result.containsKey('release_date')) {
+                       _log.d('Using metadata from backend response for embedding');
+                       final backendTrackNum = result['track_number'] as int?;
+                       final backendDiscNum = result['disc_number'] as int?;
+                       final backendYear = result['release_date'] as String?;
+                       final backendAlbum = result['album'] as String?;
+                       
+                       // Create updated track object
+                       finalTrack = Track(
+                         id: trackToDownload.id,
+                         name: trackToDownload.name,
+                         artistName: trackToDownload.artistName,
+                         albumName: backendAlbum ?? trackToDownload.albumName,
+                         albumArtist: trackToDownload.albumArtist,
+                         coverUrl: trackToDownload.coverUrl,
+                         duration: trackToDownload.duration,
+                         isrc: trackToDownload.isrc,
+                         trackNumber: (backendTrackNum != null && backendTrackNum > 0) ? backendTrackNum : trackToDownload.trackNumber,
+                         discNumber: (backendDiscNum != null && backendDiscNum > 0) ? backendDiscNum : trackToDownload.discNumber,
+                         releaseDate: backendYear ?? trackToDownload.releaseDate,
+                         deezerId: trackToDownload.deezerId,
+                         availability: trackToDownload.availability,
+                       );
+                    }
+
+                    // Use enriched/updated track for metadata embedding
+                    await _embedMetadataAndCover(flacPath, finalTrack);
+                    _log.d('Metadata and cover embedded successfully');
+                  } catch (e) {
+                    _log.w('Warning: Failed to embed metadata/cover: $e');
+                  }
+                } else {
+                  _log.w('FFmpeg conversion returned null, keeping M4A file');
+                }
+              }
             }
+          } catch (e) {
+            _log.w('FFmpeg conversion process failed: $e, keeping M4A file');
+            // Keep the M4A file if conversion fails
           }
         }
         
@@ -1116,12 +1330,20 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         );
 
         if (filePath != null) {
+          // Extract updated metadata from backend result if available
+          final backendTitle = result['title'] as String?;
+          final backendArtist = result['artist'] as String?;
+          final backendAlbum = result['album'] as String?;
+          final backendYear = result['release_date'] as String?;
+          final backendTrackNum = result['track_number'] as int?;
+          final backendDiscNum = result['disc_number'] as int?;
+
           ref.read(downloadHistoryProvider.notifier).addToHistory(
             DownloadHistoryItem(
               id: item.id,
-              trackName: item.track.name,
-              artistName: item.track.artistName,
-              albumName: item.track.albumName,
+              trackName: (backendTitle != null && backendTitle.isNotEmpty) ? backendTitle : item.track.name,
+              artistName: (backendArtist != null && backendArtist.isNotEmpty) ? backendArtist : item.track.artistName,
+              albumName: (backendAlbum != null && backendAlbum.isNotEmpty) ? backendAlbum : item.track.albumName,
               albumArtist: item.track.albumArtist,
               coverUrl: item.track.coverUrl,
               filePath: filePath,
@@ -1130,10 +1352,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
               // Additional metadata
               isrc: item.track.isrc,
               spotifyId: item.track.id,
-              trackNumber: item.track.trackNumber,
-              discNumber: item.track.discNumber,
+              trackNumber: (backendTrackNum != null && backendTrackNum > 0) ? backendTrackNum : item.track.trackNumber,
+              discNumber: (backendDiscNum != null && backendDiscNum > 0) ? backendDiscNum : item.track.discNumber,
               duration: item.track.duration,
-              releaseDate: item.track.releaseDate,
+              releaseDate: (backendYear != null && backendYear.isNotEmpty) ? backendYear : item.track.releaseDate,
               quality: actualQuality,
             ),
           );
@@ -1143,11 +1365,30 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         }
       } else {
         final errorMsg = result['error'] as String? ?? 'Download failed';
-        _log.e('Download failed: $errorMsg');
+        final errorTypeStr = result['error_type'] as String? ?? 'unknown';
+        
+        // Convert error type string to enum
+        DownloadErrorType errorType;
+        switch (errorTypeStr) {
+          case 'not_found':
+            errorType = DownloadErrorType.notFound;
+            break;
+          case 'rate_limit':
+            errorType = DownloadErrorType.rateLimit;
+            break;
+          case 'network':
+            errorType = DownloadErrorType.network;
+            break;
+          default:
+            errorType = DownloadErrorType.unknown;
+        }
+        
+        _log.e('Download failed: $errorMsg (type: $errorTypeStr)');
         updateItemStatus(
           item.id,
           DownloadStatus.failed,
           error: errorMsg,
+          errorType: errorType,
         );
         _failedInSession++;
       }
@@ -1164,10 +1405,22 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       }
     } catch (e, stackTrace) {
       _log.e('Exception: $e', e, stackTrace);
+      
+      String errorMsg = e.toString();
+      DownloadErrorType errorType = DownloadErrorType.unknown;
+
+      // Check for specific Deezer fallback error
+      if (errorMsg.contains('could not find Deezer equivalent') || 
+          errorMsg.contains('track not found on Deezer')) {
+         errorMsg = 'Track not found on Deezer (Metadata Unavailable)';
+         errorType = DownloadErrorType.notFound;
+      }
+
       updateItemStatus(
         item.id,
         DownloadStatus.failed,
-        error: e.toString(),
+        error: errorMsg,
+        errorType: errorType,
       );
       _failedInSession++;
     }

lib/providers/settings_provider.dart

@@ -5,6 +5,8 @@ import 'package:spotiflac_android/models/settings.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 
 const _settingsKey = 'app_settings';
+const _migrationVersionKey = 'settings_migration_version';
+const _currentMigrationVersion = 1;
 
 class SettingsNotifier extends Notifier<AppSettings> {
   @override
@@ -18,11 +20,35 @@ class SettingsNotifier extends Notifier<AppSettings> {
     final json = prefs.getString(_settingsKey);
     if (json != null) {
       state = AppSettings.fromJson(jsonDecode(json));
+      
+      // Run migrations if needed
+      await _runMigrations(prefs);
+      
       // Apply Spotify credentials to Go backend on load
       _applySpotifyCredentials();
     }
   }
 
+  /// Run one-time migrations for settings
+  Future<void> _runMigrations(SharedPreferences prefs) async {
+    final lastMigration = prefs.getInt(_migrationVersionKey) ?? 0;
+    
+    if (lastMigration < 1) {
+      // Migration 1: Set metadataSource to 'deezer' for existing users
+      // Only apply if user hasn't enabled custom Spotify credentials
+      // (users with custom credentials likely prefer Spotify)
+      if (!state.useCustomSpotifyCredentials) {
+        state = state.copyWith(metadataSource: 'deezer');
+        await _saveSettings();
+      }
+    }
+    
+    // Save current migration version
+    if (lastMigration < _currentMigrationVersion) {
+      await prefs.setInt(_migrationVersionKey, _currentMigrationVersion);
+    }
+  }
+
   Future<void> _saveSettings() async {
     final prefs = await SharedPreferences.getInstance();
     await prefs.setString(_settingsKey, jsonEncode(state.toJson()));
@@ -96,6 +122,11 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
+  void setUpdateChannel(String channel) {
+    state = state.copyWith(updateChannel: channel);
+    _saveSettings();
+  }
+
   void setHasSearchedBefore() {
     if (!state.hasSearchedBefore) {
       state = state.copyWith(hasSearchedBefore: true);
@@ -151,6 +182,11 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
     _applySpotifyCredentials();
   }
+
+  void setMetadataSource(String source) {
+    state = state.copyWith(metadataSource: source);
+    _saveSettings();
+  }
 }
 
 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(

lib/providers/theme_provider.dart

@@ -24,11 +24,13 @@ class ThemeNotifier extends Notifier<ThemeSettings> {
       final modeString = prefs.getString(kThemeModeKey);
       final useDynamic = prefs.getBool(kUseDynamicColorKey);
       final seedColor = prefs.getInt(kSeedColorKey);
+      final useAmoled = prefs.getBool(kUseAmoledKey);
 
       state = ThemeSettings(
         themeMode: _themeModeFromString(modeString),
         useDynamicColor: useDynamic ?? true,
         seedColorValue: seedColor ?? kDefaultSeedColor,
+        useAmoled: useAmoled ?? false,
       );
     } catch (e) {
       debugPrint('Error loading theme settings: $e');
@@ -43,6 +45,7 @@ class ThemeNotifier extends Notifier<ThemeSettings> {
       await prefs.setString(kThemeModeKey, state.themeMode.name);
       await prefs.setBool(kUseDynamicColorKey, state.useDynamicColor);
       await prefs.setInt(kSeedColorKey, state.seedColorValue);
+      await prefs.setBool(kUseAmoledKey, state.useAmoled);
     } catch (e) {
       debugPrint('Error saving theme settings: $e');
     }
@@ -72,6 +75,12 @@ class ThemeNotifier extends Notifier<ThemeSettings> {
     await _saveToStorage();
   }
 
+  /// Enable or disable AMOLED mode (pure black background)
+  Future<void> setUseAmoled(bool value) async {
+    state = state.copyWith(useAmoled: value);
+    await _saveToStorage();
+  }
+
   /// Helper to convert string to ThemeMode
   ThemeMode _themeModeFromString(String? value) {
     if (value == null) return ThemeMode.system;

lib/providers/track_provider.dart

@@ -114,7 +114,7 @@ class TrackNotifier extends Notifier<TrackState> {
   /// Check if request is still valid (not cancelled by newer request)
   bool _isRequestValid(int requestId) => requestId == _currentRequestId;
 
-  Future<void> fetchFromUrl(String url) async {
+  Future<void> fetchFromUrl(String url, {bool useDeezerFallback = true}) async {
     // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
@@ -127,7 +127,22 @@ class TrackNotifier extends Notifier<TrackState> {
       
       final type = parsed['type'] as String;
 
-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
+      // Use the new fallback-enabled method
+      Map<String, dynamic> metadata;
+      
+      try {
+        // ignore: avoid_print
+        print('[FetchURL] Fetching $type with Deezer fallback enabled...');
+        metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+        // ignore: avoid_print
+        print('[FetchURL] Metadata fetch success');
+      } catch (e) {
+        // If fallback also fails, show error
+        // ignore: avoid_print
+        print('[FetchURL] Metadata fetch failed: $e');
+        rethrow;
+      }
+      
       if (!_isRequestValid(requestId)) return; // Request cancelled
 
       if (type == 'track') {
@@ -149,6 +164,8 @@ class TrackNotifier extends Notifier<TrackState> {
           albumName: albumInfo['name'] as String?,
           coverUrl: albumInfo['images'] as String?,
         );
+        // Pre-warm cache for album tracks in background
+        _preWarmCacheForTracks(tracks);
       } else if (type == 'playlist') {
         final playlistInfo = metadata['playlist_info'] as Map<String, dynamic>;
         final trackList = metadata['track_list'] as List<dynamic>;
@@ -160,6 +177,8 @@ class TrackNotifier extends Notifier<TrackState> {
           playlistName: owner?['name'] as String?,
           coverUrl: owner?['images'] as String?,
         );
+        // Pre-warm cache for playlist tracks in background
+        _preWarmCacheForTracks(tracks);
       } else if (type == 'artist') {
         final artistInfo = metadata['artist_info'] as Map<String, dynamic>;
         final albumsList = metadata['albums'] as List<dynamic>;
@@ -180,7 +199,7 @@ class TrackNotifier extends Notifier<TrackState> {
     }
   }
 
-  Future<void> search(String query) async {
+  Future<void> search(String query, {String? metadataSource}) async {
     // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
@@ -188,7 +207,24 @@ class TrackNotifier extends Notifier<TrackState> {
     state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
-      final results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
+      // Use Deezer or Spotify based on settings
+      final source = metadataSource ?? 'deezer';
+      
+      // Debug log to show which source is being used
+      // ignore: avoid_print
+      print('[Search] Using metadata source: $source for query: "$query"');
+      
+      Map<String, dynamic> results;
+      if (source == 'deezer') {
+        results = await PlatformBridge.searchDeezerAll(query, trackLimit: 20, artistLimit: 5);
+        // ignore: avoid_print
+        print('[Search] Deezer returned ${(results['tracks'] as List?)?.length ?? 0} tracks');
+      } else {
+        results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
+        // ignore: avoid_print
+        print('[Search] Spotify returned ${(results['tracks'] as List?)?.length ?? 0} tracks');
+      }
+      
       if (!_isRequestValid(requestId)) return; // Request cancelled
       
       final trackList = results['tracks'] as List<dynamic>? ?? [];
@@ -310,6 +346,28 @@ class TrackNotifier extends Notifier<TrackState> {
       popularity: data['popularity'] as int? ?? 0,
     );
   }
+
+  /// Pre-warm track ID cache for faster downloads
+  /// Runs in background, doesn't block UI
+  void _preWarmCacheForTracks(List<Track> tracks) {
+    // Only pre-warm if we have tracks with ISRC
+    final tracksWithIsrc = tracks.where((t) => t.isrc != null && t.isrc!.isNotEmpty).toList();
+    if (tracksWithIsrc.isEmpty) return;
+
+    // Build request list for Go backend
+    final cacheRequests = tracksWithIsrc.map((t) => {
+      'isrc': t.isrc!,
+      'track_name': t.name,
+      'artist_name': t.artistName,
+      'spotify_id': t.id, // Include Spotify ID for Amazon lookup
+      'service': 'tidal', // Default to tidal for pre-warming
+    }).toList();
+
+    // Fire and forget - runs in background
+    PlatformBridge.preWarmTrackCache(cacheRequests).catchError((_) {
+      // Silently ignore errors - this is just an optimization
+    });
+  }
 }
 
 final trackProvider = NotifierProvider<TrackNotifier, TrackState>(

lib/screens/album_screen.dart

@@ -71,8 +71,22 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   Future<void> _fetchTracks() async {
     setState(() => _isLoading = true);
     try {
-      final url = 'https://open.spotify.com/album/${widget.albumId}';
-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
+      Map<String, dynamic> metadata;
+      
+      // Check if this is a Deezer album ID (format: "deezer:123456")
+      if (widget.albumId.startsWith('deezer:')) {
+        final deezerAlbumId = widget.albumId.replaceFirst('deezer:', '');
+        // ignore: avoid_print
+        print('[AlbumScreen] Fetching from Deezer: $deezerAlbumId');
+        metadata = await PlatformBridge.getDeezerMetadata('album', deezerAlbumId);
+      } else {
+        // Spotify album - use fallback method
+        // ignore: avoid_print
+        print('[AlbumScreen] Fetching from Spotify with fallback: ${widget.albumId}');
+        final url = 'https://open.spotify.com/album/${widget.albumId}';
+        metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+      }
+      
       final trackList = metadata['track_list'] as List<dynamic>;
       final tracks = trackList.map((t) => _parseTrack(t as Map<String, dynamic>)).toList();
       
@@ -302,8 +316,8 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   void _downloadTrack(BuildContext context, Track track) {
     final settings = ref.read(settingsProvider);
     if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality) {
-        ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService, qualityOverride: quality);
+      _showQualityPicker(context, (quality, service) {
+        ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
         ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
       }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
     } else {
@@ -317,8 +331,8 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     if (tracks == null || tracks.isEmpty) return;
     final settings = ref.read(settingsProvider);
     if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality) {
-        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService, qualityOverride: quality);
+      _showQualityPicker(context, (quality, service) {
+        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
         ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
       }, trackName: '${tracks.length} tracks', artistName: widget.albumName);
     } else {
@@ -327,44 +341,69 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     }
   }
 
-  void _showQualityPicker(BuildContext context, void Function(String quality) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
+  void _showQualityPicker(BuildContext context, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
     final colorScheme = Theme.of(context).colorScheme;
+    final settings = ref.read(settingsProvider);
+    String selectedService = settings.defaultService;
+    
     showModalBottomSheet(
       context: context,
       backgroundColor: colorScheme.surfaceContainerHigh,
       shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      builder: (context) => SafeArea(
-        child: Column(
-          mainAxisSize: MainAxisSize.min,
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (trackName != null) ...[
-              _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-              Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-            ] else ...[
-              const SizedBox(height: 8),
-              Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
-            ],
-            Padding(
-              padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-              child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
-            ),
-            // Disclaimer
-            Padding(
-              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-              child: Text(
-                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                  color: colorScheme.onSurfaceVariant,
-                  fontStyle: FontStyle.italic,
+      isScrollControlled: true,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setModalState) => SafeArea(
+          child: SingleChildScrollView(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                if (trackName != null) ...[
+                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
+                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+                ] else ...[
+                  const SizedBox(height: 8),
+                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
+                ],
+                // Service selector
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
+                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
                 ),
-              ),
+                Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 20),
+                  child: Row(
+                    children: [
+                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
+                    ],
+                  ),
+                ),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
+                  child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
+                ),
+                // Disclaimer
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+                  child: Text(
+                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                      fontStyle: FontStyle.italic,
+                    ),
+                  ),
+                ),
+                _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); }),
+                _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); }),
+                _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); }),
+                const SizedBox(height: 16),
+              ],
             ),
-            _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS'); }),
-            _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES'); }),
-            _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS'); }),
-            const SizedBox(height: 16),
-          ],
+          ),
         ),
       ),
     );
@@ -455,6 +494,40 @@ class _QualityOption extends StatelessWidget {
   }
 }
 
+class _ServiceChip extends StatelessWidget {
+  final String label;
+  final bool isSelected;
+  final VoidCallback onTap;
+  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Expanded(
+      child: GestureDetector(
+        onTap: onTap,
+        child: AnimatedContainer(
+          duration: const Duration(milliseconds: 200),
+          padding: const EdgeInsets.symmetric(vertical: 10),
+          decoration: BoxDecoration(
+            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(12),
+            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+          ),
+          child: Text(
+            label,
+            textAlign: TextAlign.center,
+            style: TextStyle(
+              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
 class _TrackInfoHeader extends StatefulWidget {
   final String trackName;
   final String? artistName;

lib/screens/artist_screen.dart

@@ -69,10 +69,25 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
   Future<void> _fetchDiscography() async {
     setState(() => _isLoadingDiscography = true);
     try {
-      final url = 'https://open.spotify.com/artist/${widget.artistId}';
-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
-      final albumsList = metadata['albums'] as List<dynamic>;
-      final albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      List<ArtistAlbum> albums;
+      
+      // Check if this is a Deezer artist ID (format: "deezer:123456")
+      if (widget.artistId.startsWith('deezer:')) {
+        final deezerArtistId = widget.artistId.replaceFirst('deezer:', '');
+        // ignore: avoid_print
+        print('[ArtistScreen] Fetching from Deezer: $deezerArtistId');
+        final metadata = await PlatformBridge.getDeezerMetadata('artist', deezerArtistId);
+        final albumsList = metadata['albums'] as List<dynamic>;
+        albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      } else {
+        // Spotify artist - use fallback method
+        // ignore: avoid_print
+        print('[ArtistScreen] Fetching from Spotify with fallback: ${widget.artistId}');
+        final url = 'https://open.spotify.com/artist/${widget.artistId}';
+        final metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+        final albumsList = metadata['albums'] as List<dynamic>;
+        albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      }
       
       // Store in cache
       _ArtistCache.set(widget.artistId, albums);
@@ -290,7 +305,9 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
                       Text(album.name, style: Theme.of(context).textTheme.bodySmall?.copyWith(fontWeight: FontWeight.w600), maxLines: 2, overflow: TextOverflow.ellipsis),
                       const Spacer(),
                       Text(
-                        '${album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate} • ${album.totalTracks} tracks',
+                        album.totalTracks > 0 
+                            ? '${album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate} • ${album.totalTracks} tracks'
+                            : album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate,
                         style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant, fontSize: 11),
                         maxLines: 1,
                         overflow: TextOverflow.ellipsis,

lib/screens/home_screen.dart

@@ -38,7 +38,8 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
     if (url.startsWith('http') || url.startsWith('spotify:')) {
       await ref.read(trackProvider.notifier).fetchFromUrl(url);
     } else {
-      await ref.read(trackProvider.notifier).search(url);
+      final settings = ref.read(settingsProvider);
+      await ref.read(trackProvider.notifier).search(url, metadataSource: settings.metadataSource);
     }
   }
 

lib/screens/home_tab.dart

@@ -81,7 +81,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     if (_lastSearchQuery == query) return;
     _lastSearchQuery = query;
     
-    await ref.read(trackProvider.notifier).search(query);
+    final settings = ref.read(settingsProvider);
+    await ref.read(trackProvider.notifier).search(query, metadataSource: settings.metadataSource);
     ref.read(settingsProvider.notifier).setHasSearchedBefore();
   }
 
@@ -112,7 +113,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       await ref.read(trackProvider.notifier).fetchFromUrl(url);
       _navigateToDetailIfNeeded();
     } else {
-      await ref.read(trackProvider.notifier).search(url);
+      final settings = ref.read(settingsProvider);
+      await ref.read(trackProvider.notifier).search(url, metadataSource: settings.metadataSource);
     }
     ref.read(settingsProvider.notifier).setHasSearchedBefore();
   }
@@ -170,8 +172,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       final settings = ref.read(settingsProvider);
       
       if (settings.askQualityBeforeDownload) {
-        _showQualityPicker(context, (quality) {
-          ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService, qualityOverride: quality);
+        _showQualityPicker(context, (quality, service) {
+          ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
           ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
         }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
       } else {
@@ -181,59 +183,84 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     }
   }
 
-  void _showQualityPicker(BuildContext context, void Function(String quality) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
+  void _showQualityPicker(BuildContext context, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
     final colorScheme = Theme.of(context).colorScheme;
+    final settings = ref.read(settingsProvider);
+    String selectedService = settings.defaultService;
+    
     showModalBottomSheet(
       context: context,
       backgroundColor: colorScheme.surfaceContainerHigh,
       shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      builder: (context) => SafeArea(
-        child: Column(
-          mainAxisSize: MainAxisSize.min,
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (trackName != null) ...[
-              _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-              Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-            ] else ...[
-              const SizedBox(height: 8),
-              Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
-            ],
-            Padding(
-              padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-              child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
-            ),
-            // Disclaimer
-            Padding(
-              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-              child: Text(
-                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                  color: colorScheme.onSurfaceVariant,
-                  fontStyle: FontStyle.italic,
+      isScrollControlled: true,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setModalState) => SafeArea(
+          child: SingleChildScrollView(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                if (trackName != null) ...[
+                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
+                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+                ] else ...[
+                  const SizedBox(height: 8),
+                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
+                ],
+                // Service selector
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
+                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
                 ),
-              ),
+                Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 20),
+                  child: Row(
+                    children: [
+                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
+                    ],
+                  ),
+                ),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
+                  child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
+                ),
+                // Disclaimer
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+                  child: Text(
+                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                      fontStyle: FontStyle.italic,
+                    ),
+                  ),
+                ),
+                _QualityPickerOption(
+                  title: 'FLAC Lossless',
+                  subtitle: '16-bit / 44.1kHz',
+                  icon: Icons.music_note,
+                  onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); },
+                ),
+                _QualityPickerOption(
+                  title: 'Hi-Res FLAC',
+                  subtitle: '24-bit / up to 96kHz',
+                  icon: Icons.high_quality,
+                  onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); },
+                ),
+                _QualityPickerOption(
+                  title: 'Hi-Res FLAC Max',
+                  subtitle: '24-bit / up to 192kHz',
+                  icon: Icons.four_k,
+                  onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); },
+                ),
+                const SizedBox(height: 16),
+              ],
             ),
-            _QualityPickerOption(
-              title: 'FLAC Lossless',
-              subtitle: '16-bit / 44.1kHz',
-              icon: Icons.music_note,
-              onTap: () { Navigator.pop(context); onSelect('LOSSLESS'); },
-            ),
-            _QualityPickerOption(
-              title: 'Hi-Res FLAC',
-              subtitle: '24-bit / up to 96kHz',
-              icon: Icons.high_quality,
-              onTap: () { Navigator.pop(context); onSelect('HI_RES'); },
-            ),
-            _QualityPickerOption(
-              title: 'Hi-Res FLAC Max',
-              subtitle: '24-bit / up to 192kHz',
-              icon: Icons.four_k,
-              onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS'); },
-            ),
-            const SizedBox(height: 16),
-          ],
+          ),
         ),
       ),
     );
@@ -764,6 +791,40 @@ class _QualityPickerOption extends StatelessWidget {
   }
 }
 
+class _ServiceChip extends StatelessWidget {
+  final String label;
+  final bool isSelected;
+  final VoidCallback onTap;
+  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Expanded(
+      child: GestureDetector(
+        onTap: onTap,
+        child: AnimatedContainer(
+          duration: const Duration(milliseconds: 200),
+          padding: const EdgeInsets.symmetric(vertical: 10),
+          decoration: BoxDecoration(
+            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(12),
+            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+          ),
+          child: Text(
+            label,
+            textAlign: TextAlign.center,
+            style: TextStyle(
+              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
 class _TrackInfoHeader extends StatefulWidget {
   final String trackName;
   final String? artistName;

lib/screens/main_shell.dart

@@ -85,7 +85,7 @@ class _MainShellState extends ConsumerState<MainShell> {
     final settings = ref.read(settingsProvider);
     if (!settings.checkForUpdates) return;
 
-    final updateInfo = await UpdateChecker.checkForUpdate();
+    final updateInfo = await UpdateChecker.checkForUpdate(channel: settings.updateChannel);
     if (updateInfo != null && mounted) {
       showUpdateDialog(
         context,

lib/screens/playlist_screen.dart

@@ -168,8 +168,8 @@ class PlaylistScreen extends ConsumerWidget {
   void _downloadTrack(BuildContext context, WidgetRef ref, Track track) {
     final settings = ref.read(settingsProvider);
     if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality) {
-        ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService, qualityOverride: quality);
+      _showQualityPicker(context, ref, (quality, service) {
+        ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
         ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
       }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
     } else {
@@ -182,8 +182,8 @@ class PlaylistScreen extends ConsumerWidget {
     if (tracks.isEmpty) return;
     final settings = ref.read(settingsProvider);
     if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality) {
-        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService, qualityOverride: quality);
+      _showQualityPicker(context, ref, (quality, service) {
+        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
         ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
       }, trackName: '${tracks.length} tracks', artistName: playlistName);
     } else {
@@ -192,41 +192,66 @@ class PlaylistScreen extends ConsumerWidget {
     }
   }
 
-  void _showQualityPicker(BuildContext context, void Function(String quality) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
+  void _showQualityPicker(BuildContext context, WidgetRef ref, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
     final colorScheme = Theme.of(context).colorScheme;
+    final settings = ref.read(settingsProvider);
+    String selectedService = settings.defaultService;
+    
     showModalBottomSheet(
       context: context,
       backgroundColor: colorScheme.surfaceContainerHigh,
       shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      builder: (context) => SafeArea(
-        child: Column(
-          mainAxisSize: MainAxisSize.min,
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (trackName != null) ...[
-              _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-              Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-            ] else ...[
-              const SizedBox(height: 8),
-              Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
-            ],
-            Padding(padding: const EdgeInsets.fromLTRB(24, 16, 24, 8), child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold))),
-            // Disclaimer
-            Padding(
-              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-              child: Text(
-                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                  color: colorScheme.onSurfaceVariant,
-                  fontStyle: FontStyle.italic,
+      isScrollControlled: true,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setModalState) => SafeArea(
+          child: SingleChildScrollView(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                if (trackName != null) ...[
+                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
+                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+                ] else ...[
+                  const SizedBox(height: 8),
+                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
+                ],
+                // Service selector
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
+                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
                 ),
-              ),
+                Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 20),
+                  child: Row(
+                    children: [
+                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
+                      const SizedBox(width: 8),
+                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
+                    ],
+                  ),
+                ),
+                Padding(padding: const EdgeInsets.fromLTRB(24, 16, 24, 8), child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold))),
+                // Disclaimer
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+                  child: Text(
+                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                      fontStyle: FontStyle.italic,
+                    ),
+                  ),
+                ),
+                _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); }),
+                _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); }),
+                _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); }),
+                const SizedBox(height: 16),
+              ],
             ),
-            _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS'); }),
-            _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES'); }),
-            _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS'); }),
-            const SizedBox(height: 16),
-          ],
+          ),
         ),
       ),
     );
@@ -254,6 +279,40 @@ class _QualityOption extends StatelessWidget {
   }
 }
 
+class _ServiceChip extends StatelessWidget {
+  final String label;
+  final bool isSelected;
+  final VoidCallback onTap;
+  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Expanded(
+      child: GestureDetector(
+        onTap: onTap,
+        child: AnimatedContainer(
+          duration: const Duration(milliseconds: 200),
+          padding: const EdgeInsets.symmetric(vertical: 10),
+          decoration: BoxDecoration(
+            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(12),
+            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
+          ),
+          child: Text(
+            label,
+            textAlign: TextAlign.center,
+            style: TextStyle(
+              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
 class _TrackInfoHeader extends StatefulWidget {
   final String trackName;
   final String? artistName;

lib/screens/queue_tab.dart

@@ -331,8 +331,11 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                             ),
                           ),
                           const SizedBox(width: 8),
+                          // Show percentage and speed
                           Text(
-                            '${(item.progress * 100).toStringAsFixed(0)}%',
+                            item.speedMBps > 0 
+                                ? '${(item.progress * 100).toStringAsFixed(0)}% • ${item.speedMBps.toStringAsFixed(1)} MB/s'
+                                : '${(item.progress * 100).toStringAsFixed(0)}%',
                             style: Theme.of(context).textTheme.labelSmall?.copyWith(
                               color: colorScheme.primary,
                               fontWeight: FontWeight.bold,
@@ -344,7 +347,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                     if (item.status == DownloadStatus.failed) ...[
                       const SizedBox(height: 4),
                       Text(
-                        item.error ?? 'Download failed',
+                        item.errorMessage, // Use user-friendly error message
                         maxLines: 1,
                         overflow: TextOverflow.ellipsis,
                         style: Theme.of(context).textTheme.labelSmall?.copyWith(

lib/screens/search_screen.dart

@@ -23,7 +23,8 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
     _searchController = TextEditingController(text: widget.query);
     if (widget.query.isNotEmpty) {
       WidgetsBinding.instance.addPostFrameCallback((_) {
-        ref.read(trackProvider.notifier).search(widget.query);
+        final settings = ref.read(settingsProvider);
+        ref.read(trackProvider.notifier).search(widget.query, metadataSource: settings.metadataSource);
       });
     }
   }
@@ -37,7 +38,8 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
   void _search() {
     final query = _searchController.text.trim();
     if (query.isNotEmpty) {
-      ref.read(trackProvider.notifier).search(query);
+      final settings = ref.read(settingsProvider);
+      ref.read(trackProvider.notifier).search(query, metadataSource: settings.metadataSource);
     }
   }
 

lib/screens/settings/about_page.dart

@@ -123,6 +123,24 @@ class AboutPage extends StatelessWidget {
             ),
           ),
 
+          // Support section
+          const SliverToBoxAdapter(
+            child: SettingsSectionHeader(title: 'Support'),
+          ),
+          SliverToBoxAdapter(
+            child: SettingsGroup(
+              children: [
+                SettingsItem(
+                  icon: Icons.coffee_outlined,
+                  title: 'Buy me a coffee',
+                  subtitle: 'Support development on Ko-fi',
+                  onTap: () => _launchUrl(AppInfo.kofiUrl),
+                  showDivider: false,
+                ),
+              ],
+            ),
+          ),
+
           // App info section
           const SliverToBoxAdapter(
             child: SettingsSectionHeader(title: 'App'),

lib/screens/settings/appearance_settings_page.dart

@@ -40,6 +40,14 @@ class AppearanceSettingsPage extends ConsumerWidget {
                     currentMode: themeSettings.themeMode,
                     onChanged: (mode) => ref.read(themeProvider.notifier).setThemeMode(mode),
                   ),
+                  SettingsSwitchItem(
+                    icon: Icons.brightness_2,
+                    title: 'AMOLED Dark',
+                    subtitle: 'Pure black background for OLED screens',
+                    value: themeSettings.useAmoled,
+                    onChanged: (value) => ref.read(themeProvider.notifier).setUseAmoled(value),
+                    showDivider: false,
+                  ),
                 ],
               ),
             ),

lib/screens/settings/download_settings_page.dart

@@ -1,6 +1,8 @@
+import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:file_picker/file_picker.dart';
+import 'package:path_provider/path_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/widgets/settings_group.dart';
 
@@ -113,8 +115,10 @@ class DownloadSettingsPage extends ConsumerWidget {
                 SettingsItem(
                   icon: Icons.folder_outlined,
                   title: 'Download Directory',
-                  subtitle: settings.downloadDirectory.isEmpty ? 'Music/SpotiFLAC' : settings.downloadDirectory,
-                  onTap: () => _pickDirectory(ref),
+                  subtitle: settings.downloadDirectory.isEmpty 
+                      ? (Platform.isIOS ? 'App Documents Folder' : 'Music/SpotiFLAC') 
+                      : settings.downloadDirectory,
+                  onTap: () => _pickDirectory(context, ref),
                 ),
                 SettingsItem(
                   icon: Icons.create_new_folder_outlined,
@@ -161,9 +165,90 @@ class DownloadSettingsPage extends ConsumerWidget {
     );
   }
 
-  Future<void> _pickDirectory(WidgetRef ref) async {
-    final result = await FilePicker.platform.getDirectoryPath();
-    if (result != null) ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+  Future<void> _pickDirectory(BuildContext context, WidgetRef ref) async {
+    if (Platform.isIOS) {
+      // iOS: Show options dialog
+      _showIOSDirectoryOptions(context, ref);
+    } else {
+      // Android: Use file picker
+      final result = await FilePicker.platform.getDirectoryPath();
+      if (result != null) ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+    }
+  }
+
+  void _showIOSDirectoryOptions(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showModalBottomSheet(
+      context: context,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      builder: (ctx) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
+              child: Text('Download Location', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+              child: Text(
+                'On iOS, downloads are saved to the app\'s Documents folder which is accessible via the Files app.',
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+              ),
+            ),
+            ListTile(
+              leading: Icon(Icons.folder_special, color: colorScheme.primary),
+              title: const Text('App Documents Folder'),
+              subtitle: const Text('Recommended - accessible via Files app'),
+              trailing: Icon(Icons.check_circle, color: colorScheme.primary),
+              onTap: () async {
+                final dir = await getApplicationDocumentsDirectory();
+                ref.read(settingsProvider.notifier).setDownloadDirectory(dir.path);
+                if (ctx.mounted) Navigator.pop(ctx);
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.cloud, color: colorScheme.onSurfaceVariant),
+              title: const Text('Choose from Files'),
+              subtitle: const Text('Select iCloud or other location'),
+              onTap: () async {
+                Navigator.pop(ctx);
+                // Note: iOS requires folder to have at least one file to be selectable
+                final result = await FilePicker.platform.getDirectoryPath();
+                if (result != null) {
+                  ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+                }
+              },
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 8, 24, 16),
+              child: Container(
+                padding: const EdgeInsets.all(12),
+                decoration: BoxDecoration(
+                  color: colorScheme.tertiaryContainer.withValues(alpha: 0.3),
+                  borderRadius: BorderRadius.circular(12),
+                ),
+                child: Row(
+                  children: [
+                    Icon(Icons.info_outline, size: 20, color: colorScheme.tertiary),
+                    const SizedBox(width: 12),
+                    Expanded(
+                      child: Text(
+                        'iOS limitation: Empty folders cannot be selected. Create a file inside first or use App Documents.',
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onTertiaryContainer),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+            const SizedBox(height: 8),
+          ],
+        ),
+      ),
+    );
   }
 
   String _getFolderOrganizationLabel(String value) {

lib/screens/settings/options_settings_page.dart

@@ -105,7 +105,10 @@ class OptionsSettingsPage extends ConsumerWidget {
                   subtitle: 'Notify when new version is available',
                   value: settings.checkForUpdates,
                   onChanged: (v) => ref.read(settingsProvider.notifier).setCheckForUpdates(v),
-                  showDivider: false,
+                ),
+                _UpdateChannelSelector(
+                  currentChannel: settings.updateChannel,
+                  onChanged: (v) => ref.read(settingsProvider.notifier).setUpdateChannel(v),
                 ),
               ],
             ),
@@ -116,29 +119,35 @@ class OptionsSettingsPage extends ConsumerWidget {
           SliverToBoxAdapter(
             child: SettingsGroup(
               children: [
-                SettingsItem(
-                  icon: Icons.key,
-                  title: 'Custom Credentials',
-                  subtitle: settings.spotifyClientId.isNotEmpty 
-                      ? 'Client ID: ${settings.spotifyClientId.length > 8 ? '${settings.spotifyClientId.substring(0, 8)}...' : settings.spotifyClientId}' 
-                      : 'Not configured',
-                  onTap: () => _showSpotifyCredentialsDialog(context, ref, settings),
-                  trailing: settings.spotifyClientId.isNotEmpty
-                      ? Icon(Icons.edit, color: Theme.of(context).colorScheme.onSurfaceVariant, size: 20)
-                      : Icon(Icons.add, color: Theme.of(context).colorScheme.primary, size: 20),
-                  showDivider: settings.spotifyClientId.isNotEmpty,
+                _MetadataSourceSelector(
+                  currentSource: settings.metadataSource,
+                  onChanged: (v) => ref.read(settingsProvider.notifier).setMetadataSource(v),
                 ),
-                if (settings.spotifyClientId.isNotEmpty)
-                  SettingsSwitchItem(
-                    icon: Icons.toggle_on,
-                    title: 'Use Custom Credentials',
-                    subtitle: settings.useCustomSpotifyCredentials 
-                        ? 'Using your credentials' 
-                        : 'Using default credentials',
-                    value: settings.useCustomSpotifyCredentials,
-                    onChanged: (v) => ref.read(settingsProvider.notifier).setUseCustomSpotifyCredentials(v),
-                    showDivider: false,
+                if (settings.metadataSource == 'spotify') ...[
+                  SettingsItem(
+                    icon: Icons.key,
+                    title: 'Custom Credentials',
+                    subtitle: settings.spotifyClientId.isNotEmpty 
+                        ? 'Client ID: ${settings.spotifyClientId.length > 8 ? '${settings.spotifyClientId.substring(0, 8)}...' : settings.spotifyClientId}' 
+                        : 'Not configured',
+                    onTap: () => _showSpotifyCredentialsDialog(context, ref, settings),
+                    trailing: settings.spotifyClientId.isNotEmpty
+                        ? Icon(Icons.edit, color: Theme.of(context).colorScheme.onSurfaceVariant, size: 20)
+                        : Icon(Icons.add, color: Theme.of(context).colorScheme.primary, size: 20),
+                    showDivider: settings.spotifyClientId.isNotEmpty,
                   ),
+                  if (settings.spotifyClientId.isNotEmpty)
+                    SettingsSwitchItem(
+                      icon: Icons.toggle_on,
+                      title: 'Use Custom Credentials',
+                      subtitle: settings.useCustomSpotifyCredentials 
+                          ? 'Using your credentials' 
+                          : 'Using default credentials',
+                      value: settings.useCustomSpotifyCredentials,
+                      onChanged: (v) => ref.read(settingsProvider.notifier).setUseCustomSpotifyCredentials(v),
+                      showDivider: false,
+                    ),
+                ],
               ],
             ),
           ),
@@ -393,3 +402,149 @@ class _ConcurrentChip extends StatelessWidget {
     );
   }
 }
+
+class _UpdateChannelSelector extends StatelessWidget {
+  final String currentChannel;
+  final ValueChanged<String> onChanged;
+  const _UpdateChannelSelector({required this.currentChannel, required this.onChanged});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Padding(
+      padding: const EdgeInsets.all(20),
+      child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
+        Row(children: [
+          Icon(Icons.new_releases, color: colorScheme.onSurfaceVariant, size: 24),
+          const SizedBox(width: 16),
+          Expanded(child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
+            Text('Update Channel', style: Theme.of(context).textTheme.bodyLarge),
+            const SizedBox(height: 2),
+            Text(currentChannel == 'preview' ? 'Get preview releases' : 'Stable releases only',
+              style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+          ])),
+        ]),
+        const SizedBox(height: 16),
+        Row(children: [
+          _ChannelChip(label: 'Stable', isSelected: currentChannel == 'stable', onTap: () => onChanged('stable')),
+          const SizedBox(width: 8),
+          _ChannelChip(label: 'Preview', isSelected: currentChannel == 'preview', onTap: () => onChanged('preview')),
+        ]),
+        const SizedBox(height: 12),
+        Row(children: [
+          Icon(Icons.info_outline, size: 16, color: colorScheme.onSurfaceVariant),
+          const SizedBox(width: 8),
+          Expanded(child: Text('Preview may contain bugs or incomplete features',
+            style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant))),
+        ]),
+      ]),
+    );
+  }
+}
+
+class _ChannelChip extends StatelessWidget {
+  final String label;
+  final bool isSelected;
+  final VoidCallback onTap;
+  const _ChannelChip({required this.label, required this.isSelected, required this.onTap});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    
+    final unselectedColor = isDark 
+        ? Color.alphaBlend(Colors.white.withValues(alpha: 0.05), colorScheme.surface)
+        : colorScheme.surfaceContainerHigh;
+    
+    return Expanded(
+      child: Material(
+        color: isSelected ? colorScheme.primaryContainer : unselectedColor,
+        borderRadius: BorderRadius.circular(12),
+        child: InkWell(
+          onTap: onTap,
+          borderRadius: BorderRadius.circular(12),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(vertical: 12),
+            child: Center(child: Text(label, style: TextStyle(
+              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant))),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+class _MetadataSourceSelector extends StatelessWidget {
+  final String currentSource;
+  final ValueChanged<String> onChanged;
+  const _MetadataSourceSelector({required this.currentSource, required this.onChanged});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Padding(
+      padding: const EdgeInsets.all(20),
+      child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
+        Row(children: [
+          Icon(Icons.search, color: colorScheme.onSurfaceVariant, size: 24),
+          const SizedBox(width: 16),
+          Expanded(child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
+            Text('Search Source', style: Theme.of(context).textTheme.bodyLarge),
+            const SizedBox(height: 2),
+            Text(currentSource == 'deezer' ? 'Deezer (no need developer account)' : 'Spotify (may hit rate limit)',
+              style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+          ])),
+        ]),
+        const SizedBox(height: 16),
+        Row(children: [
+          _SourceChip(label: 'Deezer', isSelected: currentSource == 'deezer', onTap: () => onChanged('deezer')),
+          const SizedBox(width: 8),
+          _SourceChip(label: 'Spotify', isSelected: currentSource == 'spotify', onTap: () => onChanged('spotify')),
+        ]),
+        const SizedBox(height: 12),
+        Row(children: [
+          Icon(Icons.info_outline, size: 16, color: colorScheme.onSurfaceVariant),
+          const SizedBox(width: 8),
+          Expanded(child: Text('Spotify URLs are always supported regardless of this setting',
+            style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant))),
+        ]),
+      ]),
+    );
+  }
+}
+
+class _SourceChip extends StatelessWidget {
+  final String label;
+  final bool isSelected;
+  final VoidCallback onTap;
+  const _SourceChip({required this.label, required this.isSelected, required this.onTap});
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    
+    final unselectedColor = isDark 
+        ? Color.alphaBlend(Colors.white.withValues(alpha: 0.05), colorScheme.surface)
+        : colorScheme.surfaceContainerHigh;
+    
+    return Expanded(
+      child: Material(
+        color: isSelected ? colorScheme.primaryContainer : unselectedColor,
+        borderRadius: BorderRadius.circular(12),
+        child: InkWell(
+          onTap: onTap,
+          borderRadius: BorderRadius.circular(12),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(vertical: 12),
+            child: Center(child: Text(label, style: TextStyle(
+              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant))),
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/screens/setup_screen.dart

@@ -23,9 +23,15 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
   String? _selectedDirectory;
   bool _isLoading = false;
   int _androidSdkVersion = 0;
+  
+  // Spotify API credentials
+  final _clientIdController = TextEditingController();
+  final _clientSecretController = TextEditingController();
+  bool _useSpotifyApi = false;
+  bool _showClientSecret = false;
 
-  // Total steps: Storage -> Notification (Android 13+) -> Folder
-  int get _totalSteps => _androidSdkVersion >= 33 ? 3 : 2;
+  // Total steps: Storage -> Notification (Android 13+) -> Folder -> Spotify API
+  int get _totalSteps => _androidSdkVersion >= 33 ? 4 : 3;
 
   @override
   void initState() {
@@ -33,6 +39,13 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
     _initDeviceInfo();
   }
 
+  @override
+  void dispose() {
+    _clientIdController.dispose();
+    _clientSecretController.dispose();
+    super.dispose();
+  }
+
   Future<void> _initDeviceInfo() async {
     if (Platform.isAndroid) {
       final deviceInfo = DeviceInfoPlugin();
@@ -205,29 +218,35 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
     setState(() => _isLoading = true);
 
     try {
-      String? selectedDirectory = await FilePicker.platform.getDirectoryPath(
-        dialogTitle: 'Select Download Folder',
-      );
-
-      if (selectedDirectory != null) {
-        setState(() => _selectedDirectory = selectedDirectory);
+      if (Platform.isIOS) {
+        // iOS: Show options dialog
+        await _showIOSDirectoryOptions();
       } else {
-        final defaultDir = await _getDefaultDirectory();
-        if (mounted) {
-          final useDefault = await showDialog<bool>(
-            context: context,
-            builder: (context) => AlertDialog(
-              title: const Text('Use Default Folder?'),
-              content: Text('No folder selected. Would you like to use the default Music folder?\n\n$defaultDir'),
-              actions: [
-                TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Cancel')),
-                TextButton(onPressed: () => Navigator.pop(context, true), child: const Text('Use Default')),
-              ],
-            ),
-          );
+        // Android: Use file picker
+        String? selectedDirectory = await FilePicker.platform.getDirectoryPath(
+          dialogTitle: 'Select Download Folder',
+        );
 
-          if (useDefault == true) {
-            setState(() => _selectedDirectory = defaultDir);
+        if (selectedDirectory != null) {
+          setState(() => _selectedDirectory = selectedDirectory);
+        } else {
+          final defaultDir = await _getDefaultDirectory();
+          if (mounted) {
+            final useDefault = await showDialog<bool>(
+              context: context,
+              builder: (context) => AlertDialog(
+                title: const Text('Use Default Folder?'),
+                content: Text('No folder selected. Would you like to use the default Music folder?\n\n$defaultDir'),
+                actions: [
+                  TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Cancel')),
+                  TextButton(onPressed: () => Navigator.pop(context, true), child: const Text('Use Default')),
+                ],
+              ),
+            );
+
+            if (useDefault == true) {
+              setState(() => _selectedDirectory = defaultDir);
+            }
           }
         }
       }
@@ -236,6 +255,82 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
     }
   }
 
+  Future<void> _showIOSDirectoryOptions() async {
+    final colorScheme = Theme.of(context).colorScheme;
+    
+    await showModalBottomSheet(
+      context: context,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      builder: (ctx) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
+              child: Text('Download Location', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+              child: Text(
+                'On iOS, downloads are saved to the app\'s Documents folder which is accessible via the Files app.',
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+              ),
+            ),
+            ListTile(
+              leading: Icon(Icons.folder_special, color: colorScheme.primary),
+              title: const Text('App Documents Folder'),
+              subtitle: const Text('Recommended - accessible via Files app'),
+              trailing: Icon(Icons.check_circle, color: colorScheme.primary),
+              onTap: () async {
+                final dir = await _getDefaultDirectory();
+                setState(() => _selectedDirectory = dir);
+                if (ctx.mounted) Navigator.pop(ctx);
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.cloud, color: colorScheme.onSurfaceVariant),
+              title: const Text('Choose from Files'),
+              subtitle: const Text('Select iCloud or other location'),
+              onTap: () async {
+                Navigator.pop(ctx);
+                // Note: iOS requires folder to have at least one file to be selectable
+                final result = await FilePicker.platform.getDirectoryPath();
+                if (result != null) {
+                  setState(() => _selectedDirectory = result);
+                }
+              },
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 8, 24, 16),
+              child: Container(
+                padding: const EdgeInsets.all(12),
+                decoration: BoxDecoration(
+                  color: colorScheme.tertiaryContainer.withValues(alpha: 0.3),
+                  borderRadius: BorderRadius.circular(12),
+                ),
+                child: Row(
+                  children: [
+                    Icon(Icons.info_outline, size: 20, color: colorScheme.tertiary),
+                    const SizedBox(width: 12),
+                    Expanded(
+                      child: Text(
+                        'iOS limitation: Empty folders cannot be selected. Create a file inside first or use App Documents.',
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onTertiaryContainer),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+            const SizedBox(height: 8),
+          ],
+        ),
+      ),
+    );
+  }
+
   Future<String> _getDefaultDirectory() async {
     if (Platform.isIOS) {
       final appDir = await getApplicationDocumentsDirectory();
@@ -276,6 +371,23 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       }
 
       ref.read(settingsProvider.notifier).setDownloadDirectory(_selectedDirectory!);
+      
+      // Save Spotify credentials if provided
+      if (_useSpotifyApi && 
+          _clientIdController.text.trim().isNotEmpty && 
+          _clientSecretController.text.trim().isNotEmpty) {
+        ref.read(settingsProvider.notifier).setSpotifyCredentials(
+          _clientIdController.text.trim(),
+          _clientSecretController.text.trim(),
+        );
+        ref.read(settingsProvider.notifier).setUseCustomSpotifyCredentials(true);
+        // Set search source to Spotify when using custom credentials
+        ref.read(settingsProvider.notifier).setMetadataSource('spotify');
+      } else {
+        // Use Deezer as default search source
+        ref.read(settingsProvider.notifier).setMetadataSource('deezer');
+      }
+      
       ref.read(settingsProvider.notifier).setFirstLaunchComplete();
 
       if (mounted) {
@@ -354,8 +466,8 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
 
   Widget _buildStepIndicator(ColorScheme colorScheme) {
     final steps = _androidSdkVersion >= 33
-        ? ['Storage', 'Notification', 'Folder']
-        : ['Permission', 'Folder'];
+        ? ['Storage', 'Notification', 'Folder', 'Spotify']
+        : ['Permission', 'Folder', 'Spotify'];
     
     return Row(
       mainAxisAlignment: MainAxisAlignment.center,
@@ -379,48 +491,61 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
   Widget _buildStepDot(int step, String label, ColorScheme colorScheme) {
     final isActive = _currentStep >= step;
     final isCompleted = _isStepCompleted(step);
+    final isCurrent = _currentStep == step;
 
     return Column(
       children: [
-        Container(
-          width: 32,
-          height: 32,
+        AnimatedContainer(
+          duration: const Duration(milliseconds: 200),
+          width: 36,
+          height: 36,
           decoration: BoxDecoration(
             shape: BoxShape.circle,
             color: isCompleted
                 ? colorScheme.primary
-                : isActive ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+                : isCurrent 
+                    ? colorScheme.primaryContainer 
+                    : colorScheme.surfaceContainerHighest,
+            border: isCurrent && !isCompleted
+                ? Border.all(color: colorScheme.primary, width: 2)
+                : null,
           ),
           child: Center(
             child: isCompleted
-                ? Icon(Icons.check, size: 18, color: colorScheme.onPrimary)
+                ? Icon(Icons.check_rounded, size: 20, color: colorScheme.onPrimary)
                 : Text('${step + 1}',
                     style: TextStyle(
-                      color: isActive ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
-                      fontWeight: FontWeight.bold)),
+                      color: isCurrent ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+                      fontWeight: FontWeight.w600,
+                      fontSize: 14,
+                    )),
           ),
         ),
-        const SizedBox(height: 4),
+        const SizedBox(height: 6),
         Text(label,
           style: Theme.of(context).textTheme.labelSmall?.copyWith(
-            color: isActive ? colorScheme.onSurface : colorScheme.onSurfaceVariant)),
+            color: isActive ? colorScheme.onSurface : colorScheme.onSurfaceVariant,
+            fontWeight: isCurrent ? FontWeight.w600 : FontWeight.normal,
+          )),
       ],
     );
   }
 
   bool _isStepCompleted(int step) {
     if (_androidSdkVersion >= 33) {
-      // 3 steps: Storage, Notification, Folder
+      // 4 steps: Storage, Notification, Folder, Spotify
       switch (step) {
         case 0: return _storagePermissionGranted;
         case 1: return _notificationPermissionGranted;
         case 2: return _selectedDirectory != null;
+        case 3: return false; // Spotify step never shows checkmark (optional)
       }
     } else {
-      // 2 steps: Permission, Folder
+      // 3 steps: Permission, Folder, Spotify
       switch (step) {
         case 0: return _storagePermissionGranted;
         case 1: return _selectedDirectory != null;
+        case 2: return false; // Spotify step never shows checkmark (optional)
       }
     }
     return false;
@@ -432,11 +557,13 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
         case 0: return _buildStoragePermissionStep(colorScheme);
         case 1: return _buildNotificationPermissionStep(colorScheme);
         case 2: return _buildDirectoryStep(colorScheme);
+        case 3: return _buildSpotifyApiStep(colorScheme);
       }
     } else {
       switch (_currentStep) {
         case 0: return _buildStoragePermissionStep(colorScheme);
         case 1: return _buildDirectoryStep(colorScheme);
+        case 2: return _buildSpotifyApiStep(colorScheme);
       }
     }
     return const SizedBox();
@@ -447,35 +574,50 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       mainAxisAlignment: MainAxisAlignment.center,
       mainAxisSize: MainAxisSize.min,
       children: [
-        Icon(
-          _storagePermissionGranted ? Icons.check_circle : Icons.folder_open,
-          size: 56,
-          color: _storagePermissionGranted ? colorScheme.primary : colorScheme.onSurfaceVariant,
+        // Icon with container background (M3 style)
+        Container(
+          width: 80,
+          height: 80,
+          decoration: BoxDecoration(
+            color: _storagePermissionGranted ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(24),
+          ),
+          child: Icon(
+            _storagePermissionGranted ? Icons.check_rounded : Icons.folder_open_rounded,
+            size: 40,
+            color: _storagePermissionGranted ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+          ),
         ),
-        const SizedBox(height: 16),
+        const SizedBox(height: 20),
         Text(
           _storagePermissionGranted ? 'Storage Permission Granted!' : 'Storage Permission Required',
-          style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
+          style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
           textAlign: TextAlign.center,
         ),
         const SizedBox(height: 8),
-        Text(
-          _storagePermissionGranted
-              ? 'You can now proceed to the next step.'
-              : 'SpotiFLAC needs storage access to save downloaded music files to your device.',
-          style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-          textAlign: TextAlign.center,
+        Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16),
+          child: Text(
+            _storagePermissionGranted
+                ? 'You can now proceed to the next step.'
+                : 'SpotiFLAC needs storage access to save downloaded music files to your device.',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+            textAlign: TextAlign.center,
+          ),
         ),
-        const SizedBox(height: 20),
+        const SizedBox(height: 24),
         if (!_storagePermissionGranted)
           FilledButton.icon(
             onPressed: _isLoading ? null : _requestStoragePermission,
             icon: _isLoading
                 ? SizedBox(width: 20, height: 20,
                     child: CircularProgressIndicator(strokeWidth: 2, color: colorScheme.onPrimary))
-                : const Icon(Icons.security),
+                : const Icon(Icons.security_rounded),
             label: const Text('Grant Permission'),
-            style: FilledButton.styleFrom(padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12)),
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+            ),
           ),
       ],
     );
@@ -486,39 +628,57 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       mainAxisAlignment: MainAxisAlignment.center,
       mainAxisSize: MainAxisSize.min,
       children: [
-        Icon(
-          _notificationPermissionGranted ? Icons.check_circle : Icons.notifications_outlined,
-          size: 56,
-          color: _notificationPermissionGranted ? colorScheme.primary : colorScheme.onSurfaceVariant,
+        // Icon with container background (M3 style)
+        Container(
+          width: 80,
+          height: 80,
+          decoration: BoxDecoration(
+            color: _notificationPermissionGranted ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(24),
+          ),
+          child: Icon(
+            _notificationPermissionGranted ? Icons.check_rounded : Icons.notifications_outlined,
+            size: 40,
+            color: _notificationPermissionGranted ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+          ),
         ),
-        const SizedBox(height: 16),
+        const SizedBox(height: 20),
         Text(
           _notificationPermissionGranted ? 'Notification Permission Granted!' : 'Enable Notifications',
-          style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
+          style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
           textAlign: TextAlign.center,
         ),
         const SizedBox(height: 8),
-        Text(
-          _notificationPermissionGranted
-              ? 'You will receive download progress notifications.'
-              : 'Get notified about download progress and completion. This helps you track downloads when the app is in background.',
-          style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-          textAlign: TextAlign.center,
+        Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16),
+          child: Text(
+            _notificationPermissionGranted
+                ? 'You will receive download progress notifications.'
+                : 'Get notified about download progress and completion. This helps you track downloads when the app is in background.',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+            textAlign: TextAlign.center,
+          ),
         ),
-        const SizedBox(height: 20),
+        const SizedBox(height: 24),
         if (!_notificationPermissionGranted) ...[
           FilledButton.icon(
             onPressed: _isLoading ? null : _requestNotificationPermission,
             icon: _isLoading
                 ? SizedBox(width: 20, height: 20,
                     child: CircularProgressIndicator(strokeWidth: 2, color: colorScheme.onPrimary))
-                : const Icon(Icons.notifications_active),
+                : const Icon(Icons.notifications_active_rounded),
             label: const Text('Enable Notifications'),
-            style: FilledButton.styleFrom(padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12)),
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+            ),
           ),
           const SizedBox(height: 12),
           TextButton(
             onPressed: _skipNotificationPermission,
+            style: TextButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+            ),
             child: const Text('Skip for now'),
           ),
         ],
@@ -531,51 +691,226 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       mainAxisAlignment: MainAxisAlignment.center,
       mainAxisSize: MainAxisSize.min,
       children: [
-        Icon(
-          _selectedDirectory != null ? Icons.folder : Icons.create_new_folder,
-          size: 56,
-          color: _selectedDirectory != null ? colorScheme.primary : colorScheme.onSurfaceVariant,
+        // Icon with container background (M3 style)
+        Container(
+          width: 80,
+          height: 80,
+          decoration: BoxDecoration(
+            color: _selectedDirectory != null ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(24),
+          ),
+          child: Icon(
+            _selectedDirectory != null ? Icons.folder_rounded : Icons.create_new_folder_rounded,
+            size: 40,
+            color: _selectedDirectory != null ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+          ),
         ),
-        const SizedBox(height: 16),
+        const SizedBox(height: 20),
         Text(
           _selectedDirectory != null ? 'Download Folder Selected!' : 'Choose Download Folder',
-          style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
+          style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
           textAlign: TextAlign.center,
         ),
         const SizedBox(height: 8),
         if (_selectedDirectory != null)
-          Container(
-            padding: const EdgeInsets.all(12),
-            decoration: BoxDecoration(
-              color: colorScheme.surfaceContainerHighest,
-              borderRadius: BorderRadius.circular(12),
-            ),
-            child: Row(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                Icon(Icons.folder, color: colorScheme.primary, size: 20),
-                const SizedBox(width: 8),
-                Flexible(
-                  child: Text(_selectedDirectory!,
-                    style: Theme.of(context).textTheme.bodySmall,
-                    overflow: TextOverflow.ellipsis),
-                ),
-              ],
+          Card(
+            elevation: 0,
+            color: colorScheme.surfaceContainerHigh,
+            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
+            child: Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  Icon(Icons.folder_rounded, color: colorScheme.primary, size: 20),
+                  const SizedBox(width: 12),
+                  Flexible(
+                    child: Text(
+                      _selectedDirectory!,
+                      style: Theme.of(context).textTheme.bodySmall,
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                  ),
+                ],
+              ),
             ),
           )
         else
-          Text('Select a folder where your downloaded music will be saved.',
-            style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-            textAlign: TextAlign.center),
-        const SizedBox(height: 20),
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16),
+            child: Text(
+              'Select a folder where your downloaded music will be saved.',
+              style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+              textAlign: TextAlign.center,
+            ),
+          ),
+        const SizedBox(height: 24),
         FilledButton.icon(
           onPressed: _isLoading ? null : _selectDirectory,
           icon: _isLoading
               ? SizedBox(width: 20, height: 20,
                   child: CircularProgressIndicator(strokeWidth: 2, color: colorScheme.onPrimary))
-              : Icon(_selectedDirectory != null ? Icons.edit : Icons.folder_open),
+              : Icon(_selectedDirectory != null ? Icons.edit_rounded : Icons.folder_open_rounded),
           label: Text(_selectedDirectory != null ? 'Change Folder' : 'Select Folder'),
-          style: FilledButton.styleFrom(padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12)),
+          style: FilledButton.styleFrom(
+            padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
+            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildSpotifyApiStep(ColorScheme colorScheme) {
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        // Icon with container background (M3 style)
+        Container(
+          width: 80,
+          height: 80,
+          decoration: BoxDecoration(
+            color: _useSpotifyApi ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(24),
+          ),
+          child: Icon(
+            Icons.api_rounded,
+            size: 40,
+            color: _useSpotifyApi ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+          ),
+        ),
+        const SizedBox(height: 20),
+        Text(
+          'Spotify API (Optional)',
+          style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
+          textAlign: TextAlign.center,
+        ),
+        const SizedBox(height: 8),
+        Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16),
+          child: Text(
+            'Add your Spotify API credentials for better search results, or skip to use Deezer instead.',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+            textAlign: TextAlign.center,
+          ),
+        ),
+        const SizedBox(height: 24),
+        
+        // Toggle card (M3 style)
+        Card(
+          elevation: 0,
+          color: colorScheme.surfaceContainerHigh,
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+          clipBehavior: Clip.antiAlias,
+          child: SwitchListTile(
+            contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+            title: Text('Use Spotify API', style: Theme.of(context).textTheme.titleSmall),
+            subtitle: Text(
+              _useSpotifyApi ? 'Enter your credentials below' : 'Using Deezer (no account needed)',
+              style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant),
+            ),
+            secondary: Container(
+              width: 40,
+              height: 40,
+              decoration: BoxDecoration(
+                color: _useSpotifyApi ? colorScheme.primary : colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(12),
+              ),
+              child: Icon(
+                _useSpotifyApi ? Icons.music_note_rounded : Icons.album_rounded,
+                size: 20,
+                color: _useSpotifyApi ? colorScheme.onPrimary : colorScheme.onSurfaceVariant,
+              ),
+            ),
+            value: _useSpotifyApi,
+            onChanged: (value) => setState(() => _useSpotifyApi = value),
+          ),
+        ),
+        
+        // Credentials form (animated)
+        AnimatedSize(
+          duration: const Duration(milliseconds: 300),
+          curve: Curves.easeInOut,
+          child: _useSpotifyApi ? Padding(
+            padding: const EdgeInsets.only(top: 16),
+            child: Card(
+              elevation: 0,
+              color: colorScheme.surfaceContainerHigh,
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    // Client ID
+                    Text('Client ID', style: Theme.of(context).textTheme.labelMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+                    const SizedBox(height: 8),
+                    TextField(
+                      controller: _clientIdController,
+                      decoration: InputDecoration(
+                        hintText: 'Enter Spotify Client ID',
+                        prefixIcon: const Icon(Icons.key_rounded),
+                        border: OutlineInputBorder(
+                          borderRadius: BorderRadius.circular(12),
+                          borderSide: BorderSide.none,
+                        ),
+                        filled: true,
+                        fillColor: colorScheme.surfaceContainerHighest,
+                        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
+                      ),
+                    ),
+                    const SizedBox(height: 16),
+                    
+                    // Client Secret
+                    Text('Client Secret', style: Theme.of(context).textTheme.labelMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+                    const SizedBox(height: 8),
+                    TextField(
+                      controller: _clientSecretController,
+                      obscureText: !_showClientSecret,
+                      decoration: InputDecoration(
+                        hintText: 'Enter Spotify Client Secret',
+                        prefixIcon: const Icon(Icons.lock_rounded),
+                        suffixIcon: IconButton(
+                          icon: Icon(_showClientSecret ? Icons.visibility_off_rounded : Icons.visibility_rounded),
+                          onPressed: () => setState(() => _showClientSecret = !_showClientSecret),
+                        ),
+                        border: OutlineInputBorder(
+                          borderRadius: BorderRadius.circular(12),
+                          borderSide: BorderSide.none,
+                        ),
+                        filled: true,
+                        fillColor: colorScheme.surfaceContainerHighest,
+                        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
+                      ),
+                    ),
+                    const SizedBox(height: 16),
+                    
+                    // Info banner
+                    Container(
+                      padding: const EdgeInsets.all(12),
+                      decoration: BoxDecoration(
+                        color: colorScheme.tertiaryContainer,
+                        borderRadius: BorderRadius.circular(12),
+                      ),
+                      child: Row(
+                        children: [
+                          Icon(Icons.info_outline_rounded, size: 20, color: colorScheme.onTertiaryContainer),
+                          const SizedBox(width: 12),
+                          Expanded(
+                            child: Text(
+                              'Get credentials from developer.spotify.com',
+                              style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onTertiaryContainer),
+                            ),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ) : const SizedBox.shrink(),
         ),
       ],
     );
@@ -584,6 +919,10 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
   Widget _buildNavigationButtons(ColorScheme colorScheme) {
     final isLastStep = _currentStep == _totalSteps - 1;
     final canProceed = _isStepCompleted(_currentStep);
+    
+    // For Spotify step, check if credentials are valid when enabled
+    final isSpotifyStepValid = !_useSpotifyApi || 
+        (_clientIdController.text.trim().isNotEmpty && _clientSecretController.text.trim().isNotEmpty);
 
     return Row(
       mainAxisAlignment: MainAxisAlignment.spaceBetween,
@@ -592,8 +931,11 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
         if (_currentStep > 0)
           TextButton.icon(
             onPressed: () => setState(() => _currentStep--),
-            icon: const Icon(Icons.arrow_back),
+            icon: const Icon(Icons.arrow_back_rounded),
             label: const Text('Back'),
+            style: TextButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+            ),
           )
         else
           const SizedBox(width: 100),
@@ -602,20 +944,32 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
         if (!isLastStep)
           FilledButton(
             onPressed: canProceed ? () => setState(() => _currentStep++) : null,
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+            ),
             child: const Row(
               mainAxisSize: MainAxisSize.min,
-              children: [Text('Next'), SizedBox(width: 8), Icon(Icons.arrow_forward, size: 18)],
+              children: [Text('Next'), SizedBox(width: 8), Icon(Icons.arrow_forward_rounded, size: 18)],
             ),
           )
         else
           FilledButton(
-            onPressed: _selectedDirectory != null && !_isLoading ? _completeSetup : null,
+            onPressed: isSpotifyStepValid && !_isLoading ? _completeSetup : null,
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+            ),
             child: _isLoading
                 ? SizedBox(width: 20, height: 20,
                     child: CircularProgressIndicator(strokeWidth: 2, color: colorScheme.onPrimary))
-                : const Row(
+                : Row(
                     mainAxisSize: MainAxisSize.min,
-                    children: [Text('Get Started'), SizedBox(width: 8), Icon(Icons.check, size: 18)],
+                    children: [
+                      Text(_useSpotifyApi ? 'Get Started' : 'Skip & Start'),
+                      const SizedBox(width: 8),
+                      const Icon(Icons.check_rounded, size: 18),
+                    ],
                   ),
           ),
       ],

lib/screens/track_metadata_screen.dart

@@ -759,17 +759,21 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
     });
 
     try {
+      // Add timeout to prevent infinite loading
       final result = await PlatformBridge.getLyricsLRC(
         item.spotifyId ?? '',
         item.trackName,
         item.artistName,
         filePath: _fileExists ? item.filePath : null, // Try embedded lyrics first
+      ).timeout(
+        const Duration(seconds: 20),
+        onTimeout: () => '', // Return empty string on timeout
       );
       
       if (mounted) {
         if (result.isEmpty) {
           setState(() {
-            _lyricsError = 'Lyrics not found';
+            _lyricsError = 'Lyrics not available for this track';
             _lyricsLoading = false;
           });
         } else {
@@ -783,8 +787,11 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
       }
     } catch (e) {
       if (mounted) {
+        final errorMsg = e.toString().contains('TimeoutException') 
+            ? 'Request timed out. Try again later.'
+            : 'Failed to load lyrics';
         setState(() {
-          _lyricsError = 'Failed to load lyrics';
+          _lyricsError = errorMsg;
           _lyricsLoading = false;
         });
       }

lib/services/ffmpeg_service.dart

@@ -1,5 +1,6 @@
 import 'dart:io';
 import 'package:flutter/services.dart';
+import 'package:path_provider/path_provider.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 
 final _log = AppLogger('FFmpeg');
@@ -133,22 +134,83 @@ class FFmpegService {
     }
   }
 
-  /// Embed cover art to FLAC file
+  /// Embed metadata and cover art to FLAC file
   /// Returns the file path on success, null on failure
-  static Future<String?> embedCover(String flacPath, String coverPath) async {
-    final tempOutput = '$flacPath.tmp';
-    final command = '-i "$flacPath" -i "$coverPath" -map 0:a -map 1:0 -c copy -metadata:s:v title="Album cover" -metadata:s:v comment="Cover (front)" -disposition:v attached_pic "$tempOutput" -y';
+  static Future<String?> embedMetadata({
+    required String flacPath,
+    String? coverPath,
+    Map<String, String>? metadata,
+  }) async {
+    // Android Scoped Storage: Cannot write directly to Music folder with FFmpeg
+    // Use app-internal cache directory for temp output
+    final tempDir = await getTemporaryDirectory();
+    final uniqueId = DateTime.now().millisecondsSinceEpoch;
+    final tempOutput = '${tempDir.path}/temp_embed_$uniqueId.flac';
+    
+    // Construct command
+    final StringBuffer cmdBuffer = StringBuffer();
+    cmdBuffer.write('-i "$flacPath" ');
+    
+    // Add cover input if available
+    if (coverPath != null) {
+      cmdBuffer.write('-i "$coverPath" ');
+    }
+    
+    // Map audio stream
+    cmdBuffer.write('-map 0:a ');
+    
+    // Map cover stream if available
+    if (coverPath != null) {
+      cmdBuffer.write('-map 1:0 ');
+      cmdBuffer.write('-c:v copy ');
+      cmdBuffer.write('-disposition:v attached_pic ');
+      cmdBuffer.write('-metadata:s:v title="Album cover" ');
+      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
+    }
+    
+    // Copy audio codec (don't re-encode)
+    cmdBuffer.write('-c:a copy ');
+    
+    // Add text metadata
+    if (metadata != null) {
+      metadata.forEach((key, value) {
+        // Sanitize value: escape double quotes
+        final sanitizedValue = value.replaceAll('"', '\\"');
+        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
+      });
+    }
+    
+    cmdBuffer.write('"$tempOutput" -y');
+    
+    final command = cmdBuffer.toString();
+    _log.d('Executing FFmpeg command: $command');
 
     final result = await _execute(command);
 
     if (result.success) {
       try {
-        // Replace original with temp
-        await File(flacPath).delete();
-        await File(tempOutput).rename(flacPath);
-        return flacPath;
+        // Copy temp output back to original location (replace)
+        final tempFile = File(tempOutput);
+        final originalFile = File(flacPath);
+        
+        if (await tempFile.exists()) {
+             // Delete original file
+             if (await originalFile.exists()) {
+               await originalFile.delete();
+             }
+             // Copy temp file to original location
+             await tempFile.copy(flacPath);
+             // Delete temp file
+             await tempFile.delete();
+             
+             return flacPath;
+        } else {
+             _log.e('Temp output file not found: $tempOutput');
+             return null;
+        }
+
       } catch (e) {
-        _log.e('Failed to replace file after cover embed: $e');
+        _log.e('Failed to replace file after metadata embed: $e');
         return null;
       }
     }
@@ -161,7 +223,7 @@ class FFmpegService {
       }
     } catch (_) {}
 
-    _log.e('Cover embed failed: ${result.output}');
+    _log.e('Metadata/Cover embed failed: ${result.output}');
     return null;
   }
 }

lib/services/platform_bridge.dart

@@ -111,7 +111,7 @@ class PlatformBridge {
     int discNumber = 1,
     int totalTracks = 1,
     String? releaseDate,
-    String preferredService = 'tidal',
+    String preferredService = 'qobuz',
     String? itemId,
     int durationMs = 0,
   }) async {
@@ -297,4 +297,71 @@ class PlatformBridge {
       'client_secret': clientSecret,
     });
   }
+
+  /// Pre-warm track ID cache for album/playlist tracks
+  /// This runs in background and returns immediately
+  /// Speeds up subsequent downloads by caching ISRC → Track ID mappings
+  static Future<void> preWarmTrackCache(List<Map<String, String>> tracks) async {
+    final tracksJson = jsonEncode(tracks);
+    await _channel.invokeMethod('preWarmTrackCache', {'tracks': tracksJson});
+  }
+
+  /// Get current track cache size
+  static Future<int> getTrackCacheSize() async {
+    final result = await _channel.invokeMethod('getTrackCacheSize');
+    return result as int;
+  }
+
+  /// Clear track ID cache
+  static Future<void> clearTrackCache() async {
+    await _channel.invokeMethod('clearTrackCache');
+  }
+
+  // ==================== DEEZER API ====================
+
+  /// Search Deezer for tracks and artists (no API key required)
+  static Future<Map<String, dynamic>> searchDeezerAll(String query, {int trackLimit = 15, int artistLimit = 3}) async {
+    final result = await _channel.invokeMethod('searchDeezerAll', {
+      'query': query,
+      'track_limit': trackLimit,
+      'artist_limit': artistLimit,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Get Deezer metadata by type and ID
+  static Future<Map<String, dynamic>> getDeezerMetadata(String resourceType, String resourceId) async {
+    final result = await _channel.invokeMethod('getDeezerMetadata', {
+      'resource_type': resourceType,
+      'resource_id': resourceId,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Parse Deezer URL and return type and ID
+  static Future<Map<String, dynamic>> parseDeezerUrl(String url) async {
+    final result = await _channel.invokeMethod('parseDeezerUrl', {'url': url});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Search Deezer by ISRC
+  static Future<Map<String, dynamic>> searchDeezerByISRC(String isrc) async {
+    final result = await _channel.invokeMethod('searchDeezerByISRC', {'isrc': isrc});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Convert Spotify track to Deezer and get metadata (for rate limit fallback)
+  static Future<Map<String, dynamic>> convertSpotifyToDeezer(String resourceType, String spotifyId) async {
+    final result = await _channel.invokeMethod('convertSpotifyToDeezer', {
+      'resource_type': resourceType,
+      'spotify_id': spotifyId,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Get Spotify metadata with automatic Deezer fallback on rate limit
+  static Future<Map<String, dynamic>> getSpotifyMetadataWithFallback(String url) async {
+    final result = await _channel.invokeMethod('getSpotifyMetadataWithFallback', {'url': url});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
 }

lib/services/update_checker.dart

@@ -12,6 +12,7 @@ class UpdateInfo {
   final String downloadUrl;
   final String? apkDownloadUrl;
   final DateTime publishedAt;
+  final bool isPrerelease;
 
   const UpdateInfo({
     required this.version,
@@ -19,11 +20,13 @@ class UpdateInfo {
     required this.downloadUrl,
     this.apkDownloadUrl,
     required this.publishedAt,
+    this.isPrerelease = false,
   });
 }
 
 class UpdateChecker {
-  static const String _apiUrl = 'https://api.github.com/repos/${AppInfo.githubRepo}/releases/latest';
+  static const String _latestApiUrl = 'https://api.github.com/repos/${AppInfo.githubRepo}/releases/latest';
+  static const String _allReleasesApiUrl = 'https://api.github.com/repos/${AppInfo.githubRepo}/releases';
 
   static Future<String> _getDeviceArch() async {
     if (!Platform.isAndroid) return 'unknown';
@@ -55,30 +58,59 @@ class UpdateChecker {
     }
   }
 
-  static Future<UpdateInfo?> checkForUpdate() async {
+  /// Check for updates based on channel preference
+  /// [channel] can be 'stable' or 'preview'
+  static Future<UpdateInfo?> checkForUpdate({String channel = 'stable'}) async {
     try {
-      final response = await http.get(
-        Uri.parse(_apiUrl),
-        headers: {'Accept': 'application/vnd.github.v3+json'},
-      ).timeout(const Duration(seconds: 10));
+      Map<String, dynamic>? releaseData;
+      
+      if (channel == 'preview') {
+        // For preview channel, get all releases and find the latest (including prereleases)
+        final response = await http.get(
+          Uri.parse('$_allReleasesApiUrl?per_page=10'),
+          headers: {'Accept': 'application/vnd.github.v3+json'},
+        ).timeout(const Duration(seconds: 10));
 
-      if (response.statusCode != 200) {
-        _log.w('GitHub API returned ${response.statusCode}');
-        return null;
+        if (response.statusCode != 200) {
+          _log.w('GitHub API returned ${response.statusCode}');
+          return null;
+        }
+
+        final releases = jsonDecode(response.body) as List<dynamic>;
+        if (releases.isEmpty) {
+          _log.i('No releases found');
+          return null;
+        }
+        
+        // First release is the latest (including prereleases)
+        releaseData = releases.first as Map<String, dynamic>;
+      } else {
+        // For stable channel, use /latest endpoint (excludes prereleases)
+        final response = await http.get(
+          Uri.parse(_latestApiUrl),
+          headers: {'Accept': 'application/vnd.github.v3+json'},
+        ).timeout(const Duration(seconds: 10));
+
+        if (response.statusCode != 200) {
+          _log.w('GitHub API returned ${response.statusCode}');
+          return null;
+        }
+
+        releaseData = jsonDecode(response.body) as Map<String, dynamic>;
       }
 
-      final data = jsonDecode(response.body) as Map<String, dynamic>;
-      final tagName = data['tag_name'] as String? ?? '';
+      final tagName = releaseData['tag_name'] as String? ?? '';
       final latestVersion = tagName.replaceFirst('v', '');
+      final isPrerelease = releaseData['prerelease'] as bool? ?? false;
       
       if (!_isNewerVersion(latestVersion, AppInfo.version)) {
-        _log.i('No update available (current: ${AppInfo.version}, latest: $latestVersion)');
+        _log.i('No update available (current: ${AppInfo.version}, latest: $latestVersion, channel: $channel)');
         return null;
       }
 
-      final body = data['body'] as String? ?? 'No changelog available';
-      final htmlUrl = data['html_url'] as String? ?? '${AppInfo.githubUrl}/releases';
-      final publishedAt = DateTime.tryParse(data['published_at'] as String? ?? '') ?? DateTime.now();
+      final body = releaseData['body'] as String? ?? 'No changelog available';
+      final htmlUrl = releaseData['html_url'] as String? ?? '${AppInfo.githubUrl}/releases';
+      final publishedAt = DateTime.tryParse(releaseData['published_at'] as String? ?? '') ?? DateTime.now();
 
       final deviceArch = await _getDeviceArch();
       _log.d('Device architecture: $deviceArch');
@@ -87,7 +119,7 @@ class UpdateChecker {
       String? arm32Url;
       String? universalUrl;
       
-      final assets = data['assets'] as List<dynamic>? ?? [];
+      final assets = releaseData['assets'] as List<dynamic>? ?? [];
       for (final asset in assets) {
         final name = (asset['name'] as String? ?? '').toLowerCase();
         if (name.endsWith('.apk')) {
@@ -117,7 +149,7 @@ class UpdateChecker {
         apkUrl = universalUrl ?? arm64Url ?? arm32Url;
       }
 
-      _log.i('Update available: $latestVersion, APK URL: $apkUrl');
+      _log.i('Update available: $latestVersion (prerelease: $isPrerelease), APK URL: $apkUrl');
       
       return UpdateInfo(
         version: latestVersion,
@@ -125,6 +157,7 @@ class UpdateChecker {
         downloadUrl: htmlUrl,
         apkDownloadUrl: apkUrl,
         publishedAt: publishedAt,
+        isPrerelease: isPrerelease,
       );
     } catch (e) {
       _log.e('Error checking for updates: $e');

lib/theme/app_theme.dart

@@ -43,6 +43,7 @@ class AppTheme {
   static ThemeData dark({
     ColorScheme? dynamicScheme,
     Color? seedColor,
+    bool isAmoled = false,
   }) {
     final scheme = dynamicScheme ??
         ColorScheme.fromSeed(
@@ -53,7 +54,8 @@ class AppTheme {
     return ThemeData(
       useMaterial3: true,
       colorScheme: scheme,
-      appBarTheme: _appBarTheme(scheme),
+      scaffoldBackgroundColor: isAmoled ? Colors.black : null,
+      appBarTheme: _appBarTheme(scheme, isAmoled: isAmoled),
       cardTheme: _cardTheme(scheme),
       elevatedButtonTheme: _elevatedButtonTheme(scheme),
       filledButtonTheme: _filledButtonTheme(scheme),
@@ -63,7 +65,7 @@ class AppTheme {
       inputDecorationTheme: _inputDecorationTheme(scheme),
       listTileTheme: _listTileTheme(scheme),
       dialogTheme: _dialogTheme(scheme),
-      navigationBarTheme: _navigationBarTheme(scheme),
+      navigationBarTheme: _navigationBarTheme(scheme, isAmoled: isAmoled),
       snackBarTheme: _snackBarTheme(scheme),
       progressIndicatorTheme: _progressIndicatorTheme(scheme),
       switchTheme: _switchTheme(scheme),
@@ -73,12 +75,12 @@ class AppTheme {
   }
 
   /// AppBar theme
-  static AppBarTheme _appBarTheme(ColorScheme scheme) => AppBarTheme(
+  static AppBarTheme _appBarTheme(ColorScheme scheme, {bool isAmoled = false}) => AppBarTheme(
         elevation: 0,
-        scrolledUnderElevation: 3,
-        backgroundColor: scheme.surface,
+        scrolledUnderElevation: isAmoled ? 0 : 3,
+        backgroundColor: isAmoled ? Colors.black : scheme.surface,
         foregroundColor: scheme.onSurface,
-        surfaceTintColor: scheme.surfaceTint,
+        surfaceTintColor: isAmoled ? Colors.transparent : scheme.surfaceTint,
         centerTitle: true,
         titleTextStyle: TextStyle(
           color: scheme.onSurface,
@@ -180,12 +182,12 @@ class AppTheme {
       );
 
   /// Navigation bar theme
-  static NavigationBarThemeData _navigationBarTheme(ColorScheme scheme) =>
+  static NavigationBarThemeData _navigationBarTheme(ColorScheme scheme, {bool isAmoled = false}) =>
       NavigationBarThemeData(
         elevation: 0,
-        backgroundColor: scheme.surfaceContainer,
+        backgroundColor: isAmoled ? Colors.black : scheme.surfaceContainer,
         indicatorColor: scheme.secondaryContainer,
-        surfaceTintColor: scheme.surfaceTint,
+        surfaceTintColor: isAmoled ? Colors.transparent : scheme.surfaceTint,
         labelBehavior: NavigationDestinationLabelBehavior.alwaysShow,
       );
 

lib/theme/dynamic_color_wrapper.dart

@@ -40,12 +40,32 @@ class DynamicColorWrapper extends ConsumerWidget {
           );
         }
 
+        // Apply AMOLED mode if enabled (pure black background)
+        if (themeSettings.useAmoled) {
+          darkScheme = _applyAmoledColors(darkScheme);
+        }
+
         // Build themes
         final lightTheme = AppTheme.light(dynamicScheme: lightScheme);
-        final darkTheme = AppTheme.dark(dynamicScheme: darkScheme);
+        final darkTheme = AppTheme.dark(dynamicScheme: darkScheme, isAmoled: themeSettings.useAmoled);
 
         return builder(lightTheme, darkTheme, themeSettings.themeMode);
       },
     );
   }
+
+  /// Apply AMOLED colors - pure black background with adjusted surface colors
+  ColorScheme _applyAmoledColors(ColorScheme scheme) {
+    return scheme.copyWith(
+      surface: Colors.black,
+      onSurface: Colors.white,
+      surfaceContainerLowest: Colors.black,
+      surfaceContainerLow: const Color(0xFF0A0A0A),
+      surfaceContainer: const Color(0xFF121212),
+      surfaceContainerHigh: const Color(0xFF1A1A1A),
+      surfaceContainerHighest: const Color(0xFF222222),
+      inverseSurface: Colors.white,
+      onInverseSurface: Colors.black,
+    );
+  }
 }

pubspec.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: 'none'
-version: 2.0.7+37
+version: 2.1.6+44
 
 environment:
   sdk: ^3.10.0

pubspec_ios.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: 'none'
-version: 2.0.7+37
+version: 2.1.6+44
 
 environment:
   sdk: ^3.10.0