use std::collections::BTreeMap;
use prolink_proto::dbserver::{
Arguments, CamelotKey, Drill, FILTER_ALL, ItemType, METADATA_ITEMS, MenuItem, MessageKind,
ROOT_CATEGORIES, SORT_MENU, SortOrder, TRACK_INFO_ITEMS,
};
use prolink_rekordbox::{Library, Track};
use super::keys::{self, TOLERANCES, Wheel};
use crate::serve::Medium;
pub(super) const SERVED: [&str; 11] = [
"PLAYLIST",
"ALBUM",
"GENRE",
"LABEL",
"ARTIST",
"BITRATE",
"DATE ADDED",
"TRACK",
"HISTORY",
"SEARCH",
"KEY",
];
const MENU_DATE_ADDED: MessageKind = MessageKind::MENU_TIME;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Position {
TrackNumber,
InList,
}
pub(super) fn build(
kind: MessageKind,
args: &Arguments,
medium: Option<&Medium>,
tags: &[u32],
) -> Option<Vec<MenuItem>> {
if let Some(medium) = medium
&& medium.is_phantom()
&& !is_about_one_track(kind)
{
return (is_menu(kind)
|| matches!(
kind,
MessageKind::MENU_ROOT | MessageKind::MENU_SORT | MessageKind::MENU_TAG_LIST
))
.then(Vec::new);
}
if let Some(medium) = medium
&& let Some(folders) = medium.folders()
&& let Some(items) = super::plain::build(kind, args, medium, folders, tags)
{
return Some(items);
}
match kind {
MessageKind::MENU_ROOT => return Some(root()),
MessageKind::MENU_SORT => return Some(sort_options()),
_ => {}
}
let Some(medium) = medium else {
return is_menu(kind).then(Vec::new);
};
if medium.is_plain() {
return is_menu(kind).then(Vec::new);
}
let library = medium.library();
let sort = SortOrder(args.number(1).unwrap_or(SortOrder::DEFAULT.0));
let items = match kind {
MessageKind::MENU_TRACK => track_items(
sorted(all_tracks(library), sort),
sort,
Position::TrackNumber,
),
MessageKind::MENU_ARTIST => named(library, Filter::Artist),
MessageKind::MENU_ALBUM => named(library, Filter::Album),
MessageKind::MENU_GENRE => named(library, Filter::Genre),
MessageKind::MENU_LABEL => named(library, Filter::Label),
MessageKind::MENU_KEY => named(library, Filter::Key),
MessageKind::MENU_BITRATE => named(library, Filter::Bitrate),
MENU_DATE_ADDED => named(library, Filter::DateAdded),
MessageKind::MENU_HISTORY => history(library),
MessageKind::MENU_TAG_LIST => tag_list(library, tags, sort),
MessageKind::MENU_PLAYLIST => playlist(library, args, sort),
MessageKind::MENU_SEARCH => search(library, args.text(3).unwrap_or_default()),
MessageKind::GET_METADATA | MessageKind::GET_GENERIC_METADATA => {
metadata(library, args.number(1).unwrap_or(0))
}
MessageKind::GET_TRACK_INFO => track_info(library, args.number(1).unwrap_or(0)),
_ => return Drill::parse(kind).and_then(|drill| drilled(drill, args, library, sort)),
};
Some(items)
}
pub(super) fn mark(item: &MenuItem, tags: &[u32], playing: Option<u32>) -> MenuItem {
let mut item = item.clone();
if item.flags & super::plain::PLAIN_TRACK_FLAGS != 0 {
if tags.contains(&item.id) {
item.flags |= MenuItem::TAGGED;
}
return item;
}
if item.flags & MenuItem::TRACK_FLAGS == 0 {
return item;
}
if playing == Some(item.id) {
item.flags |= MenuItem::LOADED;
}
if tags.contains(&item.id) {
item.flags |= MenuItem::TAGGED;
}
item
}
fn is_about_one_track(kind: MessageKind) -> bool {
matches!(
kind,
MessageKind::GET_METADATA | MessageKind::GET_GENERIC_METADATA | MessageKind::GET_TRACK_INFO
)
}
fn is_menu(kind: MessageKind) -> bool {
matches!(
kind,
MessageKind::MENU_TRACK
| MessageKind::MENU_ARTIST
| MessageKind::MENU_ALBUM
| MessageKind::MENU_GENRE
| MessageKind::MENU_LABEL
| MessageKind::MENU_KEY
| MessageKind::MENU_BITRATE
| MENU_DATE_ADDED
| MessageKind::MENU_HISTORY
| MessageKind::MENU_PLAYLIST
| MessageKind::MENU_FOLDER
| MessageKind::MENU_SEARCH
| MessageKind::GET_METADATA
| MessageKind::GET_GENERIC_METADATA
| MessageKind::GET_TRACK_INFO
) || Drill::parse(kind).is_some()
}
fn root() -> Vec<MenuItem> {
ROOT_CATEGORIES
.iter()
.filter(|category| SERVED.contains(&category.label))
.map(|category| category.to_item())
.collect()
}
fn sort_options() -> Vec<MenuItem> {
SORT_MENU.iter().map(|option| option.to_item()).collect()
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Filter {
Genre,
Artist,
Album,
Label,
Key,
Bitrate,
DateAdded,
}
impl Filter {
fn value(self, track: &Track) -> u32 {
match self {
Self::Genre => track.genre_id,
Self::Artist => track.artist_id,
Self::Album => track.album_id,
Self::Label => track.label_id,
Self::Key => track.key_id,
Self::Bitrate => track.bitrate,
Self::DateAdded => packed_date(&track.date_added),
}
}
fn label(self, track: &Track, library: &Library) -> String {
match self {
Self::Genre => library.genres.get(&track.genre_id).cloned(),
Self::Artist => library.artists.get(&track.artist_id).cloned(),
Self::Album => library.albums.get(&track.album_id).cloned(),
Self::Label => library.labels.get(&track.label_id).cloned(),
Self::Key => library.keys.get(&track.key_id).cloned(),
Self::Bitrate => Some(String::new()),
Self::DateAdded => Some(track.date_added.clone()),
}
.unwrap_or_default()
}
fn item_type(self) -> ItemType {
match self {
Self::Genre => ItemType::GENRE,
Self::Artist => ItemType::ARTIST,
Self::Album => ItemType::ALBUM,
Self::Label => ItemType::LABEL,
Self::Key => ItemType::KEY,
Self::Bitrate => ItemType::BITRATE,
Self::DateAdded => ItemType::DATE_ADDED,
}
}
fn needs_name(self) -> bool {
!matches!(self, Self::Bitrate | Self::DateAdded)
}
fn order(self, id: u32, label: &str) -> (String, i64) {
match self {
Self::Key => (keys::sort_text(label), 0),
Self::Bitrate | Self::DateAdded => (String::new(), -i64::from(id)),
_ => (label.to_lowercase(), 0),
}
}
}
fn flat_menu(category: u8) -> MessageKind {
MessageKind(0x1000 | u16::from(category))
}
fn chain(category: u8) -> Option<&'static [Filter]> {
Some(match flat_menu(category) {
MessageKind::MENU_GENRE => &[Filter::Genre, Filter::Artist, Filter::Album],
MessageKind::MENU_ARTIST => &[Filter::Artist, Filter::Album],
MessageKind::MENU_ALBUM => &[Filter::Album],
MessageKind::MENU_LABEL => &[Filter::Label, Filter::Artist, Filter::Album],
MessageKind::MENU_BITRATE => &[Filter::Bitrate],
MENU_DATE_ADDED => &[Filter::DateAdded],
_ => return None,
})
}
fn drilled(
drill: Drill,
args: &Arguments,
library: &Library,
sort: SortOrder,
) -> Option<Vec<MenuItem>> {
let depth = usize::from(drill.depth);
let filters: Vec<u32> = (0..depth)
.map(|level| args.number(2 + level).unwrap_or(FILTER_ALL))
.collect();
let first = filters.first().copied().unwrap_or(FILTER_ALL);
match flat_menu(drill.category) {
MessageKind::MENU_KEY => return Some(key_drill(library, depth, &filters, sort)),
MessageKind::MENU_HISTORY => return Some(history_tracks(library, first, sort)),
_ => {}
}
let chain = chain(drill.category)?;
let tracks = narrowed(library, chain, &filters);
let Some(&next) = chain.get(depth) else {
return Some(track_items(
sorted(tracks, sort),
sort,
Position::TrackNumber,
));
};
let mut items = rows(&tracks, next, library);
if items.is_empty() {
return Some(track_items(
sorted(tracks, sort),
sort,
Position::TrackNumber,
));
}
if items.len() > 1 || unclassified(&tracks, next, library) {
items.insert(0, MenuItem::all());
}
Some(items)
}
fn narrowed<'a>(library: &'a Library, chain: &[Filter], filters: &[u32]) -> Vec<&'a Track> {
library
.tracks
.values()
.filter(|track| {
chain
.iter()
.zip(filters)
.all(|(filter, &value)| value == FILTER_ALL || filter.value(track) == value)
})
.collect()
}
fn unclassified(tracks: &[&Track], filter: Filter, library: &Library) -> bool {
tracks.iter().any(|track| {
filter.value(track) == 0 || (filter.needs_name() && filter.label(track, library).is_empty())
})
}
fn rows(tracks: &[&Track], filter: Filter, library: &Library) -> Vec<MenuItem> {
let mut seen: BTreeMap<u32, String> = BTreeMap::new();
for track in tracks {
let id = filter.value(track);
if id == 0 {
continue;
}
let label = filter.label(track, library);
if filter.needs_name() && label.is_empty() {
continue;
}
seen.entry(id).or_insert(label);
}
ordered(seen, filter)
}
fn named(library: &Library, filter: Filter) -> Vec<MenuItem> {
let tracks: Vec<&Track> = library.tracks.values().collect();
rows(&tracks, filter, library)
}
fn ordered(seen: BTreeMap<u32, String>, filter: Filter) -> Vec<MenuItem> {
let mut sorted: Vec<(String, i64, u32, String)> = seen
.into_iter()
.map(|(id, label)| {
let (text, number) = filter.order(id, &label);
(text, number, id, label)
})
.collect();
sorted.sort();
sorted
.into_iter()
.map(|(_, _, id, label)| MenuItem::named(id, filter.item_type(), &label))
.collect()
}
fn key_drill(library: &Library, depth: usize, filters: &[u32], sort: SortOrder) -> Vec<MenuItem> {
let key_id = filters.first().copied().unwrap_or(0);
let Some(chosen) = library
.keys
.get(&key_id)
.and_then(|name| Wheel::parse(name))
else {
let tracks = library
.tracks
.values()
.filter(|track| track.key_id == key_id)
.collect();
return track_items(sorted(tracks, sort), sort, Position::TrackNumber);
};
let placed: BTreeMap<Wheel, (u32, &str)> = library
.keys
.iter()
.filter_map(|(&id, name)| Wheel::parse(name).map(|spot| (spot, (id, name.as_str()))))
.collect();
if depth <= 1 {
return (0..TOLERANCES)
.map(|tolerance| {
let names: Vec<&str> = keys::harmonic_set(chosen, tolerance)
.into_iter()
.filter_map(|spot| placed.get(&spot).map(|&(_, name)| name))
.collect();
let mut item = MenuItem::named(key_id, ItemType::KEY, &names.join(", "));
item.argument0 = tolerance;
item
})
.collect();
}
let tolerance = filters.get(1).copied().unwrap_or(0);
let wanted: Vec<u32> = keys::harmonic_set(chosen, tolerance)
.into_iter()
.filter_map(|spot| placed.get(&spot).map(|&(id, _)| id))
.collect();
let tracks = library
.tracks
.values()
.filter(|track| wanted.contains(&track.key_id))
.collect();
track_items(sorted(tracks, sort), sort, Position::TrackNumber)
}
fn history(library: &Library) -> Vec<MenuItem> {
library
.history
.values()
.rev()
.map(|playlist| MenuItem::named(playlist.id, ItemType::HISTORY_PLAYLIST, &playlist.name))
.collect()
}
fn history_tracks(library: &Library, playlist_id: u32, sort: SortOrder) -> Vec<MenuItem> {
let tracks: Vec<&Track> = library
.history
.get(&playlist_id)
.into_iter()
.flat_map(|playlist| playlist.track_ids.iter())
.filter_map(|id| library.tracks.get(id))
.collect();
let tracks = match sort {
SortOrder::DEFAULT => tracks,
_ => sorted(tracks, sort),
};
track_items(tracks, sort, Position::InList)
}
fn tag_list(library: &Library, tags: &[u32], sort: SortOrder) -> Vec<MenuItem> {
let tracks: Vec<&Track> = tags
.iter()
.filter_map(|id| library.tracks.get(id))
.collect();
let tracks = match sort {
SortOrder::DEFAULT => tracks,
_ => sorted(tracks, sort),
};
track_items(tracks, sort, Position::InList)
}
fn playlist(library: &Library, args: &Arguments, sort: SortOrder) -> Vec<MenuItem> {
let playlist_id = args.number(2).unwrap_or(0);
let is_folder = args.number(3).unwrap_or(0) != 0;
if is_folder {
let mut children: Vec<_> = library
.playlists
.values()
.filter(|node| match playlist_id {
0 => !library.playlists.contains_key(&node.parent_id),
parent => node.parent_id == parent,
})
.collect();
children.sort_by(|a, b| {
(!a.is_folder, a.sort_order, &a.name).cmp(&(!b.is_folder, b.sort_order, &b.name))
});
return children
.into_iter()
.map(|node| {
let item_type = if node.is_folder {
ItemType::FOLDER
} else {
ItemType::PLAYLIST
};
let mut item = MenuItem::named(node.id, item_type, &node.name);
item.playlist_position = node.sort_order;
item
})
.collect();
}
let tracks = library.playlist_tracks(playlist_id);
let tracks = match sort {
SortOrder::DEFAULT => tracks,
_ => sorted(tracks, sort),
};
track_items(tracks, sort, Position::InList)
}
const SEARCH_ARTIST: u32 = 1;
const SEARCH_ALBUM: u32 = 2;
const SEARCH_TRACK: u32 = 3;
fn search(library: &Library, term: &str) -> Vec<MenuItem> {
let needle = term.to_lowercase();
let matches = |text: &str| text.to_lowercase().contains(&needle);
let referenced = |ids: &dyn Fn(&Track) -> u32, table: &BTreeMap<u32, String>| {
let mut found: BTreeMap<String, (String, u32)> = BTreeMap::new();
for track in library.tracks.values() {
let id = ids(track);
let Some(name) = table.get(&id).filter(|name| !name.is_empty()) else {
continue;
};
if matches(name) {
found.insert(
format!("{}\u{0}{id}", name.to_lowercase()),
(name.clone(), id),
);
}
}
found
};
let artists = referenced(&|track: &Track| track.artist_id, &library.artists);
let albums = referenced(&|track: &Track| track.album_id, &library.albums);
let mut tracks: Vec<&Track> = library
.tracks
.values()
.filter(|track| matches(&track.title))
.collect();
tracks.sort_by_key(|track| (track.title.to_lowercase(), track.id));
let mut items: Vec<MenuItem> = Vec::with_capacity(artists.len() + albums.len() + tracks.len());
for (group, kind, item_type) in [
(artists, SEARCH_ARTIST, ItemType::ARTIST),
(albums, SEARCH_ALBUM, ItemType::ALBUM),
] {
items.extend(group.into_values().map(|(name, id)| {
let mut item = MenuItem::named(id, item_type, &name);
item.argument0 = kind;
item
}));
}
items.extend(tracks.into_iter().map(|track| {
let mut item = MenuItem::track(
track.id,
&track.title,
"",
ItemType::TRACK_TITLE,
track.artwork_id,
);
item.argument0 = SEARCH_TRACK;
item.with_key(CamelotKey::parse(&track.key))
}));
items
}
fn metadata(library: &Library, track_id: u32) -> Vec<MenuItem> {
let Some(track) = library.tracks.get(&track_id) else {
return Vec::new();
};
METADATA_ITEMS
.iter()
.map(|slot| {
let (id, label) = match slot.item_type {
ItemType::TRACK_TITLE => (track.id, track.title.as_str()),
ItemType::ARTIST => (track.artist_id, track.artist.as_str()),
ItemType::ALBUM => (track.album_id, track.album.as_str()),
ItemType::DURATION => (u32::from(track.duration), ""),
ItemType::TEMPO => (track.tempo, ""),
ItemType::COMMENT => (track.id, track.comment.as_str()),
ItemType::KEY => (track.key_id, track.key.as_str()),
ItemType::RATING => (u32::from(track.rating), ""),
ItemType::COLOR => (u32::from(track.color_id), track.color.as_str()),
ItemType::GENRE => (track.genre_id, track.genre.as_str()),
ItemType::DATE_ADDED => (track.id, track.date_added.as_str()),
ItemType::BITRATE => (track.bitrate, ""),
_ => (track.label_id, track.label.as_str()),
};
let mut item = MenuItem::named(id, slot.item_type, label);
item.argument0 = slot.argument0;
if slot.item_type == ItemType::TRACK_TITLE {
item.flags = MenuItem::TRACK_FLAGS;
item.artwork_id = track.artwork_id;
}
item
})
.collect()
}
fn track_info(library: &Library, track_id: u32) -> Vec<MenuItem> {
let Some(track) = library.tracks.get(&track_id) else {
return Vec::new();
};
TRACK_INFO_ITEMS
.iter()
.map(|&item_type| {
let (argument0, id, label) = match item_type {
ItemType::TRACK_TITLE => (0, u32::from(track.container.0), ""),
ItemType::DURATION => (0, u32::from(track.duration), ""),
ItemType::TEMPO => (0, track.tempo, ""),
ItemType::COMMENT => (0, track.id, track.comment.as_str()),
ItemType::PATH => (track.file_size, track.id, track.file_path.as_str()),
_ => (0, 1, ""),
};
let mut item = MenuItem::named(id, item_type, label);
item.argument0 = argument0;
item
})
.collect()
}
fn all_tracks(library: &Library) -> Vec<&Track> {
library.tracks.values().collect()
}
fn track_items<'a>(
tracks: impl IntoIterator<Item = &'a Track>,
sort: SortOrder,
position: Position,
) -> Vec<MenuItem> {
tracks
.into_iter()
.enumerate()
.map(|(index, track)| {
let (argument0, column) = second_column(track, sort);
let mut item = MenuItem::track(
track.id,
&track.title,
column,
sort.track_item_type(),
track.artwork_id,
);
item.argument0 = argument0;
item.playlist_position = match position {
Position::TrackNumber => track.track_number,
Position::InList => u32::try_from(index).unwrap_or(u32::MAX).saturating_add(1),
};
item.with_key(CamelotKey::parse(&track.key))
})
.collect()
}
fn second_column(track: &Track, sort: SortOrder) -> (u32, &str) {
let column = sort.column().unwrap_or(ItemType::ARTIST);
let (value, text) = match column {
ItemType::ALBUM => (track.album_id, track.album.as_str()),
ItemType::GENRE => (track.genre_id, track.genre.as_str()),
ItemType::LABEL => (track.label_id, track.label.as_str()),
ItemType::KEY => (track.key_id, track.key.as_str()),
ItemType::DATE_ADDED => (track.id, track.date_added.as_str()),
ItemType::TEMPO => (track.tempo, ""),
ItemType::RATING => (u32::from(track.rating), ""),
ItemType::BITRATE => (track.bitrate, ""),
ItemType::PLAY_COUNT => (u32::from(track.play_count), ""),
_ => (track.artist_id, track.artist.as_str()),
};
if sort.column_is_numeric() {
(value, "")
} else {
(value, text)
}
}
fn sorted(tracks: Vec<&Track>, sort: SortOrder) -> Vec<&Track> {
let mut keyed: Vec<(String, i64, String, u32, &Track)> = tracks
.into_iter()
.map(|track| {
let title = track.title.to_lowercase();
let (text, number) = match sort {
SortOrder::ARTIST => (track.artist.to_lowercase(), 0),
SortOrder::ALBUM => (track.album.to_lowercase(), i64::from(track.track_number)),
SortOrder::GENRE => (track.genre.to_lowercase(), 0),
SortOrder::LABEL => (track.label.to_lowercase(), 0),
SortOrder::KEY => (keys::sort_text(&track.key), 0),
SortOrder::BPM => (String::new(), i64::from(track.tempo)),
SortOrder::RATING => (String::new(), -i64::from(track.rating)),
SortOrder::BITRATE => (String::new(), i64::from(track.bitrate)),
SortOrder::PLAY_COUNT => (String::new(), -i64::from(track.play_count)),
SortOrder::DATE_ADDED => {
(String::new(), -i64::from(packed_date(&track.date_added)))
}
_ => (title.clone(), 0),
};
(text, number, title, track.id, track)
})
.collect();
keyed.sort_by(|a, b| (&a.0, a.1, &a.2, a.3).cmp(&(&b.0, b.1, &b.2, b.3)));
keyed.into_iter().map(|(_, _, _, _, track)| track).collect()
}
fn packed_date(date: &str) -> u32 {
let mut parts = date.split('-');
let year: u32 = parts.next().and_then(|part| part.parse().ok()).unwrap_or(0);
let month: u32 = parts.next().and_then(|part| part.parse().ok()).unwrap_or(0);
let day: u32 = parts.next().and_then(|part| part.parse().ok()).unwrap_or(0);
if parts.next().is_some() || year == 0 {
return 0;
}
year.saturating_mul(10_000)
.saturating_add(month.saturating_mul(100))
.saturating_add(day)
}