use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::album::Album;
use super::artist::Artist;
use super::clip::Clip;
use super::playlist::Playlist;
use super::track::Track;
use super::user::User;
use super::video::Video;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct SearchResult<T> {
pub r#type: Option<String>,
pub total: Option<u32>,
pub per_page: Option<u32>,
pub order: Option<u32>,
pub results: Vec<T>,
}
impl<T> Default for SearchResult<T> {
fn default() -> Self {
Self {
r#type: None,
total: None,
per_page: None,
order: None,
results: Vec::new(),
}
}
}
impl<T> SearchResult<T> {
#[must_use]
pub fn has_more(&self, page: u32) -> bool {
match (self.total, self.per_page) {
(Some(total), Some(per_page)) if per_page > 0 => (page + 1) * per_page < total,
_ => false,
}
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum SearchEntity {
Track(Box<Track>),
Artist(Box<Artist>),
Album(Box<Album>),
Playlist(Box<Playlist>),
Video(Box<Video>),
User(Box<User>),
Clip(Box<Clip>),
Unknown(Value),
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Best {
pub r#type: Option<String>,
pub result: Option<Value>,
pub text: Option<String>,
}
impl Best {
#[must_use]
pub fn entity(&self) -> Option<SearchEntity> {
let raw = self.result.clone()?;
let typed = |value: Value| -> Option<SearchEntity> {
Some(match self.r#type.as_deref()? {
"track" => SearchEntity::Track(Box::new(serde_json::from_value(value).ok()?)),
"artist" => SearchEntity::Artist(Box::new(serde_json::from_value(value).ok()?)),
"album" | "podcast" => {
SearchEntity::Album(Box::new(serde_json::from_value(value).ok()?))
},
"playlist" => SearchEntity::Playlist(Box::new(serde_json::from_value(value).ok()?)),
"video" => SearchEntity::Video(Box::new(serde_json::from_value(value).ok()?)),
"user" => SearchEntity::User(Box::new(serde_json::from_value(value).ok()?)),
"clip" => SearchEntity::Clip(Box::new(serde_json::from_value(value).ok()?)),
_ => return None,
})
};
Some(typed(raw.clone()).unwrap_or(SearchEntity::Unknown(raw)))
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Suggestions {
pub best: Option<Best>,
pub suggestions: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Search {
pub search_request_id: Option<String>,
pub text: Option<String>,
pub best: Option<Best>,
pub albums: Option<SearchResult<Album>>,
pub artists: Option<SearchResult<Artist>>,
pub playlists: Option<SearchResult<Playlist>>,
pub tracks: Option<SearchResult<Track>>,
pub videos: Option<SearchResult<Video>>,
pub users: Option<SearchResult<User>>,
pub podcasts: Option<SearchResult<Album>>,
pub podcast_episodes: Option<SearchResult<Track>>,
pub clips: Option<SearchResult<Clip>>,
pub r#type: Option<String>,
pub page: Option<u32>,
pub per_page: Option<u32>,
pub misspell_result: Option<String>,
pub misspell_original: Option<String>,
pub misspell_corrected: Option<bool>,
pub nocorrect: Option<bool>,
}
impl Search {
#[must_use]
pub fn track_results(&self) -> &[Track] {
self.tracks
.as_ref()
.map_or(&[], |block| block.results.as_slice())
}
#[must_use]
pub fn correction(&self) -> Option<&str> {
if self.misspell_corrected == Some(true) {
self.misspell_result.as_deref()
} else {
None
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn best(json: &str) -> Best {
serde_json::from_str(json).unwrap()
}
#[test]
fn best_matches_resolve_by_their_type_tag() {
assert!(matches!(
best(r#"{"type":"track","result":{"id":1,"title":"T"}}"#).entity(),
Some(SearchEntity::Track(t)) if t.title.as_deref() == Some("T")
));
assert!(matches!(
best(r#"{"type":"artist","result":{"id":2}}"#).entity(),
Some(SearchEntity::Artist(_))
));
assert!(matches!(
best(r#"{"type":"album","result":{"id":3}}"#).entity(),
Some(SearchEntity::Album(_))
));
assert!(matches!(
best(r#"{"type":"playlist","result":{"kind":4}}"#).entity(),
Some(SearchEntity::Playlist(_))
));
assert!(matches!(
best(r#"{"type":"video","result":{"title":"V"}}"#).entity(),
Some(SearchEntity::Video(_))
));
assert!(matches!(
best(r#"{"type":"user","result":{"uid":5}}"#).entity(),
Some(SearchEntity::User(_))
));
assert!(matches!(
best(r#"{"type":"clip","result":{"clipId":6}}"#).entity(),
Some(SearchEntity::Clip(_))
));
}
#[test]
fn podcasts_resolve_as_albums_because_that_is_how_the_api_models_them() {
assert!(matches!(
best(r#"{"type":"podcast","result":{"id":7,"metaType":"podcast"}}"#).entity(),
Some(SearchEntity::Album(_))
));
}
#[test]
fn an_unknown_best_type_keeps_its_payload() {
match best(r#"{"type":"something-new","result":{"x":1}}"#).entity() {
Some(SearchEntity::Unknown(value)) => assert_eq!(value, serde_json::json!({"x": 1})),
other => panic!("expected Unknown, got {other:?}"),
}
}
#[test]
fn a_best_without_a_payload_resolves_to_nothing() {
assert!(best(r#"{"type":"track"}"#).entity().is_none());
assert!(best("{}").entity().is_none());
}
#[test]
fn a_full_search_response_deserializes() {
let search: Search = serde_json::from_str(
r#"{
"searchRequestId":"r1","text":"query","page":0,"perPage":20,
"best":{"type":"track","result":{"id":1}},
"tracks":{"type":"track","total":100,"perPage":20,"results":[{"id":1},{"id":2}]},
"albums":{"total":5,"results":[{"id":10}]}
}"#,
)
.unwrap();
assert_eq!(search.track_results().len(), 2);
assert_eq!(search.albums.as_ref().unwrap().results.len(), 1);
assert!(search.tracks.as_ref().unwrap().has_more(0));
assert!(!search.tracks.as_ref().unwrap().has_more(4));
}
#[test]
fn corrections_are_reported_only_when_actually_applied() {
let corrected: Search = serde_json::from_str(
r#"{"misspellCorrected":true,"misspellResult":"fixed","misspellOriginal":"fxied"}"#,
)
.unwrap();
assert_eq!(corrected.correction(), Some("fixed"));
let not_corrected: Search = serde_json::from_str(r#"{"misspellResult":"fixed"}"#).unwrap();
assert_eq!(not_corrected.correction(), None);
}
#[test]
fn an_absent_track_block_yields_an_empty_slice_not_a_panic() {
let search: Search = serde_json::from_str("{}").unwrap();
assert!(search.track_results().is_empty());
}
#[test]
fn search_models_survive_an_empty_object() {
serde_json::from_str::<Search>("{}").unwrap();
serde_json::from_str::<Best>("{}").unwrap();
serde_json::from_str::<Suggestions>("{}").unwrap();
serde_json::from_str::<SearchResult<Track>>("{}").unwrap();
}
}