Upload 2 files

src/main.rs

@@ -297,16 +297,27 @@ async fn media_url_for_track(
     id: u64,
     formats: &Vec<Format>,
 ) -> Result<(String, String, u64), String> {
+    use std::io::Write;
+    let mut log_file = std::fs::OpenOptions::new().create(true).append(true).open("debug_dzmedia.log").unwrap();
+    let _ = writeln!(log_file, "--- NEW REQUEST FOR ID {} ---", id);
+
     if client.license_token.is_empty() {
         if let Err(e) = client.force_renew().await {
+            let _ = writeln!(log_file, "force_renew err: {}", e);
             return Err(format!("renew:{e}"));
         }
     }
 
     let q_json = serde_json::json!({"sng_ids":[id],"array_default":["SNG_ID","TRACK_TOKEN","FALLBACK"]});
-    let r: serde_json::Value = client.api_call("song.getListData", &q_json).await.map_err(|e| e.to_string())?;
+    let r: serde_json::Value = client.api_call("song.getListData", &q_json).await.map_err(|e| {
+        let _ = writeln!(log_file, "api_call err: {}", e);
+        e.to_string()
+    })?;
 
-    let item = r.pointer("/data/0").ok_or_else(|| "No valid ID".to_string())?;
+    let item = r.pointer("/data/0").ok_or_else(|| {
+        let _ = writeln!(log_file, "No valid ID");
+        "No valid ID".to_string()
+    })?;
 
     let track_token = item.get("TRACK_TOKEN").and_then(|v| v.as_str()).unwrap_or("").to_string();
     let fallback = item.get("FALLBACK");
@@ -320,19 +331,33 @@ async fn media_url_for_track(
         })
     }).unwrap_or(0);
 
+    let _ = writeln!(log_file, "track_token: {}, fallback_id: {}, fallback_token: {}", track_token, fallback_id, fallback_token);
+
     if fallback_id > 0 {
         let q_fb = serde_json::json!({"sng_ids":[fallback_id],"array_default":["SNG_ID","TRACK_TOKEN","FALLBACK"]});
+        let _ = writeln!(log_file, "Querying fallback ID: {}", fallback_id);
         if let Ok(r_fb) = client.api_call::<serde_json::Value, serde_json::Value>("song.getListData", &q_fb).await {
             if let Some(item_fb) = r_fb.pointer("/data/0") {
                 if let Some(real_tk) = item_fb.get("TRACK_TOKEN").and_then(|v| v.as_str()) {
+                    let _ = writeln!(log_file, "Fetched real_tk for fallback: {}", real_tk);
                     let tokens = vec![real_tk];
-                    if let Ok((url, fmt, _)) = fetch_media_url(client, formats, tokens).await {
-                        // Ensure we return the high quality one if found, else let it fall through? 
-                        // Wait, no. If it succeeds at all, we should just return it.
-                        return Ok((url, fmt, fallback_id));
+                    match fetch_media_url(client, formats, tokens).await {
+                        Ok((url, fmt, _)) => {
+                            let _ = writeln!(log_file, "fetch_media_url SUCCESS for fallback: fmt={}", fmt);
+                            return Ok((url, fmt, fallback_id));
+                        },
+                        Err(e) => {
+                            let _ = writeln!(log_file, "fetch_media_url FAILED for fallback: {}", e);
+                        }
                     }
+                } else {
+                    let _ = writeln!(log_file, "NO TRACK_TOKEN in fallback response");
                 }
+            } else {
+                let _ = writeln!(log_file, "Empty data array in fallback response");
             }
+        } else {
+            let _ = writeln!(log_file, "api_call for fallback ID FAILED");
         }
     }
 
@@ -349,12 +374,23 @@ async fn media_url_for_track(
     }
 
     if tokens.is_empty() {
+        let _ = writeln!(log_file, "empty TRACK_TOKEN and FALLBACK");
         return Err("empty TRACK_TOKEN and FALLBACK".to_string());
     }
 
-    let (url, fmt, idx) = fetch_media_url(client, formats, tokens).await?;
-    let id_to_use = *token_ids.get(idx).unwrap_or(&id);
-    Ok((url, fmt, id_to_use))
+    let _ = writeln!(log_file, "Falling back to old logic. Tokens: {:?}", tokens);
+    let res = fetch_media_url(client, formats, tokens).await;
+    match res {
+        Ok((url, fmt, idx)) => {
+            let _ = writeln!(log_file, "Old logic SUCCESS: fmt={}", fmt);
+            let id_to_use = *token_ids.get(idx).unwrap_or(&id);
+            Ok((url, fmt, id_to_use))
+        },
+        Err(e) => {
+            let _ = writeln!(log_file, "Old logic FAILED: {}", e);
+            Err(e)
+        }
+    }
 }
 
 fn upstream_bases() -> Vec<String> {
@@ -649,6 +685,7 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
         _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
     };
 
+
     let requested = q.format.clone().unwrap_or_else(|| "AUTO".to_string());
     let mut url: String  = String::new();
     let mut used: String = String::new();