use std::collections::HashSet; use std::sync::mpsc::Sender; use std::time::{Instant, SystemTime, UNIX_EPOCH}; use anyhow::Result; use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers}; use ratatui::widgets::TableState; use crate::command::{self, Amount, Command, COMMAND_NAMES}; use crate::config::{self, Config}; use crate::model::{split_artists, RepeatMode, Track}; use crate::player::{Player, PlayerEvent}; use crate::session::Session; use crate::store::Store; use crate::ytmusic; pub enum AppEvent { Player(PlayerEvent), Results { id: u64, title: String, result: Result, String>, }, } #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum View { Results, Queue, Playlists, } impl View { pub fn idx(self) -> usize { match self { View::Results => 0, View::Queue => 1, View::Playlists => 2, } } fn from_idx(i: usize) -> View { [View::Results, View::Queue, View::Playlists][i % 3] } } #[derive(Clone, Copy, PartialEq, Eq)] pub enum Mode { Normal, Command, ArtistPick, Help, } #[derive(Clone, Copy, PartialEq, Eq)] pub enum PlayState { Stopped, Loading, Playing, Paused, } #[derive(Clone, Copy, PartialEq, Eq)] pub enum Level { Info, Error, } pub struct Status { pub text: String, pub level: Level, pub at: Instant, } pub struct App { pub view: View, pub mode: Mode, pub results: Vec, pub results_title: String, pub queue: Vec, pub current: Option, pub store: Store, pub states: [TableState; 3], pub open: Option, pub pl_state: TableState, pub cmd_buf: String, pub artist_opts: Vec, pub artist_sel: usize, pub help_scroll: usize, history: Vec, hist_pos: Option, pub count: Option, pub pending: Option, pub play_state: PlayState, pub position: f64, pub duration: f64, pub volume: u8, pub shuffle: bool, pub repeat: RepeatMode, played: HashSet, fail_streak: u8, result_cursor: Option, radio: Vec, on_radio: bool, seek_step: f64, volume_step: f64, resume: Option<(String, f64)>, saved: String, save_failed: bool, pub status: Option, pub busy: Option, pub tick: usize, pub should_quit: bool, search_id: u64, player: Option, tx: Sender, rng: u64, } impl App { pub fn new(tx: Sender) -> App { let (store, store_warning) = Store::load(); config::migrate_legacy(); let (cfg, cfg_warning) = Config::load(); let p = cfg.playback; let warning = cfg_warning.or(store_warning); let seed = SystemTime::now() .duration_since(UNIX_EPOCH) .map(|d| d.as_nanos() as u64) .unwrap_or(0x9E37_79B9_7F4A_7C15) | 1; let mut app = App { view: View::Results, mode: Mode::Normal, results: Vec::new(), results_title: "Results".into(), queue: Vec::new(), current: None, store, states: Default::default(), open: None, pl_state: TableState::default(), cmd_buf: String::new(), artist_opts: Vec::new(), artist_sel: 0, help_scroll: 0, history: Vec::new(), hist_pos: None, count: None, pending: None, play_state: PlayState::Stopped, position: 0.0, duration: 0.0, volume: p.volume, shuffle: p.shuffle, repeat: p.repeat, played: HashSet::new(), fail_streak: 0, result_cursor: None, radio: Vec::new(), on_radio: false, seek_step: p.seek_step, volume_step: p.volume_step, resume: None, saved: String::new(), save_failed: false, status: None, busy: None, tick: 0, should_quit: false, search_id: 0, player: None, tx, rng: seed, }; if p.restore_session { let s = Session::load(); app.resume = s .current .and_then(|c| s.queue.get(c)) .map(|t| (t.id.clone(), s.position)); app.current = s.current; app.queue = s.queue; if !app.queue.is_empty() { app.states[View::Queue.idx()].select(Some(app.current.unwrap_or(0))); } } match warning { Some(w) => app.error(w), None => app.info("Welcome! Press / to search, ? for help."), } app } pub fn shutdown(&mut self) { if let Err(e) = self.save_session(true) { eprintln!("drift: could not save session: {e:#}"); } self.player = None; } fn save_session(&mut self, force: bool) -> Result<()> { let session = Session { queue: self.queue.clone(), current: self.current, position: if self.on_radio { 0.0 } else { self.position }, }; let text = session.render()?; if !force && text == self.saved { return Ok(()); } Session::write(&text)?; self.saved = text; Ok(()) } pub fn info(&mut self, msg: impl Into) { self.set_status(msg.into(), Level::Info); } pub fn error(&mut self, msg: impl Into) { self.set_status(msg.into(), Level::Error); } fn set_status(&mut self, text: String, level: Level) { self.status = Some(Status { text, level, at: Instant::now() }); } pub fn visible_status(&self) -> Option<&Status> { self.status.as_ref().filter(|s| { s.at.elapsed().as_secs() < if s.level == Level::Error { 12 } else { 6 } }) } pub fn on_tick(&mut self) { self.tick = self.tick.wrapping_add(1); if self.tick % 50 == 0 { match self.save_session(false) { Ok(()) => self.save_failed = false, Err(e) if !self.save_failed => { self.save_failed = true; self.error(format!("Could not save session: {e:#}")); } Err(_) => {} } } } pub fn len_of(&self, v: View) -> usize { match v { View::Results => self.results.len(), View::Queue => self.queue.len(), View::Playlists => self.store.playlists.len(), } } pub fn in_playlist(&self) -> bool { self.view == View::Playlists && self.open.as_ref().is_some_and(|n| self.store.playlists.contains_key(n)) } pub fn open_len(&self) -> usize { self.open.as_ref().and_then(|n| self.store.playlists.get(n)).map_or(0, |t| t.len()) } fn cur_len(&self) -> usize { if self.in_playlist() { self.open_len() } else { self.len_of(self.view) } } pub fn selected(&self) -> usize { if self.in_playlist() { return self.pl_state.selected().unwrap_or(0); } self.states[self.view.idx()].selected().unwrap_or(0) } fn set_selected(&mut self, i: usize) { let len = self.cur_len(); let new = if len == 0 { None } else { Some(i.min(len - 1)) }; if self.in_playlist() { self.pl_state.select(new); } else { let idx = self.view.idx(); self.states[idx].select(new); } } fn move_sel(&mut self, delta: isize) { let len = self.cur_len(); if len == 0 { return; } let new = (self.selected() as isize + delta).clamp(0, len as isize - 1); self.set_selected(new as usize); } fn set_view(&mut self, v: View) { if v != View::Playlists { self.open = None; } self.view = v; let sel = self.selected(); self.set_selected(sel); } pub fn playlist_name(&self, i: usize) -> Option { self.store.playlists.keys().nth(i).cloned() } pub fn now_track(&self) -> Option<&Track> { if self.on_radio { return self.result_cursor.and_then(|i| self.radio.get(i)); } self.current.and_then(|i| self.queue.get(i)) } pub fn on_key(&mut self, key: KeyEvent) { if key.kind == KeyEventKind::Release { return; } if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') { self.should_quit = true; return; } match self.mode { Mode::Help => self.key_help(key), Mode::Command => self.key_command(key), Mode::ArtistPick => self.key_artist_pick(key), Mode::Normal => self.key_normal(key), } } fn key_normal(&mut self, key: KeyEvent) { let ctrl = key.modifiers.contains(KeyModifiers::CONTROL); if let Some(p) = self.pending.take() { let n = self.count.take(); if let KeyCode::Char(c) = key.code { match (p, c) { ('g', 'g') => self.set_selected(n.map_or(0, |n| n.saturating_sub(1))), ('g', 'r') => self.set_view(View::Results), ('g', 'q') => self.set_view(View::Queue), ('g', 'p') => self.set_view(View::Playlists), ('d', 'd') => self.delete_selected(), ('g', 'a') => self.go_to_artist(), _ => {} } } return; } if let KeyCode::Char(c @ '0'..='9') = key.code { if !ctrl && !(c == '0' && self.count.is_none()) { let d = c as usize - '0' as usize; self.count = Some((self.count.unwrap_or(0) * 10 + d).min(9999)); return; } } let n = self.count.take(); let times = n.unwrap_or(1); if self.view == View::Playlists { match key.code { KeyCode::Right | KeyCode::Char('l') if !self.in_playlist() && !ctrl => { return self.open_selected_playlist(); } KeyCode::Left | KeyCode::Char('h') | KeyCode::Backspace | KeyCode::Esc if self.in_playlist() && !ctrl => { return self.close_playlist(); } _ => {} } } match key.code { KeyCode::Char('d') if ctrl => self.move_sel(10), KeyCode::Char('u') if ctrl => self.move_sel(-10), KeyCode::Char('f') if ctrl => self.move_sel(20), KeyCode::Char('b') if ctrl => self.move_sel(-20), KeyCode::PageDown => self.move_sel(20), KeyCode::PageUp => self.move_sel(-20), KeyCode::Home => self.set_selected(0), KeyCode::End => self.set_selected(usize::MAX), KeyCode::Char('j') | KeyCode::Down => self.move_sel(times as isize), KeyCode::Char('k') | KeyCode::Up => self.move_sel(-(times as isize)), KeyCode::Char('g') => { self.pending = Some('g'); self.count = n; } KeyCode::Char('G') => self.set_selected(n.map_or(usize::MAX, |n| n.saturating_sub(1))), KeyCode::Char('d') => { if matches!(self.view, View::Queue | View::Playlists) { self.pending = Some('d'); } } KeyCode::Char('x') | KeyCode::Delete => self.delete_selected(), KeyCode::Tab => self.set_view(View::from_idx(self.view.idx() + 1)), KeyCode::BackTab => self.set_view(View::from_idx(self.view.idx() + 2)), KeyCode::Enter => self.activate(), KeyCode::Char(' ') => self.toggle_pause(), KeyCode::Char('n') | KeyCode::Char('>') => self.next(), KeyCode::Char('N') | KeyCode::Char('<') => self.prev(), KeyCode::Char('h') | KeyCode::Left => self.seek(Amount::Delta(-self.seek_step * times as f64)), KeyCode::Char('l') | KeyCode::Right => self.seek(Amount::Delta(self.seek_step * times as f64)), KeyCode::Char('+') | KeyCode::Char('=') => { self.set_volume(Amount::Delta(self.volume_step * times as f64)) } KeyCode::Char('-') | KeyCode::Char('_') => { self.set_volume(Amount::Delta(-self.volume_step * times as f64)) } KeyCode::Char('a') => self.add_selected(), KeyCode::Char('A') => self.add_all_results(), KeyCode::Char('P') => self.play_all_results(), KeyCode::Char('J') => self.move_item(1), KeyCode::Char('K') => self.move_item(-1), KeyCode::Char('s') => self.toggle_shuffle(), KeyCode::Char('r') => self.cycle_repeat(), KeyCode::Char('/') => { self.cmd_buf = "search ".into(); self.enter_command_mode(); } KeyCode::Char(':') => { self.cmd_buf.clear(); self.enter_command_mode(); } KeyCode::Char('?') => self.open_help(), KeyCode::Char('q') => self.should_quit = true, KeyCode::Esc => self.status = None, _ => {} } } fn open_help(&mut self) { self.help_scroll = 0; self.mode = Mode::Help; } fn key_help(&mut self, key: KeyEvent) { let ctrl = key.modifiers.contains(KeyModifiers::CONTROL); let s = self.help_scroll; match key.code { KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('?') | KeyCode::Enter => { self.mode = Mode::Normal } KeyCode::Char('j') | KeyCode::Down => self.help_scroll = s.saturating_add(1), KeyCode::Char('k') | KeyCode::Up => self.help_scroll = s.saturating_sub(1), KeyCode::Char('d') if ctrl => self.help_scroll = s.saturating_add(10), KeyCode::Char('u') if ctrl => self.help_scroll = s.saturating_sub(10), KeyCode::PageDown | KeyCode::Char(' ') => self.help_scroll = s.saturating_add(10), KeyCode::PageUp => self.help_scroll = s.saturating_sub(10), KeyCode::Char('g') | KeyCode::Home => self.help_scroll = 0, KeyCode::Char('G') | KeyCode::End => self.help_scroll = usize::MAX, _ => {} } } fn enter_command_mode(&mut self) { self.mode = Mode::Command; self.hist_pos = None; } fn key_command(&mut self, key: KeyEvent) { let ctrl = key.modifiers.contains(KeyModifiers::CONTROL); match key.code { KeyCode::Esc => { self.mode = Mode::Normal; self.cmd_buf.clear(); } KeyCode::Enter => { let line = std::mem::take(&mut self.cmd_buf); self.mode = Mode::Normal; let trimmed = line.trim(); if !trimmed.is_empty() { if self.history.last().map(String::as_str) != Some(trimmed) { self.history.push(trimmed.to_string()); } self.run_command(trimmed); } } KeyCode::Backspace => { if self.cmd_buf.is_empty() { self.mode = Mode::Normal; } else { self.cmd_buf.pop(); } } KeyCode::Char('u') if ctrl => self.cmd_buf.clear(), KeyCode::Char('w') if ctrl => { let trimmed = self.cmd_buf.trim_end().len(); let cut = self.cmd_buf[..trimmed].rfind(' ').map_or(0, |i| i + 1); self.cmd_buf.truncate(cut); } KeyCode::Up => self.history_step(-1), KeyCode::Down => self.history_step(1), KeyCode::Tab => self.complete(), KeyCode::Char(c) if !ctrl => self.cmd_buf.push(c), _ => {} } } fn history_step(&mut self, dir: isize) { if self.history.is_empty() { return; } let len = self.history.len() as isize; let pos = match (self.hist_pos, dir) { (None, -1) => len - 1, (None, _) => return, (Some(p), d) => p as isize + d, }; if pos >= len { self.hist_pos = None; self.cmd_buf.clear(); } else { let pos = pos.max(0) as usize; self.hist_pos = Some(pos); self.cmd_buf = self.history[pos].clone(); } } fn complete(&mut self) { if self.cmd_buf.contains(' ') { return; } let matches: Vec<&&str> = COMMAND_NAMES .iter() .filter(|c| c.starts_with(self.cmd_buf.as_str())) .collect(); match matches.len() { 0 => {} 1 => self.cmd_buf = format!("{} ", matches[0]), _ => { let list = matches.iter().map(|s| **s).collect::>().join(" "); self.info(list); } } } pub fn run_command(&mut self, line: &str) { match command::parse(line) { Ok(Some(cmd)) => self.exec(cmd), Ok(None) => {} Err(e) => self.error(e), } } fn exec(&mut self, cmd: Command) { match cmd { Command::Search(q) => self.start_search(q), Command::Play(None) => self.play_default(), Command::Play(Some(n)) => { let len = self.len_of(self.view); if n > len { self.error(format!("no row {n} (only {len} here)")); } else { let v = self.view; self.activate_at(v, n - 1); } } Command::Pause => self.set_pause(true), Command::Resume => self.set_pause(false), Command::Toggle => self.toggle_pause(), Command::Stop => self.stop_playback(), Command::Next => self.next(), Command::Prev => self.prev(), Command::Quit => self.should_quit = true, Command::Add(None) => self.add_selected(), Command::Add(Some(n)) => match self.results.get(n - 1).cloned() { Some(t) => self.enqueue(t), None => self.error(format!("no result #{n}")), }, Command::AddAll => self.add_all_results(), Command::PlayAll => self.play_all_results(), Command::Remove(n) => { let i = n.map_or(self.selected(), |n| n - 1); self.remove_from_queue(i); } Command::Clear => self.clear_queue(), Command::ShowResults => self.set_view(View::Results), Command::ShowQueue => self.set_view(View::Queue), Command::ShowPlaylists => self.set_view(View::Playlists), Command::Volume(a) => self.set_volume(a), Command::Seek(a) => self.seek(a), Command::Shuffle => self.toggle_shuffle(), Command::Repeat(m) => { self.repeat = m.unwrap_or_else(|| self.repeat.cycle()); self.info(format!("Repeat: {}", self.repeat.label())); } Command::Save(name) => self.save_playlist(&name), Command::Load(name) => match self.store.resolve(&name) { Some(n) => self.load_playlist(&n, true), None => self.error(format!("no playlist named '{name}'")), }, Command::Append(name) => match self.store.resolve(&name) { Some(n) => self.load_playlist(&n, false), None => self.error(format!("no playlist named '{name}'")), }, Command::DeletePlaylist(name) => match self.store.resolve(&name) { Some(n) => self.delete_playlist(&n), None => self.error(format!("no playlist named '{name}'")), }, Command::AddTo(name) => self.add_to_playlist(&name), Command::Import(url) => self.start_import(url), Command::Artist => self.go_to_artist(), Command::Help => self.open_help(), } } fn artist_target(&self) -> Option { let sel = self.selected(); let highlighted = match self.view { View::Results => self.results.get(sel), View::Queue => self.queue.get(sel), View::Playlists if self.in_playlist() => self .open .as_ref() .and_then(|n| self.store.playlists.get(n)) .and_then(|t| t.get(sel)), View::Playlists => None, }; highlighted.or_else(|| self.now_track()).cloned() } fn go_to_artist(&mut self) { let Some(track) = self.artist_target() else { return self.error("No song selected"); }; let names = split_artists(&track.artist); if names.is_empty() || track.artist == "Unknown artist" { return self.error("No artist known for this song"); } if names.len() == 1 { return self.search_artist(names[0].clone()); } let mut opts = names; opts.push(track.artist.trim().to_string()); self.artist_opts = opts; self.artist_sel = 0; self.mode = Mode::ArtistPick; } fn key_artist_pick(&mut self, key: KeyEvent) { let len = self.artist_opts.len(); if len == 0 { self.mode = Mode::Normal; return; } match key.code { KeyCode::Esc | KeyCode::Char('q') => self.close_artist_pick(), KeyCode::Char('j') | KeyCode::Down => self.artist_sel = (self.artist_sel + 1).min(len - 1), KeyCode::Char('k') | KeyCode::Up => self.artist_sel = self.artist_sel.saturating_sub(1), KeyCode::Char(c @ '1'..='9') => { let i = c as usize - '1' as usize; if i < len { self.artist_sel = i; self.confirm_artist(); } } KeyCode::Enter => self.confirm_artist(), _ => {} } } fn close_artist_pick(&mut self) { self.mode = Mode::Normal; self.artist_opts.clear(); self.artist_sel = 0; } fn confirm_artist(&mut self) { let name = self.artist_opts.get(self.artist_sel).cloned(); self.close_artist_pick(); if let Some(name) = name { self.search_artist(name); } } fn search_artist(&mut self, name: String) { let busy = format!("Loading songs by \u{201c}{name}\u{201d}"); let title = format!("Artist: {name}"); self.spawn_loader(title, busy, move || { let wanted = name.to_lowercase(); let tracks = ytmusic::search(&name)?; Ok(tracks .into_iter() .filter(|t| { t.artist.to_lowercase() == wanted || split_artists(&t.artist).iter().any(|a| a.to_lowercase() == wanted) }) .collect()) }); } fn start_search(&mut self, query: String) { self.spawn_loader(format!("Search: {query}"), format!("Searching \u{201c}{query}\u{201d}"), move || { ytmusic::search(&query) }); } fn start_import(&mut self, url: String) { self.spawn_loader("Imported playlist".into(), "Importing playlist".into(), move || { ytmusic::import(&url) }); } fn spawn_loader(&mut self, title: String, busy: String, work: F) where F: FnOnce() -> Result, String> + Send + 'static, { self.search_id += 1; let id = self.search_id; self.busy = Some(busy); let tx = self.tx.clone(); std::thread::spawn(move || { let result = work(); let _ = tx.send(AppEvent::Results { id, title, result }); }); } pub fn on_event(&mut self, ev: AppEvent) { match ev { AppEvent::Results { id, title, result } => { if id != self.search_id { return; } self.busy = None; match result { Ok(tracks) if tracks.is_empty() => self.info("No results found."), Ok(tracks) => { let n = tracks.len(); self.results = tracks; self.results_title = title; self.states[View::Results.idx()].select(Some(0)); self.set_view(View::Results); self.info(format!("{n} results — Enter plays, a queues, ? for help")); } Err(e) => self.error(e), } } AppEvent::Player(pe) => self.on_player(pe), } } fn ensure_player(&mut self) -> Result<&mut Player> { if let Some(p) = self.player.as_mut() { if !p.is_alive() { self.player = None; } } if self.player.is_none() { let tx = self.tx.clone(); let p = Player::spawn(self.volume, move |ev| { let _ = tx.send(AppEvent::Player(ev)); })?; self.player = Some(p); } Ok(self.player.as_mut().expect("player was just created")) } fn with_player(&mut self, f: impl Fn(&mut Player) -> Result<()>) -> Result<()> { match self.ensure_player().and_then(|p| f(p)) { Ok(()) => Ok(()), Err(_) => { self.player = None; self.ensure_player().and_then(|p| f(p)) } } } fn on_player(&mut self, ev: PlayerEvent) { match ev { PlayerEvent::Position(Some(p)) => self.position = p, PlayerEvent::Position(None) => {} PlayerEvent::Duration(Some(d)) => self.duration = d, PlayerEvent::Duration(None) => {} PlayerEvent::Paused(p) => match (self.play_state, p) { (PlayState::Playing, true) => self.play_state = PlayState::Paused, (PlayState::Paused, false) => self.play_state = PlayState::Playing, _ => {} }, PlayerEvent::Volume(v) => self.volume = v.round().clamp(0.0, 130.0) as u8, PlayerEvent::FileLoaded => { self.play_state = PlayState::Playing; self.fail_streak = 0; if let Some((id, pos)) = self.resume.take() { let ok = self.now_track().is_some_and(|t| { t.id == id && t.duration.map_or(true, |d| pos < f64::from(d) - 1.0) }); if ok && pos > 1.0 { let _ = self.with_player(|p| p.seek_absolute(pos)); self.position = pos; } } } PlayerEvent::EndOfFile => { if self.play_state != PlayState::Stopped { self.advance(true); } } PlayerEvent::LoadError(msg) => { let name = self.now_track().map(Track::label).unwrap_or_default(); self.fail_streak += 1; if self.fail_streak >= 3 { self.stop_playback(); self.error(format!( "Playback failed 3 times in a row ({msg}). Update yt-dlp: yt-dlp -U" )); } else { self.error(format!("Can't play \u{201c}{name}\u{201d} ({msg}) — skipping")); self.advance(true); } } PlayerEvent::Died => { self.player = None; if self.play_state != PlayState::Stopped { self.play_state = PlayState::Stopped; self.error("mpv exited unexpectedly; it will restart on next play"); } } } } fn play_index(&mut self, i: usize) { self.start_track(i, false); } fn start_track(&mut self, i: usize, keep_resume: bool) { let Some(track) = self.queue.get(i).cloned() else { return }; if !keep_resume { self.resume = None; } self.on_radio = false; self.current = Some(i); self.played.insert(i); self.play_state = PlayState::Loading; self.position = match &self.resume { Some((id, pos)) if *id == track.id => *pos, _ => 0.0, }; self.duration = track.duration.map_or(0.0, f64::from); let url = track.url(); match self.with_player(|p| p.load(&url)) { Ok(()) => self.info(format!("♪ {}", track.label())), Err(e) => { self.play_state = PlayState::Stopped; self.error(format!("Playback failed: {e:#}")); } } } fn play_default(&mut self) { match self.play_state { PlayState::Paused => return self.set_pause(false), PlayState::Playing | PlayState::Loading => { return self.info("Already playing (use :next, :pause, or :play N)"); } PlayState::Stopped => {} } if self.queue.is_empty() { match self.view { View::Results if !self.results.is_empty() => { let i = self.selected().min(self.results.len() - 1); self.play_result(i); } View::Playlists if !self.store.playlists.is_empty() => { let i = self.selected(); self.activate_at(View::Playlists, i); } _ => self.error("Nothing to play — search first with :search \"query\""), } return; } let i = if self.view == View::Queue { self.selected() } else { self.current.unwrap_or(0) }; self.start_track(i.min(self.queue.len() - 1), true); } fn activate(&mut self) { let (v, i) = (self.view, self.selected()); self.activate_at(v, i); } fn activate_at(&mut self, view: View, i: usize) { match view { View::Results => { if i < self.results.len() { self.play_result(i); } } View::Queue => { if i < self.queue.len() { self.play_index(i); } } View::Playlists => { if self.in_playlist() { if let Some(name) = self.open.clone() { self.play_playlist_from(&name, i); } } else if let Some(name) = self.playlist_name(i) { self.load_playlist(&name, true); } } } } fn play_result(&mut self, i: usize) { if i >= self.results.len() { return; } self.radio = self.results.clone(); self.play_radio(i); } fn play_radio(&mut self, i: usize) { let Some(track) = self.radio.get(i).cloned() else { return }; self.on_radio = true; self.result_cursor = Some(i); self.resume = None; self.play_state = PlayState::Loading; self.position = 0.0; self.duration = track.duration.map_or(0.0, f64::from); let url = track.url(); match self.with_player(|p| p.load(&url)) { Ok(()) => self.info(format!("♪ {}", track.label())), Err(e) => { self.play_state = PlayState::Stopped; self.error(format!("Playback failed: {e:#}")); } } } fn set_pause(&mut self, pause: bool) { match self.play_state { PlayState::Stopped => return self.error("Nothing is playing"), PlayState::Loading => return, _ => {} } match self.with_player(|p| p.set_pause(pause)) { Ok(()) => { self.play_state = if pause { PlayState::Paused } else { PlayState::Playing }; } Err(e) => self.error(format!("{e:#}")), } } fn toggle_pause(&mut self) { match self.play_state { PlayState::Playing => self.set_pause(true), PlayState::Paused => self.set_pause(false), PlayState::Loading => {} PlayState::Stopped => self.play_default(), } } fn stop_playback(&mut self) { if let Some(p) = self.player.as_mut() { let _ = p.stop(); } self.play_state = PlayState::Stopped; self.position = 0.0; } fn next(&mut self) { if self.queue.is_empty() && self.result_cursor.is_none() { return self.error("Queue is empty"); } self.advance(false); } fn prev(&mut self) { if let Some(cursor) = self.result_cursor.filter(|_| self.on_radio) { if self.position > 3.0 { return self.seek(Amount::Abs(0.0)); } if cursor > 0 { self.play_radio(cursor - 1); } else { self.seek(Amount::Abs(0.0)); } return; } let Some(c) = self.current else { return self.error("Nothing is playing"); }; if self.position > 3.0 { return self.seek(Amount::Abs(0.0)); } if c > 0 { self.play_index(c - 1); } else if self.repeat == RepeatMode::All && !self.queue.is_empty() { self.play_index(self.queue.len() - 1); } else { self.seek(Amount::Abs(0.0)); } } fn rand_below(&mut self, n: usize) -> usize { self.rng ^= self.rng >> 12; self.rng ^= self.rng << 25; self.rng ^= self.rng >> 27; (self.rng.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 33) as usize % n.max(1) } fn advance(&mut self, auto: bool) { if auto && self.repeat == RepeatMode::One { if self.on_radio { if let Some(c) = self.result_cursor { return self.play_radio(c); } } else if let Some(c) = self.current { return self.play_index(c); } } let len = self.queue.len(); let next = if len == 0 { None } else if self.shuffle { let mut pool: Vec = (0..len).filter(|i| !self.played.contains(i)).collect(); if pool.is_empty() && self.repeat == RepeatMode::All { self.played.clear(); pool = (0..len).filter(|i| Some(*i) != self.current).collect(); if pool.is_empty() { pool = vec![0]; } } if pool.is_empty() { None } else { let k = self.rand_below(pool.len()); Some(pool[k]) } } else { match self.current { Some(c) if c + 1 < len => Some(c + 1), Some(_) if self.repeat == RepeatMode::All => Some(0), Some(_) => None, None => Some(0), } }; match next { Some(i) => self.play_index(i), None => self.advance_radio(auto), } } fn advance_radio(&mut self, auto: bool) { let next = self.result_cursor.map(|c| c + 1).filter(|&i| i < self.radio.len()); match next { Some(i) => self.play_radio(i), None if auto => { self.stop_playback(); self.info("Queue finished"); } None => self.info("End of queue"), } } fn seek(&mut self, amount: Amount) { if !matches!(self.play_state, PlayState::Playing | PlayState::Paused) { return self.error("Nothing is playing"); } let r = match amount { Amount::Delta(d) => self.with_player(|p| p.seek_relative(d)), Amount::Abs(a) => self.with_player(|p| p.seek_absolute(a)), }; match r { Ok(()) => { self.position = match amount { Amount::Delta(d) => (self.position + d).max(0.0), Amount::Abs(a) => a, }; } Err(e) => self.error(format!("{e:#}")), } } fn set_volume(&mut self, amount: Amount) { let v = match amount { Amount::Abs(a) => a, Amount::Delta(d) => self.volume as f64 + d, } .round() .clamp(0.0, 100.0) as u8; self.volume = v; if let Some(p) = self.player.as_mut() { if let Err(e) = p.set_volume(v) { return self.error(format!("{e:#}")); } } self.info(format!("Volume: {v}%")); } fn toggle_shuffle(&mut self) { self.shuffle = !self.shuffle; self.played.clear(); if let Some(c) = self.current { self.played.insert(c); } self.info(format!("Shuffle: {}", if self.shuffle { "on" } else { "off" })); } fn cycle_repeat(&mut self) { self.repeat = self.repeat.cycle(); self.info(format!("Repeat: {}", self.repeat.label())); } fn enqueue(&mut self, t: Track) { let label = t.label(); self.queue.push(t); self.info(format!("Queued: {label}")); } fn add_selected(&mut self) { let i = self.selected(); match self.view { View::Results => match self.results.get(i).cloned() { Some(t) => self.enqueue(t), None => self.error("No result selected"), }, View::Playlists if self.in_playlist() => { let track = self .open .as_ref() .and_then(|n| self.store.playlists.get(n)) .and_then(|l| l.get(i)) .cloned(); match track { Some(t) => self.enqueue(t), None => self.error("No track selected"), } } View::Playlists => match self.playlist_name(i) { Some(n) => self.load_playlist(&n, false), None => self.error("No playlist selected"), }, View::Queue => self.info("Already in the queue"), } } fn add_all_results(&mut self) { if self.results.is_empty() { return self.error("No results to add"); } let n = self.results.len(); self.queue.extend(self.results.iter().cloned()); self.info(format!("Queued {n} tracks")); } fn play_all_results(&mut self) { if self.results.is_empty() { return self.error("No results to play"); } let start = if self.view == View::Results { self.selected() } else { 0 }; self.queue = self.results.clone(); self.played.clear(); self.current = None; self.result_cursor = None; self.play_index(start.min(self.queue.len() - 1)); } fn clear_queue(&mut self) { self.queue.clear(); self.current = None; self.played.clear(); if !self.on_radio { self.stop_playback(); } self.states[View::Queue.idx()].select(None); self.info("Queue cleared"); } fn remove_from_queue(&mut self, i: usize) { if i >= self.queue.len() { return self.error("No such queue entry"); } let removed = self.queue.remove(i); self.played.clear(); let active = self.play_state != PlayState::Stopped; match self.current { Some(c) if c == i && self.on_radio => self.current = i.checked_sub(1), Some(c) if c == i => { if self.queue.is_empty() { self.current = None; self.stop_playback(); } else if active { self.play_index(i.min(self.queue.len() - 1)); } else { self.current = Some(i.min(self.queue.len() - 1)); } } Some(c) if c > i => self.current = Some(c - 1), _ => {} } let sel = self.states[View::Queue.idx()].selected().unwrap_or(0); let len = self.queue.len(); self.states[View::Queue.idx()].select(if len == 0 { None } else { Some(sel.min(len - 1)) }); self.info(format!("Removed: {}", removed.label())); } fn move_queue_item(&mut self, dir: isize) { if self.view != View::Queue { return; } let i = self.selected(); let j = i as isize + dir; if i >= self.queue.len() || j < 0 || j as usize >= self.queue.len() { return; } let j = j as usize; self.queue.swap(i, j); self.played.clear(); if self.current == Some(i) { self.current = Some(j); } else if self.current == Some(j) { self.current = Some(i); } self.set_selected(j); } fn delete_selected(&mut self) { let i = self.selected(); match self.view { View::Queue => self.remove_from_queue(i), View::Playlists if self.in_playlist() => self.remove_playlist_track(i), View::Playlists => match self.playlist_name(i) { Some(n) => self.delete_playlist(&n), None => {} }, View::Results => self.info("Results can't be deleted — they are replaced by the next search"), } } fn persist(&mut self) -> bool { match self.store.save() { Ok(()) => true, Err(e) => { self.error(format!("Could not save playlists: {e:#}")); false } } } fn save_playlist(&mut self, name: &str) { if self.queue.is_empty() { return self.error("Queue is empty — nothing to save"); } let n = self.queue.len(); self.store.playlists.insert(name.to_string(), self.queue.clone()); if self.persist() { self.info(format!("Saved {n} tracks to playlist \u{201c}{name}\u{201d}")); } } fn add_to_playlist(&mut self, name: &str) { let i = self.selected(); let track = match self.view { View::Results => self.results.get(i).cloned(), View::Queue => self.queue.get(i).cloned(), View::Playlists => self .open .as_ref() .and_then(|n| self.store.playlists.get(n)) .and_then(|l| l.get(i)) .cloned(), }; let Some(track) = track else { return self.error("Select a track in Results or Queue first"); }; let key = self.store.resolve(name).unwrap_or_else(|| name.to_string()); let list = self.store.playlists.entry(key.clone()).or_default(); if list.iter().any(|t| t.id == track.id) { return self.info(format!("Already in \u{201c}{key}\u{201d}")); } let label = track.label(); list.push(track); if self.persist() { self.info(format!("Added {label} to \u{201c}{key}\u{201d}")); } } fn load_playlist(&mut self, name: &str, replace: bool) { let Some(tracks) = self.store.playlists.get(name).cloned() else { return self.error(format!("no playlist named '{name}'")); }; if tracks.is_empty() { return self.error(format!("Playlist \u{201c}{name}\u{201d} is empty")); } let n = tracks.len(); if replace { self.queue = tracks; self.played.clear(); self.current = None; self.result_cursor = None; self.states[View::Queue.idx()].select(Some(0)); self.play_index(0); self.info(format!("Playing playlist \u{201c}{name}\u{201d} ({n} tracks)")); } else { self.queue.extend(tracks); self.info(format!("Appended \u{201c}{name}\u{201d} ({n} tracks) to the queue")); } } fn open_selected_playlist(&mut self) { let Some(name) = self.playlist_name(self.selected()) else { return; }; let len = self.store.playlists.get(&name).map_or(0, |l| l.len()); self.open = Some(name); self.pl_state.select(if len == 0 { None } else { Some(0) }); } fn close_playlist(&mut self) { self.open = None; } fn play_playlist_from(&mut self, name: &str, i: usize) { let Some(tracks) = self.store.playlists.get(name).cloned() else { return self.error(format!("no playlist named '{name}'")); }; if tracks.is_empty() { return self.error(format!("Playlist \u{201c}{name}\u{201d} is empty")); } let i = i.min(tracks.len() - 1); self.queue = tracks; self.played.clear(); self.current = None; self.result_cursor = None; self.states[View::Queue.idx()].select(Some(i)); self.play_index(i); } fn remove_playlist_track(&mut self, i: usize) { let Some(name) = self.open.clone() else { return }; let removed = { let Some(list) = self.store.playlists.get_mut(&name) else { return }; if i >= list.len() { None } else { let t = list.remove(i); Some((t, list.len())) } }; let Some((track, len)) = removed else { return self.error("No track selected"); }; self.pl_state.select(if len == 0 { None } else { Some(i.min(len - 1)) }); if self.persist() { self.info(format!("Removed from \u{201c}{name}\u{201d}: {}", track.label())); } } fn move_item(&mut self, dir: isize) { if self.in_playlist() { return self.move_playlist_track(dir); } self.move_queue_item(dir); } fn move_playlist_track(&mut self, dir: isize) { let Some(name) = self.open.clone() else { return }; let i = self.selected(); let j = i as isize + dir; let moved = match self.store.playlists.get_mut(&name) { Some(list) if j >= 0 && (j as usize) < list.len() && i < list.len() => { list.swap(i, j as usize); true } _ => false, }; if moved { self.set_selected(j as usize); self.persist(); } } fn delete_playlist(&mut self, name: &str) { if self.store.playlists.remove(name).is_some() && self.persist() { if self.open.as_deref() == Some(name) { self.open = None; } self.info(format!("Deleted playlist \u{201c}{name}\u{201d}")); let sel = self.selected(); self.set_selected(sel); } } } #[cfg(test)] mod tests { use super::*; use std::sync::mpsc; fn track(id: &str, title: &str) -> Track { Track { id: id.into(), title: title.into(), artist: "Artist".into(), album: None, duration: Some(100), } } fn press(app: &mut App, code: KeyCode) { app.on_key(KeyEvent::new(code, KeyModifiers::NONE)); } fn check_artist_popup(app: &mut App) { let mut t = track("zzzzzzzzzzz", "Duet"); t.artist = "A & B".into(); app.results = vec![t]; app.states[View::Results.idx()].select(Some(0)); app.view = View::Results; app.go_to_artist(); assert!(app.mode == Mode::ArtistPick); assert_eq!(app.artist_opts, ["A", "B", "A & B"]); press(app, KeyCode::Down); assert_eq!(app.artist_sel, 1); press(app, KeyCode::Esc); assert!(app.mode == Mode::Normal); assert!(app.artist_opts.is_empty()); } #[test] fn playlist_drill_in() { let dir = std::env::temp_dir().join(format!("drift-test-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); std::env::set_var("XDG_CONFIG_HOME", &dir); std::env::set_var("XDG_STATE_HOME", &dir); let (tx, _rx) = mpsc::channel(); let mut app = App::new(tx); app.store.playlists.insert( "mix".into(), vec![track("aaaaaaaaaaa", "A"), track("bbbbbbbbbbb", "B"), track("ccccccccccc", "C")], ); app.store.playlists.insert("other".into(), vec![track("ddddddddddd", "D")]); press(&mut app, KeyCode::Tab); press(&mut app, KeyCode::Tab); assert_eq!(app.view, View::Playlists); assert!(!app.in_playlist()); press(&mut app, KeyCode::Right); assert!(app.in_playlist()); assert_eq!(app.open.as_deref(), Some("mix")); assert_eq!(app.selected(), 0); press(&mut app, KeyCode::Down); press(&mut app, KeyCode::Down); assert_eq!(app.selected(), 2); press(&mut app, KeyCode::Down); assert_eq!(app.selected(), 2); press(&mut app, KeyCode::Char('K')); let ids: Vec<&str> = app.store.playlists["mix"].iter().map(|t| t.id.as_str()).collect(); assert_eq!(ids, ["aaaaaaaaaaa", "ccccccccccc", "bbbbbbbbbbb"]); assert_eq!(app.selected(), 1); press(&mut app, KeyCode::Char('x')); let ids: Vec<&str> = app.store.playlists["mix"].iter().map(|t| t.id.as_str()).collect(); assert_eq!(ids, ["aaaaaaaaaaa", "bbbbbbbbbbb"]); assert_eq!(app.selected(), 1); press(&mut app, KeyCode::Char('d')); press(&mut app, KeyCode::Char('d')); assert_eq!(app.store.playlists["mix"].len(), 1); assert_eq!(app.selected(), 0); assert_eq!(app.store.playlists.len(), 2); let saved = std::fs::read_to_string(dir.join("drift").join("playlists.json")).unwrap(); assert!(saved.contains("aaaaaaaaaaa") && !saved.contains("bbbbbbbbbbb")); press(&mut app, KeyCode::Char('a')); assert_eq!(app.queue.len(), 1); press(&mut app, KeyCode::Left); assert!(!app.in_playlist()); assert_eq!(app.open, None); assert_eq!(app.store.playlists.len(), 2); press(&mut app, KeyCode::Right); assert!(app.in_playlist()); press(&mut app, KeyCode::Esc); assert!(!app.in_playlist()); press(&mut app, KeyCode::Right); press(&mut app, KeyCode::Tab); assert_eq!(app.open, None); check_artist_popup(&mut app); let _ = std::fs::remove_dir_all(&dir); } }