use serde_json::Value;
use crate::client::Client;
use crate::error::{Error, Result};
use crate::models::{
DownloadInfo, LosslessDownloadInfo, ShotEvent, SimilarTracks, Supplement, Track, TrackFullInfo,
TrackLyrics, TrackTrailer,
};
use crate::params::Params;
use crate::sign::{
FILE_INFO_CODECS, FILE_INFO_TRANSPORT, sign_file_info, sign_track, track_id_to_number,
};
use crate::types::{BatchObject, LyricsFormat};
#[derive(Debug, Clone, Default)]
pub struct PlayAudioReport {
pub track_id: i64,
pub album_id: i64,
pub from: String,
pub playlist_id: Option<String>,
pub from_cache: bool,
pub play_id: Option<String>,
pub uid: Option<i64>,
pub timestamp: Option<String>,
pub track_length_seconds: u64,
pub total_played_seconds: u64,
pub end_position_seconds: u64,
pub client_now: Option<String>,
}
impl PlayAudioReport {
#[must_use]
pub fn new(track_id: i64, album_id: i64, from: impl Into<String>) -> Self {
Self {
track_id,
album_id,
from: from.into(),
..Self::default()
}
}
}
impl Client {
pub async fn tracks(
&self,
track_ids: impl IntoIterator<Item = impl std::fmt::Display>,
) -> Result<Vec<Track>> {
self.tracks_with_positions(track_ids, true).await
}
pub async fn tracks_with_positions(
&self,
track_ids: impl IntoIterator<Item = impl std::fmt::Display>,
with_positions: bool,
) -> Result<Vec<Track>> {
let extra = Params::new().add("with-positions", with_positions);
self.get_batch(BatchObject::Track, track_ids, extra).await
}
pub async fn track(&self, track_id: impl std::fmt::Display) -> Result<Option<Track>> {
Ok(self.tracks([track_id]).await?.into_iter().next())
}
pub async fn track_download_info(
&self,
track_id: impl std::fmt::Display,
) -> Result<Vec<DownloadInfo>> {
self.get(&format!("/tracks/{track_id}/download-info"), Params::new())
.await
}
pub async fn track_lossless_info(
&self,
track_id: impl std::fmt::Display,
quality: &str,
) -> Result<LosslessDownloadInfo> {
let id = track_id_to_number(&track_id.to_string())
.ok_or(Error::IdMissing("numeric track id"))?;
let sign = sign_file_info(id, quality);
let params = Params::new()
.add("ts", sign.ts)
.add("trackId", id)
.add("quality", quality)
.add("codecs", FILE_INFO_CODECS)
.add("transports", FILE_INFO_TRANSPORT)
.add("sign", sign.value);
let value = self.get_value("/get-file-info", params).await?;
let info = value.get("downloadInfo").cloned().unwrap_or(Value::Null);
self.decode(info)
}
pub async fn track_lyrics(
&self,
track_id: impl std::fmt::Display,
format: LyricsFormat,
) -> Result<TrackLyrics> {
let display = track_id.to_string();
let id = track_id_to_number(&display).ok_or(Error::IdMissing("numeric track id"))?;
let sign = sign_track(id);
let params = Params::new()
.add("format", format)
.add("timeStamp", sign.timestamp)
.add("sign", sign.value);
self.get(&format!("/tracks/{id}/lyrics"), params).await
}
pub async fn track_similar(&self, track_id: impl std::fmt::Display) -> Result<SimilarTracks> {
self.get(&format!("/tracks/{track_id}/similar"), Params::new())
.await
}
pub async fn track_full_info(&self, track_id: impl std::fmt::Display) -> Result<TrackFullInfo> {
self.get(&format!("/tracks/{track_id}/full-info"), Params::new())
.await
}
pub async fn track_trailer(&self, track_id: impl std::fmt::Display) -> Result<TrackTrailer> {
self.get(&format!("/tracks/{track_id}/trailer"), Params::new())
.await
}
pub async fn track_supplement(&self, track_id: impl std::fmt::Display) -> Result<Supplement> {
self.get(&format!("/tracks/{track_id}/supplement"), Params::new())
.await
}
pub async fn play_audio(&self, report: &PlayAudioReport) -> Result<bool> {
let now = || iso_now();
let uid = report.uid.or_else(|| self.account_uid());
let form = Params::new()
.add("track-id", report.track_id)
.add("from-cache", report.from_cache)
.add("from", &report.from)
.add("play-id", report.play_id.as_deref().unwrap_or(""))
.add("uid", uid.map(|u| u.to_string()).unwrap_or_default())
.add("timestamp", report.timestamp.clone().unwrap_or_else(now))
.add("track-length-seconds", report.track_length_seconds)
.add("total-played-seconds", report.total_played_seconds)
.add("end-position-seconds", report.end_position_seconds)
.add("album-id", report.album_id)
.add("playlist-id", report.playlist_id.as_deref().unwrap_or(""))
.add("client-now", report.client_now.clone().unwrap_or_else(now));
let value = self.post_form_value("/play-audio", form).await?;
Ok(Client::is_ok_response(&value))
}
pub async fn after_track(
&self,
next_track_id: impl std::fmt::Display,
context_item: &str,
prev_track_id: Option<i64>,
) -> Result<ShotEvent> {
let params = Params::new()
.add("from", "mobile-landing-origin-default")
.maybe("prevTrackId", prev_track_id)
.add("nextTrackId", next_track_id)
.add("context", "playlist")
.add("contextItem", context_item)
.add("types", "shot");
let value = self.get_value("/after-track", params).await?;
let event = value.get("shotEvent").cloned().unwrap_or(Value::Null);
self.decode(event)
}
}
fn iso_now() -> String {
let secs = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_secs());
let days = secs / 86_400;
let time_of_day = secs % 86_400;
let (hour, minute, second) = (
time_of_day / 3600,
(time_of_day % 3600) / 60,
time_of_day % 60,
);
let (year, month, day) = civil_from_days(i64::try_from(days).unwrap_or(0));
format!("{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}Z")
}
fn civil_from_days(days: i64) -> (i64, u32, u32) {
let z = days + 719_468;
let era = z.div_euclid(146_097);
let doe = z.rem_euclid(146_097);
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
let year = yoe + era * 400;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let day = u32::try_from(doy - (153 * mp + 2) / 5 + 1).unwrap_or(1);
let month = u32::try_from(if mp < 10 { mp + 3 } else { mp - 9 }).unwrap_or(1);
(if month <= 2 { year + 1 } else { year }, month, day)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_epoch_converts_to_its_known_date() {
assert_eq!(civil_from_days(0), (1970, 1, 1));
}
#[test]
fn leap_years_and_century_boundaries_convert_correctly() {
assert_eq!(civil_from_days(59), (1970, 3, 1));
assert_eq!(civil_from_days(11_016), (2000, 2, 29));
assert_eq!(civil_from_days(20_664), (2026, 7, 30));
}
#[test]
fn timestamps_render_in_the_shape_the_api_expects() {
let now = iso_now();
assert_eq!(now.len(), 20, "yyyy-mm-ddThh:mm:ssZ");
assert!(now.ends_with('Z'));
assert_eq!(now.as_bytes()[10], b'T');
assert_eq!(now.as_bytes()[4], b'-');
assert_eq!(now.as_bytes()[13], b':');
}
#[test]
fn a_play_report_starts_with_only_its_required_fields_set() {
let report = PlayAudioReport::new(42, 1001, "desktop_win");
assert_eq!(report.track_id, 42);
assert_eq!(report.album_id, 1001);
assert_eq!(report.from, "desktop_win");
assert!(!report.from_cache);
assert!(report.play_id.is_none());
assert_eq!(report.total_played_seconds, 0);
}
}