use md5::{Digest, Md5};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::album::Album;
use super::artist::Artist;
use super::landing::Chart;
use super::{ContentRestrictions, CoverDerivedColors, Id};
use crate::error::{Error, Result};
use crate::transport::Transport;
const SIGN_SALT: &str = "XGRlBW9FXlekgbPrRHuSiA";
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Major {
pub id: Option<i64>,
pub name: Option<String>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Normalization {
pub gain: Option<f64>,
pub peak: Option<f64>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PoetryLoverMatch {
pub begin: Option<i64>,
pub end: Option<i64>,
pub line: Option<i64>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct LyricsInfo {
pub has_available_sync_lyrics: Option<bool>,
pub has_available_text_lyrics: Option<bool>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Fade {
pub in_start: Option<f64>,
pub in_stop: Option<f64>,
pub out_start: Option<f64>,
pub out_stop: Option<f64>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct SmartPreviewParams {
pub duration_ms: Option<i64>,
pub fade: Option<Fade>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MetaData {
pub album: Option<String>,
pub volume: Option<i64>,
pub year: Option<i64>,
pub number: Option<i64>,
pub genre: Option<String>,
pub lyricist: Option<String>,
pub version: Option<String>,
pub composer: Option<String>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct R128 {
pub i: Option<f64>,
pub tp: Option<f64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct LyricsMajor {
pub id: Option<i64>,
pub name: Option<String>,
pub pretty_name: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Track {
pub id: Option<Id>,
pub title: Option<String>,
pub available: Option<bool>,
pub artists: Vec<Artist>,
pub albums: Vec<Album>,
pub available_for_premium_users: Option<bool>,
pub lyrics_available: Option<bool>,
pub poetry_lover_matches: Vec<PoetryLoverMatch>,
pub best: Option<bool>,
pub real_id: Option<Id>,
pub og_image: Option<String>,
pub r#type: Option<String>,
pub cover_uri: Option<String>,
pub major: Option<Major>,
pub duration_ms: Option<i64>,
pub storage_dir: Option<String>,
pub file_size: Option<i64>,
pub substituted: Option<Box<Track>>,
pub matched_track: Option<Box<Track>>,
pub normalization: Option<Normalization>,
pub error: Option<String>,
pub can_publish: Option<bool>,
pub state: Option<String>,
pub desired_visibility: Option<String>,
pub filename: Option<String>,
pub meta_data: Option<MetaData>,
pub regions: Vec<String>,
pub available_as_rbt: Option<bool>,
pub content_warning: Option<String>,
pub explicit: Option<bool>,
pub preview_duration_ms: Option<i64>,
pub available_full_without_permission: Option<bool>,
pub version: Option<String>,
pub remember_position: Option<bool>,
pub background_video_uri: Option<String>,
pub short_description: Option<String>,
pub is_suitable_for_children: Option<bool>,
pub track_source: Option<String>,
pub available_for_options: Vec<String>,
pub lyrics_info: Option<LyricsInfo>,
pub track_sharing_flag: Option<String>,
pub derived_colors: Option<CoverDerivedColors>,
pub fade: Option<Fade>,
pub smart_preview_params: Option<SmartPreviewParams>,
pub special_audio_resources: Vec<String>,
pub disclaimers: Vec<String>,
pub background_video_id: Option<String>,
pub player_id: Option<String>,
pub r128: Option<R128>,
pub podcast_episode_type: Option<String>,
pub pub_date: Option<String>,
pub chart: Option<Chart>,
pub content_restrictions: Option<ContentRestrictions>,
}
impl Track {
pub fn numeric_id(&self) -> Result<i64> {
self.id
.as_ref()
.and_then(Id::as_number)
.ok_or(Error::IdMissing("track id"))
}
#[must_use]
pub fn artists_name(&self) -> String {
self.artists
.iter()
.filter_map(|a| a.name.as_deref())
.collect::<Vec<_>>()
.join(", ")
}
#[must_use]
pub fn cover_url(&self, size: &str) -> Option<String> {
self.cover_uri
.as_deref()
.map(|uri| super::normalize_image_url(uri, size))
}
#[must_use]
pub fn album(&self) -> Option<&Album> {
self.albums.first()
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackShort {
pub id: Option<Id>,
pub timestamp: Option<String>,
pub album_id: Option<String>,
pub play_count: Option<i64>,
pub recent: Option<bool>,
pub chart: Option<Value>,
pub track: Option<Track>,
pub original_index: Option<i64>,
pub original_shuffle_index: Option<i64>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackId {
pub id: Option<i64>,
pub track_id: Option<i64>,
pub album_id: Option<i64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct DownloadInfo {
pub codec: Option<String>,
pub bitrate_in_kbps: Option<i64>,
pub gain: Option<bool>,
pub preview: Option<bool>,
pub download_info_url: Option<String>,
pub direct: Option<bool>,
}
impl DownloadInfo {
pub async fn direct_link(&self, transport: &Transport) -> Result<String> {
let info_url = self
.download_info_url
.as_deref()
.ok_or(Error::IdMissing("downloadInfoUrl"))?;
let xml = transport.retrieve_text(info_url).await?;
build_direct_link(&xml)
}
}
fn build_direct_link(xml: &str) -> Result<String> {
let tag = |name: &str| -> Option<&str> {
let open = format!("<{name}>");
let close = format!("</{name}>");
let start = xml.find(&open)? + open.len();
let end = xml[start..].find(&close)? + start;
Some(&xml[start..end])
};
let (Some(host), Some(path), Some(ts), Some(s)) =
(tag("host"), tag("path"), tag("ts"), tag("s"))
else {
return Err(Error::InvalidResponse(
"download-info xml is missing host/path/ts/s".into(),
));
};
let mut hasher = Md5::new();
hasher.update(SIGN_SALT.as_bytes());
hasher.update(path.strip_prefix('/').unwrap_or(path).as_bytes());
hasher.update(s.as_bytes());
let sign = hex::encode(hasher.finalize());
Ok(format!("https://{host}/get-mp3/{sign}/{ts}{path}"))
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct LosslessDownloadInfo {
pub track_id: Option<String>,
pub quality: Option<String>,
pub codec: Option<String>,
pub bitrate: Option<i64>,
pub transport: Option<String>,
pub key: Option<String>,
pub urls: Vec<String>,
pub url: Option<String>,
pub size: Option<i64>,
pub gain: Option<bool>,
pub real_id: Option<String>,
}
impl LosslessDownloadInfo {
#[must_use]
pub fn is_lossless(&self) -> bool {
matches!(self.codec.as_deref(), Some("flac" | "flac-mp4"))
}
#[must_use]
pub fn is_encrypted(&self) -> bool {
self.key.is_some()
}
#[must_use]
pub fn links(&self) -> Vec<String> {
let mut seen = Vec::new();
for url in self.urls.iter().chain(self.url.as_ref()) {
if !url.is_empty() && !seen.contains(url) {
seen.push(url.clone());
}
}
seen
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackLyrics {
pub download_url: Option<String>,
pub lyric_id: Option<i64>,
pub external_lyric_id: Option<String>,
pub writers: Vec<String>,
pub major: Option<LyricsMajor>,
}
impl TrackLyrics {
pub async fn text(&self, transport: &Transport) -> Result<String> {
let url = self
.download_url
.as_deref()
.ok_or(Error::IdMissing("lyrics downloadUrl"))?;
transport.retrieve_text(url).await
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct SimilarTracks {
pub track: Option<Track>,
pub similar_tracks: Vec<Track>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackFullInfo {
pub track: Option<Track>,
pub similar_tracks: Vec<Track>,
pub also_in_albums: Vec<Track>,
pub aliases: Vec<String>,
pub artists: Vec<Artist>,
pub other_versions: std::collections::HashMap<String, Vec<Track>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackTrailer {
pub title: Option<String>,
pub track: Option<Track>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_direct_link_is_built_from_the_info_xml() {
let xml = r#"<?xml version="1.0" encoding="utf-8"?><download-info>
<host>storage.mds.yandex.net</host>
<path>/get-mp3/abc/1.mp3</path>
<ts>0005f2</ts>
<region>225</region>
<s>deadbeef</s>
</download-info>"#;
let link = build_direct_link(xml).unwrap();
let mut hasher = Md5::new();
hasher.update(SIGN_SALT.as_bytes());
hasher.update(b"get-mp3/abc/1.mp3");
hasher.update(b"deadbeef");
let expected = hex::encode(hasher.finalize());
assert_eq!(
link,
format!("https://storage.mds.yandex.net/get-mp3/{expected}/0005f2/get-mp3/abc/1.mp3")
);
}
#[test]
fn an_incomplete_xml_is_rejected() {
assert!(build_direct_link("<download-info><host>h</host></download-info>").is_err());
assert!(build_direct_link("not xml").is_err());
assert!(build_direct_link("").is_err());
}
#[test]
fn lossless_detection_covers_both_flac_codecs() {
let flac = LosslessDownloadInfo {
codec: Some("flac".into()),
..Default::default()
};
let flac_mp4 = LosslessDownloadInfo {
codec: Some("flac-mp4".into()),
..Default::default()
};
let aac = LosslessDownloadInfo {
codec: Some("aac".into()),
..Default::default()
};
assert!(flac.is_lossless());
assert!(flac_mp4.is_lossless());
assert!(!aac.is_lossless());
assert!(!LosslessDownloadInfo::default().is_lossless());
}
#[test]
fn links_merge_both_url_shapes_and_deduplicate() {
let info = LosslessDownloadInfo {
urls: vec!["https://a".into(), "https://b".into(), "https://a".into()],
url: Some("https://b".into()),
..Default::default()
};
assert_eq!(
info.links(),
vec!["https://a".to_string(), "https://b".to_string()]
);
let only_single = LosslessDownloadInfo {
url: Some("https://c".into()),
..Default::default()
};
assert_eq!(only_single.links(), vec!["https://c".to_string()]);
assert!(LosslessDownloadInfo::default().links().is_empty());
}
#[test]
fn encryption_is_flagged_by_the_presence_of_a_key() {
assert!(!LosslessDownloadInfo::default().is_encrypted());
let encrypted = LosslessDownloadInfo {
key: Some("ab".into()),
..Default::default()
};
assert!(encrypted.is_encrypted());
}
#[test]
fn tracks_accept_both_id_shapes_and_normalize_them() {
let numeric: Track = serde_json::from_str(r#"{"id":42}"#).unwrap();
let compound: Track = serde_json::from_str(r#"{"id":"42:1001"}"#).unwrap();
assert_eq!(numeric.numeric_id().unwrap(), 42);
assert_eq!(compound.numeric_id().unwrap(), 42);
assert!(Track::default().numeric_id().is_err());
}
#[test]
fn artist_names_join_for_display() {
let track: Track =
serde_json::from_str(r#"{"artists":[{"name":"A"},{"name":"B"},{}]}"#).unwrap();
assert_eq!(track.artists_name(), "A, B");
assert_eq!(Track::default().artists_name(), "");
}
#[test]
fn cover_urls_resolve_the_size_placeholder() {
let track: Track =
serde_json::from_str(r#"{"coverUri":"avatars.yandex.net/get-music/1/%%"}"#).unwrap();
assert_eq!(
track.cover_url("200x200").as_deref(),
Some("https://avatars.yandex.net/get-music/1/200x200")
);
assert!(Track::default().cover_url("200x200").is_none());
}
#[test]
fn a_substituted_track_nests_without_blowing_the_stack() {
let track: Track =
serde_json::from_str(r#"{"id":1,"substituted":{"id":2,"title":"other"}}"#).unwrap();
let substituted = track.substituted.as_ref().unwrap();
assert_eq!(substituted.title.as_deref(), Some("other"));
}
#[test]
fn other_versions_deserialize_as_a_keyed_map() {
let info: TrackFullInfo = serde_json::from_str(
r#"{"track":{"id":1},"otherVersions":{"live":[{"id":2}],"remix":[{"id":3},{"id":4}]}}"#,
)
.unwrap();
assert_eq!(info.other_versions["live"].len(), 1);
assert_eq!(info.other_versions["remix"].len(), 2);
}
#[test]
fn track_models_survive_an_empty_object() {
serde_json::from_str::<Track>("{}").unwrap();
serde_json::from_str::<TrackShort>("{}").unwrap();
serde_json::from_str::<TrackId>("{}").unwrap();
serde_json::from_str::<DownloadInfo>("{}").unwrap();
serde_json::from_str::<LosslessDownloadInfo>("{}").unwrap();
serde_json::from_str::<TrackLyrics>("{}").unwrap();
serde_json::from_str::<SimilarTracks>("{}").unwrap();
serde_json::from_str::<TrackFullInfo>("{}").unwrap();
serde_json::from_str::<TrackTrailer>("{}").unwrap();
}
}