fix(downloads): resolve format mismatch errors and improve playback

- Use downloadUri directly for playback instead of ExoPlayer downloadCache
  to prevent format mismatch errors (MatroskaExtractor parsing M4A data)
- Check targetItag before cache in DownloadUtil to respect user format selection
- Clear playerCache when specific format requested to ensure fresh fetch
- Fix URL cache expiry check (was using wrong comparison operator)
- Reorder ExtractorsFactory: FragmentedMp4Extractor first for M4A files
- Add detailed logging for download and cache resolution debugging

Author: alltechdev

app/src/main/kotlin/com/metrolist/music/playback/DownloadUtil.kt

@@ -129,17 +129,40 @@ constructor(
             val mediaId = dataSpec.key ?: error("No media id")
             val length = if (dataSpec.length >= 0) dataSpec.length else 1
 
-            if (playerCache.isCached(mediaId, dataSpec.position, length)) {
-                return@Factory dataSpec
-            }
+            // Check if user selected a specific format for this download
+            // IMPORTANT: Check targetItag FIRST - if set, we must bypass cache to get that specific format
+            val targetItag = targetItagOverride[mediaId] ?: 0
+            val hasTargetItag = targetItag > 0
+            timber.log.Timber.tag("DownloadUtil").d("Download resolver for $mediaId, targetItag=${if (hasTargetItag) targetItag else "auto"}")
 
-            songUrlCache[mediaId]?.takeIf { it.second < System.currentTimeMillis() }?.let {
-                return@Factory dataSpec.withUri(it.first.toUri())
+            // Only use cache if no specific format was requested
+            if (!hasTargetItag) {
+                if (playerCache.isCached(mediaId, dataSpec.position, length)) {
+                    timber.log.Timber.tag("DownloadUtil").d("Using player cache for $mediaId")
+                    return@Factory dataSpec
+                }
+
+                // Fixed: use > for "not expired" (was < which meant "use if expired")
+                songUrlCache[mediaId]?.takeIf { it.second > System.currentTimeMillis() }?.let {
+                    timber.log.Timber.tag("DownloadUtil").d("Using URL cache for $mediaId")
+                    return@Factory dataSpec.withUri(it.first.toUri())
+                }
+            } else {
+                // Clear caches when specific format requested to ensure fresh fetch
+                timber.log.Timber.tag("DownloadUtil").d("Bypassing cache for $mediaId - specific format requested (itag=$targetItag)")
+                songUrlCache.remove(mediaId)
+                // Also clear playerCache for this media to prevent format mismatch
+                runBlocking(Dispatchers.IO) {
+                    try {
+                        if (playerCache.getCachedSpans(mediaId).isNotEmpty()) {
+                            playerCache.removeResource(mediaId)
+                            timber.log.Timber.tag("DownloadUtil").d("Cleared player cache for $mediaId")
+                        }
+                    } catch (_: Exception) {}
+                }
             }
 
-            // Check if user selected a specific format for this download
-            val targetItag = targetItagOverride[mediaId] ?: 0
-            timber.log.Timber.tag("DownloadUtil").d("Fetching stream for $mediaId, targetItag=${if (targetItag > 0) targetItag else "auto"}")
+            timber.log.Timber.tag("DownloadUtil").d("Fetching fresh stream for $mediaId, targetItag=${if (hasTargetItag) targetItag else "auto"}")
 
             val playbackData = runBlocking(Dispatchers.IO) {
                 YTPlayerUtils.playerResponseForPlayback(
@@ -150,6 +173,9 @@ constructor(
                 )
             }.getOrThrow()
             val format = playbackData.format
+            timber.log.Timber.tag("DownloadUtil").i(
+                "Download stream for $mediaId: itag=${format.itag}, mimeType=${format.mimeType.split(";")[0]}, bitrate=${format.bitrate/1000}kbps"
+            )
 
             database.query {
                 upsert(

app/src/main/kotlin/com/metrolist/music/playback/MusicService.kt

@@ -2627,19 +2627,32 @@ class MusicService :
             // Check if we need to bypass cache for quality change
             val shouldBypassCache = bypassCacheForQualityChange.contains(mediaId)
 
+            // ZEMER APPROACH: Check for downloaded file URI first (local playback)
+            // Only use local file if starting from beginning (position 0) to avoid
+            // switching sources mid-stream when a download completes during playback
             if (!shouldBypassCache) {
-                if (downloadCache.isCached(
-                        mediaId,
-                        dataSpec.position,
-                        if (dataSpec.length >= 0) dataSpec.length else 1
-                    ) ||
-                    playerCache.isCached(mediaId, dataSpec.position, CHUNK_LENGTH)
-                ) {
+                val song = runBlocking(Dispatchers.IO) {
+                    database.song(mediaId).first()
+                }
+
+                // Use downloaded file directly if available (bypasses ExoPlayer cache entirely)
+                if (song?.song?.downloadUri != null && dataSpec.position == 0L) {
+                    Timber.tag("CacheResolver").d("Using downloaded file for $mediaId: ${song.song.downloadUri}")
+                    scope.launch(Dispatchers.IO) { recoverSong(mediaId) }
+                    return@Factory dataSpec.withUri(song.song.downloadUri.toUri())
+                }
+
+                // Check player cache (streaming buffer) - NOT download cache
+                // Download cache can have format mismatches, use downloadUri instead
+                if (playerCache.isCached(mediaId, dataSpec.position, CHUNK_LENGTH)) {
+                    Timber.tag("CacheResolver").d("Using player cache for $mediaId at pos=${dataSpec.position}")
                     scope.launch(Dispatchers.IO) { recoverSong(mediaId) }
                     return@Factory dataSpec
                 }
 
+                // Check URL cache
                 songUrlCache[mediaId]?.takeIf { it.second > System.currentTimeMillis() }?.let {
+                    Timber.tag("CacheResolver").d("Using URL cache for $mediaId")
                     scope.launch(Dispatchers.IO) { recoverSong(mediaId) }
                     return@Factory dataSpec.withUri(it.first.toUri())
                 }
@@ -2731,7 +2744,9 @@ class MusicService :
         DefaultMediaSourceFactory(
             createDataSourceFactory(),
             ExtractorsFactory {
-                arrayOf(MatroskaExtractor(), FragmentedMp4Extractor())
+                // FragmentedMp4Extractor first for M4A downloads, MatroskaExtractor for WebM/OPUS streams
+                // Order matters: ExoPlayer tries extractors in order until sniff() succeeds
+                arrayOf(FragmentedMp4Extractor(), MatroskaExtractor())
             },
         )