Skip to main content

radio_cli/
engine.rs

1pub(crate) mod artwork;
2mod persistence;
3mod playback;
4mod queue;
5mod recording;
6mod status;
7use playback::PlaybackController;
8use recording::RecordingController;
9pub use status::{PlaybackState, RecordingState};
10
11use crate::error::{DomainError, ErrorCode};
12use crate::{
13    config::Config,
14    directory::Directory,
15    model::{Filter, Station},
16    player::{Event, Player},
17    process::{Background, MediaLock},
18    recorder::{self, Recorder},
19    store::Store,
20};
21use anyhow::{Context, Result, bail};
22use std::{
23    collections::VecDeque,
24    sync::{Arc, atomic::AtomicBool},
25    time::{Duration, Instant},
26};
27
28#[derive(Debug, Clone, PartialEq)]
29pub struct Status {
30    pub sleep_remaining: Option<u64>,
31    pub podcast_auto_next: bool,
32    pub skip_back: u32,
33    pub skip_forward: u32,
34    pub episode: Option<crate::podcast::Episode>,
35    pub seekable: bool,
36    pub speed: f64,
37    pub station: Option<Station>,
38    pub title: String,
39    pub message: String,
40    pub playback_state: PlaybackState,
41    pub volume: u8,
42    pub muted: bool,
43    pub recording_state: RecordingState,
44    pub recording_ms: u64,
45    pub recording_path: String,
46    pub source_url: String,
47}
48
49impl Status {
50    pub(crate) fn control_eq(&self, other: &Self) -> bool {
51        self.episode
52            .as_ref()
53            .map(|e| (&e.id, e.completed, e.observed_duration_ms))
54            == other
55                .episode
56                .as_ref()
57                .map(|e| (&e.id, e.completed, e.observed_duration_ms))
58            && self.seekable == other.seekable
59            && self.sleep_remaining == other.sleep_remaining
60            && self.podcast_auto_next == other.podcast_auto_next
61            && self.skip_back == other.skip_back
62            && self.skip_forward == other.skip_forward
63            && self.speed == other.speed
64            && self.station == other.station
65            && self.title == other.title
66            && self.message == other.message
67            && self.playback_state == other.playback_state
68            && self.recording_state == other.recording_state
69            && self.volume == other.volume
70            && self.muted == other.muted
71            && self.recording_path == other.recording_path
72            && self.source_url == other.source_url
73    }
74    pub(crate) fn ui_eq(&self, other: &Self) -> bool {
75        self.control_eq(other)
76            && self.recording_ms / 1000 == other.recording_ms / 1000
77            && self.episode.as_ref().map(|e| e.position_ms / 1000)
78                == other.episode.as_ref().map(|e| e.position_ms / 1000)
79    }
80    pub fn playing(&self) -> bool {
81        matches!(
82            self.playback_state,
83            PlaybackState::Playing | PlaybackState::Paused
84        )
85    }
86    pub fn paused(&self) -> bool {
87        self.playback_state == PlaybackState::Paused
88    }
89    pub fn recording(&self) -> bool {
90        matches!(
91            self.recording_state,
92            RecordingState::Probing | RecordingState::Recording
93        )
94    }
95}
96
97pub struct Engine {
98    podcast_runtime: crate::podcast::Runtime,
99    session: Session,
100    playback: PlaybackController,
101    recording: RecordingController,
102}
103
104/// Shared services and published session state owned by the engine.
105pub(crate) struct Session {
106    persistence: Option<persistence::Writer>,
107    pub subtitles: crate::speech::Controller,
108    pub(crate) artwork: artwork::Controller,
109    pub config: Config,
110    pub store: Store,
111    pub directory: Directory,
112    pub status: Status,
113    // Session preferences survive playback resets and pending database writes.
114    pub podcast_speed: f64,
115    pub podcast_auto_next: bool,
116    pub stop: Arc<AtomicBool>,
117    pub(crate) _lock: Arc<MediaLock>,
118    pub(crate) background_media: bool,
119    pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
120    pub(crate) library_task: Option<Background<String>>,
121    pub playback_failed: bool,
122}
123
124impl Session {
125    pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
126        if let Some(writer) = &self.persistence {
127            writer.preference(key, value)
128        } else {
129            if let Some(id) = key.strip_prefix("podcast_progress:") {
130                self.store
131                    .podcast_save_progress(id, &serde_json::from_str(value)?)
132            } else if let Some(id) = key.strip_prefix("podcast_played:") {
133                self.store.podcast_played(id)
134            } else {
135                self.store.set_meta(key, value)
136            }
137        }
138    }
139
140    fn remember_play(&self, uuid: &str) -> Result<()> {
141        if let Some(writer) = &self.persistence {
142            writer.played(uuid)?;
143            writer.preference("pref_last_media", "station")
144        } else {
145            self.store.played(uuid)?;
146            self.store.set_meta("pref_last_media", "station")?;
147            self.store.set_meta("pref_last_station", uuid)
148        }
149    }
150}
151
152impl Engine {
153    pub fn status(&self) -> &Status {
154        &self.session.status
155    }
156
157    pub fn config(&self) -> &Config {
158        &self.session.config
159    }
160
161    pub fn store(&self) -> &Store {
162        &self.session.store
163    }
164
165    #[cfg(test)]
166    pub(crate) fn test_store_mut(&mut self) -> &mut Store {
167        &mut self.session.store
168    }
169
170    pub fn subtitles(&self) -> &crate::speech::Snapshot {
171        &self.session.subtitles.snapshot
172    }
173
174    pub fn playback_failed(&self) -> bool {
175        self.session.playback_failed
176    }
177
178    /// Add, edit, remove, or change backup URLs without exposing session state.
179    pub fn change_station(
180        &mut self,
181        command: crate::service::StationCommand,
182    ) -> Result<crate::service::StationChange> {
183        crate::service::change_station(&mut self.session.store, command)
184    }
185
186    /// Atomically toggle a favorite and return its new state.
187    pub fn toggle_favorite(&mut self, uuid: &str) -> Result<bool> {
188        self.session.store.toggle_favorite(uuid)
189    }
190
191    pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
192        self.session.save_preference(key, value)
193    }
194
195    pub(crate) fn set_language(&mut self, language: String) {
196        crate::messages::init(Some(&language), None);
197        self.session.config.settings.language = Some(language.clone());
198        self.session.status.message = crate::t!("language_set", "language" => language);
199    }
200
201    pub(crate) fn request_artwork(&mut self, station: Option<String>) {
202        self.session.artwork.demand = station;
203    }
204
205    pub(crate) fn track_artwork(&self) -> &Option<artwork::TrackArtwork> {
206        &self.session.artwork.cover
207    }
208
209    pub(crate) fn start_diagnostics(&mut self) -> Result<()> {
210        if self.session.diagnostics.is_some() {
211            bail!(crate::t!("diagnostics_busy"));
212        }
213        let config = self.session.config.clone();
214        self.session.diagnostics = Some(Background::start("radio-doctor", move |cancel| {
215            crate::service::doctor_report(&config, &cancel)
216        })?);
217        Ok(())
218    }
219
220    pub(crate) fn poll_diagnostics(&mut self) -> Option<Result<(serde_json::Value, bool)>> {
221        let result = self.session.diagnostics.as_ref()?.poll()?;
222        self.session.diagnostics = None;
223        Some(result)
224    }
225
226    pub(crate) fn stop(&mut self) -> Result<()> {
227        self.stop_playback()?;
228        self.session.status.message = crate::t!("playback_stopped").into();
229        Ok(())
230    }
231
232    #[cfg(test)]
233    pub(crate) fn test_session(&mut self) -> &mut Session {
234        &mut self.session
235    }
236
237    pub fn bootstrap(&mut self) -> Result<usize> {
238        self.session.directory.bootstrap(&mut self.session.store)
239    }
240
241    /// Fetch and publish a full catalog. This call performs blocking I/O.
242    pub fn sync(&mut self, progress: impl FnMut(usize)) -> Result<usize> {
243        self.sync_with_policy(progress, false)
244    }
245
246    /// Sync with explicit permission to accept a catalog shrink over 25%.
247    /// This call performs blocking I/O.
248    pub fn sync_with_policy(
249        &mut self,
250        progress: impl FnMut(usize),
251        accept_shrink: bool,
252    ) -> Result<usize> {
253        self.session
254            .directory
255            .sync_with_policy(&mut self.session.store, progress, accept_shrink)
256    }
257
258    /// Fetch current directory metadata without persisting it. Performs I/O.
259    pub fn refresh_station(&mut self, uuid: &str) -> Result<Option<Station>> {
260        self.session.directory.refresh(uuid)
261    }
262
263    /// Report a confirmed play to the directory. This call performs blocking I/O.
264    pub fn report_click(&mut self, uuid: &str) -> Result<()> {
265        self.session.directory.click(uuid)
266    }
267    pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
268        let lock = MediaLock::acquire(&config.runtime_dir)?;
269        let store = Store::open(&config.data_dir.join("radio.db"))?;
270        if let Some(volume) = store
271            .meta("pref_volume")?
272            .and_then(|v| v.parse::<u8>().ok())
273            .filter(|v| *v <= 100)
274        {
275            config.settings.volume = volume;
276        }
277        let podcast_speed = store
278            .meta("podcast_speed")?
279            .and_then(|v| v.parse().ok())
280            .unwrap_or(1.);
281        let podcast_auto_next = store.meta("podcast_auto_next")?.as_deref() == Some("on");
282        let recovery_warnings = recorder::recover(&store)?;
283        let directory = Directory::new(&config, stop.clone())?;
284        let status = Status {
285            sleep_remaining: None,
286            podcast_auto_next: false,
287            skip_back: 15,
288            skip_forward: 15,
289            episode: None,
290            seekable: false,
291            speed: 1.,
292            station: None,
293            title: String::new(),
294            message: if recovery_warnings.is_empty() {
295                crate::t!("status_ready").into()
296            } else {
297                recovery_warnings.join("\n")
298            },
299            playback_state: PlaybackState::Idle,
300            volume: config.settings.volume,
301            muted: false,
302            recording_state: RecordingState::Idle,
303            recording_ms: 0,
304            recording_path: String::new(),
305            source_url: String::new(),
306        };
307        Ok(Self {
308            podcast_runtime: Default::default(),
309            session: Session {
310                persistence: None,
311                subtitles: crate::speech::Controller::default(),
312                artwork: artwork::Controller::default(),
313                config,
314                store,
315                directory,
316                status,
317                podcast_speed,
318                podcast_auto_next,
319                stop,
320                _lock: Arc::new(lock),
321                background_media: false,
322                diagnostics: None,
323                library_task: None,
324                playback_failed: false,
325            },
326            playback: PlaybackController {
327                sleep_deadline: None,
328                sleep_end: false,
329                show_settings: Default::default(),
330                episode: None,
331                progress: Default::default(),
332                seek_request: None,
333                loaded: false,
334                resume_pending: false,
335                resume_blocked: false,
336                last_save: Instant::now(),
337                queue_mode: false,
338                auto_next: false,
339                queue_completions: Default::default(),
340                generation: 0,
341                refresh_task: None,
342                click_task: None,
343                player: None,
344                player_start: None,
345                retiring: vec![],
346                url: String::new(),
347                candidates: VecDeque::new(),
348                tried: vec![],
349                refreshed: false,
350                confirmed: false,
351                session_started: false,
352                source_kind: playback::SourceKind::Catalog,
353                local_recording_id: None,
354                reconnect_attempts: 0,
355                reconnect_due: None,
356                reconnect_window: VecDeque::new(),
357                started: Instant::now(),
358                random_filter: None,
359                random_tried: vec![],
360                failure: None,
361            },
362            recording: RecordingController {
363                recording_probe: None,
364                retiring_probes: vec![],
365                finalizing: None,
366                recorder: None,
367            },
368        })
369    }
370
371    pub fn play_episode(&mut self, id: &str, from_start: bool, speed: Option<f64>) -> Result<()> {
372        if self.podcast_runtime.cleaning(id) {
373            anyhow::bail!(crate::t!("podcast_download_busy"));
374        }
375        self.playback.play_episode(
376            &mut self.session,
377            &mut self.recording,
378            id,
379            from_start,
380            speed,
381        )
382    }
383    pub fn play_podcast_queue(&mut self, auto_next: bool) -> Result<()> {
384        let id = self
385            .store()
386            .podcast_queue()?
387            .first()
388            .map(|e| e.id.clone())
389            .context(crate::t!("podcast_empty_queue"))?;
390        self.play_episode(&id, false, None)?;
391        self.playback.queue_mode = true;
392        self.playback.auto_next = auto_next;
393        Ok(())
394    }
395    pub fn seek_episode(&mut self, position: u64) -> Result<()> {
396        self.playback.seek_episode(&mut self.session, position)
397    }
398    pub fn podcast_speed(&mut self, rate: f64) -> Result<()> {
399        crate::podcast::valid_speed(rate)?;
400        if let Some(p) = self.playback.player.as_mut()
401            && self.playback.episode.is_some()
402        {
403            p.request(serde_json::json!(["set_property", "speed", rate]))?;
404        }
405        self.session.podcast_speed = rate;
406        self.session.status.speed = rate;
407        self.session
408            .save_preference("podcast_speed", &rate.to_string())
409    }
410    pub fn podcast_auto_next(&mut self, on: bool) -> Result<()> {
411        self.session.status.podcast_auto_next = on;
412        self.session.podcast_auto_next = on;
413        self.playback.auto_next = on;
414        self.session
415            .save_preference("podcast_auto_next", if on { "on" } else { "off" })
416    }
417    pub fn play(&mut self, uuid: &str) -> Result<()> {
418        let result = self
419            .playback
420            .play(&mut self.session, &mut self.recording, uuid);
421        if let Err(error) = &result
422            && !self.playback_active()
423        {
424            self.session.status.playback_state = PlaybackState::Failed {
425                reason: format!("{error:#}"),
426            };
427        }
428        result
429    }
430
431    pub fn resume_last_station(&mut self) -> Result<()> {
432        self.playback
433            .resume_last_station(&mut self.session, &mut self.recording)
434    }
435
436    pub fn play_recording(&mut self, id: &str) -> Result<()> {
437        let result = self
438            .playback
439            .play_recording(&mut self.session, &mut self.recording, id);
440        if let Err(error) = &result
441            && !self.playback_active()
442        {
443            self.session.status.playback_state = PlaybackState::Failed {
444                reason: format!("{error:#}"),
445            };
446        }
447        result
448    }
449
450    pub fn random(&mut self, filter: Filter) -> Result<()> {
451        let result = self
452            .playback
453            .random(&mut self.session, &mut self.recording, filter);
454        if let Err(error) = &result
455            && !self.playback_active()
456        {
457            self.session.status.playback_state = PlaybackState::Failed {
458                reason: format!("{error:#}"),
459            };
460        }
461        result
462    }
463
464    pub(crate) fn current_podcast_action(
465        &mut self,
466        mut action: crate::podcast::Action,
467    ) -> Result<()> {
468        let episode = self
469            .session
470            .status
471            .episode
472            .as_ref()
473            .filter(|_| self.session.status.playing())
474            .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
475        let id = action
476            .episode_id_mut()
477            .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
478        *id = episode.id.clone();
479        self.podcast_action(action)
480    }
481
482    pub fn podcast_action(&mut self, mut action: crate::podcast::Action) -> Result<()> {
483        use crate::podcast::{Action, DownloadAction, QueueAction};
484        if let Some(id) = action.episode_id_mut() {
485            *id = self.store().podcast_episode_id(id)?;
486        }
487        if let Action::Queue {
488            action: QueueAction::Next { after, .. },
489        } = &mut action
490        {
491            *after = self
492                .playback
493                .queue_mode
494                .then(|| self.playback.episode.as_ref().map(|e| e.id.clone()))
495                .flatten();
496        }
497        self.podcast_runtime
498            .follow_captions(self.session.status.episode.as_ref());
499        let show = matches!(&action, Action::Subtitles { id, .. } if self.status().playing() && self.status().episode.as_ref().is_some_and(|e| e.id == *id));
500        let result = match action {
501            Action::Sleep { value } => self.playback.set_sleep(&mut self.session, &value),
502            Action::Jump { id, time } => {
503                let target = crate::podcast::parse_time(&time)?;
504                if self.status().episode.as_ref().is_some_and(|e| e.id == id) {
505                    self.seek_episode(target)
506                } else {
507                    self.play_episode(&id, false, None)?;
508                    self.playback.episode.as_mut().unwrap().position_ms = target;
509                    self.playback.resume_pending = target > 0;
510                    Ok(())
511                }
512            }
513            Action::Bookmark {
514                id,
515                time: None,
516                note,
517            } => {
518                let episode = self
519                    .status()
520                    .episode
521                    .as_ref()
522                    .filter(|e| e.id == id)
523                    .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
524                self.store()
525                    .podcast_add_bookmark(&id, episode.position_ms, &note)?;
526                Ok(())
527            }
528            Action::Resume => {
529                let id = self
530                    .store()
531                    .meta("pref_last_episode")?
532                    .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
533                self.play_episode(&id, false, None)
534            }
535            Action::Relative { seconds } => {
536                if !seconds.is_finite() || seconds.abs() > 86400. {
537                    anyhow::bail!(crate::t!("podcast_invalid_time"));
538                }
539                self.playback.seek_relative(&mut self.session, seconds)
540            }
541            Action::Play {
542                id,
543                from_start,
544                speed,
545            } => self.play_episode(&id, from_start, speed),
546            Action::Queue {
547                action: QueueAction::Start { id, auto_next },
548            } => {
549                if !self.store().podcast_queue()?.iter().any(|e| e.id == id) {
550                    anyhow::bail!(crate::t!("podcast_not_found"));
551                }
552                self.play_episode(&id, false, None)?;
553                self.playback.queue_mode = true;
554                self.playback.auto_next = auto_next || self.session.podcast_auto_next;
555                Ok(())
556            }
557            Action::Queue {
558                action: QueueAction::Play { auto_next },
559            } => self.play_podcast_queue(auto_next || self.session.podcast_auto_next),
560            Action::Seek { time } => self.seek_episode(crate::podcast::parse_time(&time)?),
561            Action::Speed { rate } => self.podcast_speed(rate),
562            Action::MarkBatch { ids, unplayed } => {
563                // Validate all targets before changing the player or any progress.
564                let mut episodes = ids
565                    .iter()
566                    .map(|id| self.store().podcast_episode(id))
567                    .collect::<Result<Vec<_>>>()?;
568                let ids = episodes.iter().map(|e| e.id.clone()).collect::<Vec<_>>();
569                if self
570                    .playback
571                    .episode
572                    .as_ref()
573                    .is_some_and(|e| ids.contains(&e.id))
574                {
575                    self.stop_playback()?;
576                    self.playback.episode = None;
577                }
578                let mut rows = Vec::new();
579                for e in &mut episodes {
580                    e.completed = !unplayed;
581                    e.position_ms = if unplayed {
582                        0
583                    } else {
584                        e.observed_duration_ms
585                            .or(e.duration_ms)
586                            .unwrap_or(e.position_ms)
587                    };
588                    self.playback.progress.insert(e.id.clone(), e.clone());
589                    if self.status().episode.as_ref().is_some_and(|p| p.id == e.id) {
590                        self.session.status.episode = Some(e.clone());
591                    }
592                    rows.push((e.id.clone(), e.progress()));
593                }
594                if let Some(writer) = &self.session.persistence {
595                    let updates = rows
596                        .iter()
597                        .map(|(id, progress)| {
598                            Ok((
599                                format!("podcast_progress:{id}"),
600                                serde_json::to_string(progress)?,
601                            ))
602                        })
603                        .collect::<Result<Vec<_>>>()?;
604                    writer.preferences(updates)
605                } else {
606                    let tx = rusqlite::Transaction::new_unchecked(
607                        &self.store().conn,
608                        rusqlite::TransactionBehavior::Immediate,
609                    )?;
610                    for (id, progress) in rows {
611                        Store::write_podcast_progress(&tx, &id, &progress)?;
612                    }
613                    tx.commit()?;
614                    Ok(())
615                }
616            }
617            Action::Mark { id, state } => {
618                let mut e = self.session.store.podcast_episode(&id)?;
619                if self.playback.episode.as_ref().is_some_and(|e| e.id == id) {
620                    self.stop_playback()?;
621                    self.playback.episode = None;
622                }
623                e.completed = state == "played";
624                e.position_ms = if e.completed {
625                    e.observed_duration_ms.unwrap_or(e.position_ms)
626                } else {
627                    0
628                };
629                self.playback.progress.insert(id.clone(), e.clone());
630                if self
631                    .session
632                    .status
633                    .episode
634                    .as_ref()
635                    .is_some_and(|p| p.id == id)
636                {
637                    self.session.status.episode = Some(e.clone());
638                }
639                self.session.save_preference(
640                    &format!("podcast_progress:{id}"),
641                    &serde_json::to_string(&e.progress())?,
642                )
643            }
644            Action::AutoNext { state } => self.podcast_auto_next(state == "on"),
645            Action::Downloads {
646                action: DownloadAction::Remove { ref id },
647            } if self.podcast_runtime.download_active(id) => {
648                Err(crate::podcast::error(crate::t!("podcast_download_busy")))
649            }
650            Action::Downloads {
651                action: DownloadAction::Remove { ref id },
652            } if self.playback_active()
653                && self
654                    .store()
655                    .podcast_download(id)?
656                    .is_some_and(|d| !d.path.is_empty() && d.path == self.playback.url) =>
657            {
658                Err(crate::podcast::error(crate::t!("podcast_download_in_use")))
659            }
660            action => self.podcast_runtime.action(
661                &self.session.config,
662                action,
663                self.session._lock.clone(),
664            ),
665        };
666        if result.is_ok() && show {
667            self.set_subtitles(true);
668        }
669        result
670    }
671    pub(crate) fn show_podcast_subtitles(&mut self, id: &str) -> Result<()> {
672        // Resolve the frozen menu target at execution time. Playback may have
673        // advanced after the menu opened or while this command was queued.
674        if !self.playback_active() || self.playback.episode.as_ref().is_none_or(|e| e.id != id) {
675            self.play_episode(id, false, None)?;
676        }
677        self.set_subtitles(true);
678        Ok(())
679    }
680    pub(crate) fn subtitle_progress(&self) -> Option<u64> {
681        self.podcast_runtime.subtitle_progress()
682    }
683    pub fn podcast_tasks(&self) -> (usize, bool) {
684        self.podcast_runtime.tasks()
685    }
686    pub(crate) fn poll_podcast_browse(&mut self) -> Option<Result<serde_json::Value>> {
687        self.podcast_runtime.poll_browse()
688    }
689    pub fn poll_podcast(&mut self) -> Option<Result<serde_json::Value>> {
690        self.podcast_runtime
691            .poll_browse()
692            .or_else(|| self.podcast_runtime.poll())
693    }
694    pub(crate) fn poll_podcast_operation(&mut self) -> Option<Result<serde_json::Value>> {
695        self.podcast_runtime.poll()
696    }
697    pub(crate) fn poll_podcast_subtitles(&mut self) -> Option<Result<serde_json::Value>> {
698        let current = self
699            .session
700            .status
701            .episode
702            .as_ref()
703            .is_some_and(|e| self.podcast_runtime.subtitle_target() == Some(e.id.as_str()));
704        let result = self.podcast_runtime.poll_subtitles()?;
705        if current {
706            self.session.subtitles.retry();
707        }
708        Some(result)
709    }
710    pub(crate) fn cancel_podcast_subtitles(&mut self) {
711        self.podcast_runtime.cancel_subtitles();
712        self.session.subtitles.retry();
713    }
714    pub(crate) fn cancel_podcast_subtitles_for(&mut self, id: &str) -> Result<()> {
715        self.podcast_runtime.cancel_subtitles_for(id)?;
716        self.session.subtitles.retry();
717        Ok(())
718    }
719    pub(crate) fn cancel_podcast_browse(&mut self) {
720        self.podcast_runtime.cancel_browse();
721    }
722    pub fn cancel_podcast(&mut self) -> bool {
723        let cancelled = self.podcast_runtime.cancel();
724        if cancelled {
725            self.session.subtitles.retry();
726        }
727        cancelled
728    }
729    pub fn tick(&mut self) -> Result<()> {
730        if self.session.background_media {
731            self.podcast_runtime
732                .follow_captions(self.session.status.episode.as_ref());
733            self.podcast_runtime
734                .tick(&self.session.config, self.session._lock.clone())?;
735        }
736        self.playback
737            .sleep_tick(&mut self.session, Instant::now())?;
738        self.poll_background()?;
739        self.playback.tick(&mut self.session, &mut self.recording)?;
740        self.recording
741            .recording_tick(&mut self.session, &mut self.playback)?;
742        self.subtitle_tick();
743        self.artwork_tick();
744        Ok(())
745    }
746
747    fn subtitle_tick(&mut self) {
748        if !self.session.background_media {
749            return;
750        }
751        if self.session.subtitles.snapshot.enabled && !self.session.artwork.quiescent() {
752            self.session.artwork.cancel();
753            return;
754        }
755        let playing = self.session.status.playback_state == PlaybackState::Playing;
756        let paused = self.session.status.paused();
757        let local = self.playback.source_kind == playback::SourceKind::Local;
758        let generation = self.playback.generation;
759        if let Some(episode) = &self.session.status.episode {
760            self.podcast_runtime.follow_captions(Some(episode));
761            self.session.subtitles.update_episode(
762                &self.session.config,
763                generation,
764                episode,
765                playing || paused,
766            );
767            let reset = !self
768                .session
769                .subtitles
770                .incremental_episode(generation, episode);
771            if self.session.subtitles.snapshot.enabled
772                && let Some(update) = self.podcast_runtime.caption_update(episode, reset)
773            {
774                self.session
775                    .subtitles
776                    .publish_episode(generation, episode, update);
777            }
778            return;
779        }
780        let session = &mut self.session;
781        let key = (generation, session.status.source_url.as_str());
782        session
783            .subtitles
784            .update(&session.config, key, playing, paused, local, &session.stop);
785    }
786
787    pub fn set_subtitles(&mut self, enabled: bool) {
788        self.session.subtitles.enabled(enabled);
789    }
790    pub fn retry_subtitles(&mut self) {
791        self.session.subtitles.retry();
792    }
793    pub fn clear_subtitles(&mut self) {
794        self.session.subtitles.clear();
795    }
796    pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
797        crate::speech::validate_model(&id)?;
798        let mut settings = self.session.config.settings.subtitles.clone();
799        settings.model = id;
800        settings.validate()?;
801        self.session.config.settings.subtitles = settings;
802        self.session.subtitles.retry();
803        self.session.subtitles.clear();
804        Ok(())
805    }
806
807    fn artwork_tick(&mut self) {
808        let request = (self.session.background_media
809            && !self.session.subtitles.snapshot.enabled
810            && self.session.subtitles.quiescent()
811            && self.session.config.settings.artwork == crate::config::ArtworkMode::Track
812            && self.session.status.playback_state == PlaybackState::Playing
813            && !matches!(
814                self.session.status.recording_state,
815                RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
816            )
817            && self.playback.source_kind != playback::SourceKind::Local
818            && self.playback.retiring.is_empty()
819            && self.recording.retiring_probes.is_empty()
820            && !self.session.status.title.is_empty())
821        .then_some(self.session.status.station.as_ref())
822        .flatten()
823        .filter(|station| {
824            station.hls == 0
825                && self.session.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
826        })
827        .filter(|_| crate::config::validate_url(&self.session.status.source_url).is_ok())
828        .map(|station| artwork::Request {
829            stationuuid: station.stationuuid.clone(),
830            source_url: self.session.status.source_url.clone(),
831            title: self.session.status.title.clone(),
832        });
833        let session = &mut self.session;
834        session.artwork.update(&session.config, request);
835    }
836
837    pub fn pause(&mut self) -> Result<()> {
838        self.playback.pause(&mut self.session, &mut self.recording)
839    }
840    pub fn mute(&mut self) -> Result<()> {
841        self.playback
842            .player
843            .as_mut()
844            .context(DomainError::new(ErrorCode::NotPlaying))?
845            .toggle_mute()
846    }
847
848    pub fn volume(&mut self, delta: i32) -> Result<()> {
849        self.playback
850            .volume(&mut self.session, &mut self.recording, delta)
851    }
852
853    pub fn stop_playback(&mut self) -> Result<()> {
854        self.playback
855            .stop_playback(&mut self.session, &mut self.recording)
856    }
857
858    pub fn toggle_recording(&mut self) -> Result<()> {
859        let result = self
860            .recording
861            .toggle_recording(&mut self.session, &mut self.playback);
862        if let Err(error) = &result
863            && self.recording.recorder.is_none()
864            && self.recording.recording_probe.is_none()
865            && self.recording.finalizing.is_none()
866        {
867            self.session.status.recording_state = RecordingState::Failed {
868                reason: format!("{error:#}"),
869            };
870        }
871        result
872    }
873
874    pub fn record_current(
875        &mut self,
876        duration: Option<Duration>,
877        dir: Option<&std::path::Path>,
878    ) -> Result<()> {
879        let result =
880            self.recording
881                .record_current(&mut self.session, &mut self.playback, duration, dir);
882        if let Err(error) = &result
883            && self.recording.recorder.is_none()
884            && self.recording.recording_probe.is_none()
885            && self.recording.finalizing.is_none()
886        {
887            self.session.status.recording_state = RecordingState::Failed {
888                reason: format!("{error:#}"),
889            };
890        }
891        result
892    }
893
894    pub fn standalone_record(
895        &mut self,
896        uuid: &str,
897        duration: Option<Duration>,
898        dir: Option<&std::path::Path>,
899    ) -> Result<()> {
900        let result = self.recording.standalone_record(
901            &mut self.session,
902            &mut self.playback,
903            uuid,
904            duration,
905            dir,
906        );
907        if let Err(error) = &result
908            && self.recording.recorder.is_none()
909            && self.recording.recording_probe.is_none()
910            && self.recording.finalizing.is_none()
911        {
912            self.session.status.recording_state = RecordingState::Failed {
913                reason: format!("{error:#}"),
914            };
915        }
916        result
917    }
918
919    pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
920        self.recording
921            .stop_recording(&mut self.session, &mut self.playback, reason)
922    }
923
924    pub(crate) fn enable_background_media(&mut self) -> Result<()> {
925        if self.session.persistence.is_none() {
926            self.session.persistence = Some(persistence::Writer::start(
927                self.session.config.data_dir.join("radio.db"),
928                self.session._lock.clone(),
929            )?);
930        }
931        self.session.background_media = true;
932        let enabled = self.session.config.settings.subtitles.enabled;
933        self.session.subtitles.enabled(enabled);
934        Ok(())
935    }
936
937    pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
938        if self.session.library_task.is_some() {
939            bail!(DomainError::new(ErrorCode::RecordingBusy));
940        }
941        if self.playback.local_recording_id.as_deref() == Some(&id) {
942            self.stop_playback()?;
943        }
944        let path = self.session.config.data_dir.join("radio.db");
945        let lock = self.session._lock.clone();
946        self.session.library_task = Some(Background::start(
947            "radio-recording-delete",
948            move |cancel| {
949                let _lock = lock;
950                if cancel.load(std::sync::atomic::Ordering::Relaxed) {
951                    bail!(DomainError::new(ErrorCode::Cancelled));
952                }
953                crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
954                Ok(crate::t!("recording_deleted", "id" => id))
955            },
956        )?);
957        Ok(())
958    }
959
960    pub fn open_recordings(&mut self) -> Result<()> {
961        if self.session.library_task.is_some() {
962            bail!(DomainError::new(ErrorCode::RecordingBusy));
963        }
964        let dir = self.session.config.recording_dir.clone();
965        self.session.library_task =
966            Some(Background::start("radio-open-recordings", move |cancel| {
967                crate::service::open_recordings(&dir, &cancel)?;
968                Ok(crate::t!("recordings_opened", "path" => dir.display()))
969            })?);
970        Ok(())
971    }
972
973    pub fn playback_active(&self) -> bool {
974        self.playback.player.is_some()
975            || self.playback.player_start.is_some()
976            || self.playback.refresh_task.is_some()
977            || self.playback.reconnect_due.is_some()
978            || self
979                .playback
980                .queue_completions
981                .active(self.playback.generation)
982    }
983
984    pub fn playback_error(&self) -> Option<&DomainError> {
985        self.playback.failure.as_ref()
986    }
987
988    pub fn shutdown(&mut self) -> Result<()> {
989        self.shutdown_with_budget(Duration::from_secs(6))
990    }
991
992    fn shutdown_with_budget(&mut self, budget: Duration) -> Result<()> {
993        self.podcast_runtime = Default::default();
994        let mut failure = self.stop_playback().err();
995        self.session.subtitles.enabled(false);
996        self.playback.click_task = None;
997        self.session.diagnostics = None;
998        self.session.library_task = None;
999        let deadline = Instant::now() + budget;
1000        if let Some(writer) = &self.session.persistence {
1001            writer.close(deadline);
1002        }
1003        // Allow normal finalization, then cancel verification if its budget
1004        // expires. Outstanding HTTP results never need joining.
1005        while (self.recording.finalizing.is_some()
1006            || !self.playback.queue_completions.is_empty()
1007            || !self.playback.retiring.is_empty()
1008            || !self.recording.retiring_probes.is_empty()
1009            || !self.session.artwork.quiescent()
1010            || !self.session.subtitles.quiescent()
1011            || self
1012                .session
1013                .persistence
1014                .as_ref()
1015                .is_some_and(|writer| !writer.finished()))
1016            && Instant::now() < deadline
1017        {
1018            if let Err(error) = self.poll_background() {
1019                failure.get_or_insert(error);
1020            }
1021            std::thread::sleep(Duration::from_millis(10));
1022        }
1023        self.recording.finalizing = None;
1024        if !self.playback.queue_completions.is_empty() {
1025            failure.get_or_insert_with(|| anyhow::anyhow!(crate::t!("session_save_failed")));
1026        }
1027        if let Some(writer) = self.session.persistence.take()
1028            && let Err(error) = writer.finish().context(crate::t!("session_save_failed"))
1029        {
1030            failure.get_or_insert(error);
1031        }
1032        failure.map_or(Ok(()), Err)
1033    }
1034
1035    fn poll_background(&mut self) -> Result<()> {
1036        if let Some(writer) = &self.session.persistence {
1037            writer.poll().context(crate::t!("session_save_failed"))?;
1038        }
1039        self.session.subtitles.poll_retiring();
1040        if let Some(result) = self
1041            .session
1042            .library_task
1043            .as_ref()
1044            .and_then(Background::poll)
1045        {
1046            self.session.library_task = None;
1047            self.session.status.message = match result {
1048                Ok(message) => message,
1049                Err(error) => {
1050                    crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
1051                }
1052            };
1053        }
1054        self.playback
1055            .poll_background(&mut self.session, &mut self.recording)?;
1056        self.recording
1057            .record_poll_background(&mut self.session, &mut self.playback)
1058    }
1059}
1060
1061impl Drop for Engine {
1062    fn drop(&mut self) {
1063        let _ = self.shutdown();
1064    }
1065}
1066
1067#[cfg(test)]
1068mod tests {
1069    use super::*;
1070
1071    #[test]
1072    fn cached_episode_captions_follow_mpv_resume_pause_seek_and_speed() {
1073        use crate::podcast::{Action, Download, Episode, Feed, Preview};
1074        let dir = tempfile::tempdir().unwrap();
1075        let mut config = crate::test_support::config(dir.path());
1076        config.settings.mpv = std::env::var("RADIO_TEST_MPV").unwrap_or_else(|_| "mpv".into());
1077        config.settings.audio_device = Some("null".into());
1078        config.settings.podcasts.refresh_hours = 0;
1079        if std::process::Command::new(&config.settings.mpv)
1080            .arg("--version")
1081            .output()
1082            .is_err()
1083        {
1084            return;
1085        }
1086        let audio = dir.path().join("audio.wav");
1087        std::fs::write(&audio, crate::test_support::fixture("pcm_s16le", "wav")).unwrap();
1088        let file = dir.path().join("captions.vtt");
1089        std::fs::write(&file, "WEBVTT\n\n00:00.000 --> 00:01.000\nfirst\n\n00:01.000 --> 00:02.000\nsecond\n\n00:02.000 --> 00:05.000\nthird").unwrap();
1090        let stop = Arc::new(AtomicBool::new(false));
1091        let mut engine = Engine::new(config.clone(), stop.clone()).unwrap();
1092        let p = Preview {
1093            feed: Feed {
1094                url: "https://example.test/feed".into(),
1095                title: "show".into(),
1096                ..Default::default()
1097            },
1098            episodes: vec![Episode {
1099                url: "https://example.test/audio".into(),
1100                title: "episode".into(),
1101                ..Default::default()
1102            }],
1103        };
1104        let feed = engine.store().podcast_subscribe(&p, &p.feed.url).unwrap();
1105        let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1106        engine
1107            .store()
1108            .podcast_save_download(&Download {
1109                episode_id: episode.id.clone(),
1110                url: episode.url.clone(),
1111                media: Some(episode.media()),
1112                path: audio.to_string_lossy().into(),
1113                state: "complete".into(),
1114                ..Default::default()
1115            })
1116            .unwrap();
1117        crate::podcast::manage(
1118            &config,
1119            engine.store(),
1120            Action::Subtitles {
1121                id: episode.id.clone(),
1122                file: Some(file),
1123                transcribe: false,
1124            },
1125            &stop,
1126        )
1127        .unwrap();
1128        engine
1129            .store()
1130            .podcast_progress(&episode, 1200, None, false)
1131            .unwrap();
1132        engine.session.background_media = true;
1133        engine.set_subtitles(true);
1134        engine.play_episode(&episode.id, false, None).unwrap();
1135        let deadline = Instant::now() + Duration::from_secs(10);
1136        let wait = |engine: &mut Engine, expected: usize| {
1137            loop {
1138                engine.tick().unwrap();
1139                if engine.subtitles().current == [expected] {
1140                    break;
1141                }
1142                assert!(
1143                    Instant::now() < deadline,
1144                    "{:?} {:?}",
1145                    engine.status(),
1146                    engine.subtitles()
1147                );
1148                std::thread::sleep(Duration::from_millis(10));
1149            }
1150        };
1151        wait(&mut engine, 1);
1152        while engine.status().playback_state != PlaybackState::Playing
1153            || !engine.playback.session_started
1154            || engine.status().episode.as_ref().unwrap().position_ms <= 1200
1155        {
1156            engine.tick().unwrap();
1157            assert!(Instant::now() < deadline);
1158            std::thread::sleep(Duration::from_millis(10));
1159        }
1160        assert!(engine.subtitles().timed);
1161        engine.pause().unwrap();
1162        while !engine.status().paused() {
1163            engine.tick().unwrap();
1164            assert!(Instant::now() < deadline, "{:?}", engine.status());
1165            std::thread::sleep(Duration::from_millis(10));
1166        }
1167        engine.seek_episode(2500).unwrap();
1168        engine.podcast_speed(2.).unwrap();
1169        wait(&mut engine, 2);
1170        assert!(engine.status().paused());
1171        assert_eq!(engine.status().speed, 2.);
1172        let generation = engine.playback.generation;
1173        let position = engine.status().episode.as_ref().unwrap().position_ms;
1174        engine.show_podcast_subtitles(&episode.id).unwrap();
1175        assert!(engine.subtitles().enabled);
1176        assert_eq!(engine.playback.generation, generation);
1177        assert_eq!(
1178            engine.status().episode.as_ref().unwrap().position_ms,
1179            position
1180        );
1181        assert!(engine.status().paused());
1182        assert_eq!(engine.status().speed, 2.);
1183        let revision = engine.subtitles().revision;
1184        for _ in 0..3 {
1185            engine.tick().unwrap();
1186        }
1187        assert_eq!(engine.subtitles().revision, revision);
1188        engine.seek_episode(250).unwrap();
1189        wait(&mut engine, 0);
1190        engine.pause().unwrap();
1191        wait(&mut engine, 1);
1192        assert_eq!(engine.status().speed, 2.);
1193        engine.set_subtitles(false);
1194        let error = engine
1195            .show_podcast_subtitles("missing-episode")
1196            .unwrap_err();
1197        assert!(!error.to_string().is_empty());
1198        assert!(!engine.subtitles().enabled);
1199        assert_eq!(engine.status().episode.as_ref().unwrap().id, episode.id);
1200        engine.shutdown().unwrap();
1201    }
1202
1203    #[test]
1204    fn queue_completion_refreshes_candidates_after_concurrent_edits() {
1205        use crate::podcast::{Episode, Feed, Preview, QueueAction};
1206        for edit in ["clear", "remove", "move", "readd"] {
1207            let dir = tempfile::tempdir().unwrap();
1208            let mut config = crate::test_support::config(dir.path());
1209            config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1210                .to_string_lossy()
1211                .into_owned();
1212            let path = config.data_dir.join("radio.db");
1213            let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1214            let preview = Preview {
1215                feed: Feed {
1216                    url: "https://example.test/feed".into(),
1217                    ..Default::default()
1218                },
1219                episodes: ["episode-eof", "second", "third"]
1220                    .into_iter()
1221                    .map(|name| Episode {
1222                        guid: Some(name.into()),
1223                        url: format!("https://example.test/{name}"),
1224                        ..Default::default()
1225                    })
1226                    .collect(),
1227            };
1228            let feed = engine
1229                .store()
1230                .podcast_subscribe(&preview, &preview.feed.url)
1231                .unwrap();
1232            let episodes = engine.store().podcast_episodes(&feed.id).unwrap();
1233            let ids: Vec<_> = ["episode-eof", "second", "third"]
1234                .into_iter()
1235                .map(|name| {
1236                    episodes
1237                        .iter()
1238                        .find(|e| e.guid.as_deref() == Some(name))
1239                        .unwrap()
1240                        .id
1241                        .clone()
1242                })
1243                .collect();
1244            engine.store().podcast_queue_set(&ids).unwrap();
1245            engine.enable_background_media().unwrap();
1246            engine.play_podcast_queue(true).unwrap();
1247            let deadline = Instant::now() + Duration::from_secs(3);
1248            while engine.playback.queue_completions.is_empty() {
1249                engine.tick().unwrap();
1250                assert!(Instant::now() < deadline);
1251                std::thread::sleep(Duration::from_millis(5));
1252            }
1253            // Launch completion, then stop polling until its transaction commits.
1254            engine.poll_background().unwrap();
1255            let external = Store::open(&path).unwrap();
1256            while external.podcast_queue().unwrap().len() != 2 {
1257                assert!(Instant::now() < deadline);
1258                std::thread::sleep(Duration::from_millis(5));
1259            }
1260            let action = match edit {
1261                "clear" => QueueAction::Clear,
1262                "remove" => QueueAction::Remove { id: ids[1].clone() },
1263                "move" => QueueAction::Move {
1264                    id: ids[2].clone(),
1265                    position: 1,
1266                },
1267                "readd" => QueueAction::Add { id: ids[0].clone() },
1268                _ => unreachable!(),
1269            };
1270            external.podcast_queue_update(action).unwrap();
1271            let deadline = Instant::now() + Duration::from_secs(3);
1272            while !engine.playback.queue_completions.is_empty() {
1273                engine.tick().unwrap();
1274                assert!(Instant::now() < deadline);
1275                std::thread::sleep(Duration::from_millis(5));
1276            }
1277            match edit {
1278                "clear" => {
1279                    assert!(!engine.playback_active());
1280                    assert_eq!(engine.status().playback_state, PlaybackState::Idle);
1281                }
1282                "remove" | "move" => {
1283                    assert_eq!(engine.status().episode.as_ref().unwrap().id, ids[2])
1284                }
1285                "readd" => {
1286                    assert_eq!(engine.status().episode.as_ref().unwrap().id, ids[1]);
1287                    assert!(
1288                        external
1289                            .podcast_queue()
1290                            .unwrap()
1291                            .iter()
1292                            .any(|e| e.id == ids[0])
1293                    );
1294                }
1295                _ => unreachable!(),
1296            }
1297            engine.shutdown().unwrap();
1298        }
1299    }
1300
1301    #[test]
1302    fn queue_completion_retries_without_blocking_or_overriding_controls() {
1303        use crate::podcast::{Episode, Feed, Preview};
1304        for control in ["advance", "stop", "switch", "off", "shutdown"] {
1305            let dir = tempfile::tempdir().unwrap();
1306            let mut config = crate::test_support::config(dir.path());
1307            config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1308                .to_string_lossy()
1309                .into_owned();
1310            let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1311            let preview = Preview {
1312                feed: Feed {
1313                    url: "https://example.test/feed".into(),
1314                    ..Default::default()
1315                },
1316                episodes: ["episode-eof", "audio"]
1317                    .into_iter()
1318                    .map(|name| Episode {
1319                        guid: Some(name.into()),
1320                        url: format!("https://example.test/{name}"),
1321                        ..Default::default()
1322                    })
1323                    .collect(),
1324            };
1325            let feed = engine
1326                .store()
1327                .podcast_subscribe(&preview, &preview.feed.url)
1328                .unwrap();
1329            let episodes = engine.store().podcast_episodes(&feed.id).unwrap();
1330            let first = episodes
1331                .iter()
1332                .find(|e| e.guid.as_deref() == Some("episode-eof"))
1333                .unwrap();
1334            let next = episodes
1335                .iter()
1336                .find(|e| e.guid.as_deref() == Some("audio"))
1337                .unwrap();
1338            engine
1339                .store()
1340                .podcast_queue_set(&[first.id.clone(), next.id.clone()])
1341                .unwrap();
1342            engine.enable_background_media().unwrap();
1343            engine.play_podcast_queue(true).unwrap();
1344            let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1345            connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1346            let deadline = Instant::now() + Duration::from_secs(3);
1347            while engine.playback.queue_completions.is_empty() {
1348                let started = Instant::now();
1349                engine.tick().unwrap();
1350                assert!(
1351                    started.elapsed() < Duration::from_millis(250),
1352                    "EOF blocked controls"
1353                );
1354                assert!(Instant::now() < deadline);
1355                std::thread::sleep(Duration::from_millis(5));
1356            }
1357            let deadline = Instant::now() + Duration::from_millis(350);
1358            while Instant::now() < deadline {
1359                let started = Instant::now();
1360                engine.tick().unwrap();
1361                engine.volume(-1).unwrap();
1362                assert!(
1363                    started.elapsed() < Duration::from_millis(250),
1364                    "queue retry blocked controls"
1365                );
1366                std::thread::sleep(Duration::from_millis(5));
1367            }
1368            assert_eq!(engine.store().podcast_queue().unwrap().len(), 2);
1369            assert!(!engine.playback.queue_completions.is_empty());
1370            if control == "shutdown" {
1371                let release = std::thread::spawn(move || {
1372                    std::thread::sleep(Duration::from_millis(200));
1373                    connection.execute_batch("ROLLBACK").unwrap();
1374                });
1375                engine.shutdown().unwrap();
1376                release.join().unwrap();
1377                assert!(engine.playback.queue_completions.is_empty());
1378                assert_eq!(engine.status().playback_state, PlaybackState::Idle);
1379                assert_eq!(engine.store().podcast_queue().unwrap()[0].id, next.id);
1380                assert!(engine.store().podcast_episode(&first.id).unwrap().completed);
1381                continue;
1382            }
1383            match control {
1384                "stop" => {
1385                    engine.stop_playback().unwrap();
1386                    assert!(!engine.playback_active());
1387                }
1388                "switch" => {
1389                    engine.play("https://example.test/live").unwrap();
1390                }
1391                "off" => engine.podcast_auto_next(false).unwrap(),
1392                _ => assert!(engine.playback_active()),
1393            }
1394            connection.execute_batch("ROLLBACK").unwrap();
1395            let deadline = Instant::now() + Duration::from_secs(3);
1396            loop {
1397                engine.tick().unwrap();
1398                if engine.playback.queue_completions.is_empty()
1399                    && (matches!(control, "stop" | "off")
1400                        || engine.status().playback_state == PlaybackState::Playing)
1401                {
1402                    break;
1403                }
1404                assert!(
1405                    Instant::now() < deadline,
1406                    "{control}: {:?}",
1407                    engine.status()
1408                );
1409                std::thread::sleep(Duration::from_millis(5));
1410            }
1411            assert_eq!(
1412                engine
1413                    .store()
1414                    .podcast_queue()
1415                    .unwrap()
1416                    .iter()
1417                    .map(|e| &e.id)
1418                    .collect::<Vec<_>>(),
1419                vec![&next.id]
1420            );
1421            match control {
1422                "advance" => assert_eq!(engine.status().episode.as_ref().unwrap().id, next.id),
1423                "stop" | "off" => assert_eq!(engine.status().playback_state, PlaybackState::Idle),
1424                "switch" => {
1425                    assert!(engine.status().episode.is_none());
1426                    assert_eq!(engine.status().source_url, "https://example.test/live");
1427                }
1428                _ => unreachable!(),
1429            }
1430            engine.shutdown().unwrap();
1431            assert!(engine.store().podcast_episode(&first.id).unwrap().completed);
1432        }
1433    }
1434
1435    #[test]
1436    fn podcast_preferences_apply_before_the_background_write_finishes() {
1437        use crate::podcast::{Action, Episode, Feed, Preview, QueueAction};
1438        for (old_speed, old_auto_next, speed, auto_next) in
1439            [(1., false, 1.5, true), (1.5, true, 1.25, false)]
1440        {
1441            let dir = tempfile::tempdir().unwrap();
1442            let mut config = crate::test_support::config(dir.path());
1443            let mpv = crate::test_support::fake_mpv(dir.path());
1444            config.settings.mpv = mpv.to_string_lossy().into_owned();
1445            let store = Store::open(&config.data_dir.join("radio.db")).unwrap();
1446            store
1447                .set_meta("podcast_speed", &old_speed.to_string())
1448                .unwrap();
1449            store
1450                .set_meta(
1451                    "podcast_auto_next",
1452                    if old_auto_next { "on" } else { "off" },
1453                )
1454                .unwrap();
1455            let preview = Preview {
1456                feed: Feed {
1457                    url: "https://example.test/feed".into(),
1458                    ..Default::default()
1459                },
1460                episodes: vec![Episode {
1461                    url: "https://example.test/audio".into(),
1462                    ..Default::default()
1463                }],
1464            };
1465            let feed = store
1466                .podcast_subscribe(&preview, &preview.feed.url)
1467                .unwrap();
1468            let id = store.podcast_episodes(&feed.id).unwrap().remove(0).id;
1469            store.podcast_queue_set(std::slice::from_ref(&id)).unwrap();
1470            let mut engine = Engine::new(config.clone(), Arc::new(AtomicBool::new(false))).unwrap();
1471            engine.enable_background_media().unwrap();
1472            let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1473            connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1474            engine
1475                .podcast_action(Action::Speed { rate: speed })
1476                .unwrap();
1477            engine
1478                .podcast_action(Action::AutoNext {
1479                    state: if auto_next { "on" } else { "off" }.into(),
1480                })
1481                .unwrap();
1482            assert_eq!(
1483                store.meta("podcast_speed").unwrap(),
1484                Some(old_speed.to_string())
1485            );
1486            assert_eq!(
1487                store.meta("podcast_auto_next").unwrap().as_deref(),
1488                Some(if old_auto_next { "on" } else { "off" })
1489            );
1490            engine
1491                .podcast_action(Action::Queue {
1492                    action: QueueAction::Play { auto_next: false },
1493                })
1494                .unwrap();
1495            assert_eq!(engine.status().speed, speed);
1496            assert_eq!(engine.playback.auto_next, auto_next);
1497            let deadline = Instant::now() + Duration::from_secs(3);
1498            loop {
1499                engine.tick().unwrap();
1500                let commands =
1501                    std::fs::read_to_string(mpv.with_extension("commands")).unwrap_or_default();
1502                let speed_sent = commands
1503                    .lines()
1504                    .filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
1505                    .any(|value| {
1506                        value["command"] == serde_json::json!(["set_property", "speed", speed])
1507                    });
1508                if speed_sent && engine.status().playback_state == PlaybackState::Playing {
1509                    break;
1510                }
1511                assert!(Instant::now() < deadline, "{:?}", engine.status());
1512                std::thread::sleep(Duration::from_millis(5));
1513            }
1514            engine.play("https://example.test/live").unwrap();
1515            assert_eq!(engine.status().speed, 1.);
1516            engine.play_episode(&id, false, Some(2.)).unwrap();
1517            assert_eq!(engine.status().speed, 2.);
1518            assert!(engine.podcast_speed(f64::NAN).is_err());
1519            engine.play_episode(&id, false, None).unwrap();
1520            assert_eq!(engine.status().speed, speed);
1521            engine
1522                .podcast_action(Action::Queue {
1523                    action: QueueAction::Play { auto_next: true },
1524                })
1525                .unwrap();
1526            assert!(engine.playback.auto_next);
1527            connection.execute_batch("ROLLBACK").unwrap();
1528            engine.shutdown().unwrap();
1529            let lock = Arc::downgrade(&engine.session._lock);
1530            drop(engine);
1531            // Cancelled player startups finish their cleanup on detached threads.
1532            let deadline = Instant::now() + Duration::from_secs(3);
1533            while lock.strong_count() > 0 {
1534                assert!(Instant::now() < deadline);
1535                std::thread::sleep(Duration::from_millis(5));
1536            }
1537            let mut restored = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1538            restored.play_episode(&id, false, None).unwrap();
1539            assert_eq!(restored.status().speed, speed);
1540            assert_eq!(restored.playback.auto_next, auto_next);
1541            restored.shutdown().unwrap();
1542        }
1543    }
1544
1545    #[test]
1546    fn podcast_marks_apply_before_the_background_write_finishes() {
1547        use crate::podcast::{Action, Episode, Feed, Preview};
1548        for active in [false, true] {
1549            for state in ["unplayed", "played"] {
1550                let dir = tempfile::tempdir().unwrap();
1551                let mut config = crate::test_support::config(dir.path());
1552                config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1553                    .to_string_lossy()
1554                    .into_owned();
1555                let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1556                let preview = Preview {
1557                    feed: Feed {
1558                        url: "https://example.test/feed".into(),
1559                        ..Default::default()
1560                    },
1561                    episodes: vec![Episode {
1562                        url: "https://example.test/audio".into(),
1563                        ..Default::default()
1564                    }],
1565                };
1566                let feed = engine
1567                    .store()
1568                    .podcast_subscribe(&preview, &preview.feed.url)
1569                    .unwrap();
1570                let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1571                let id = episode.id.clone();
1572                engine
1573                    .store()
1574                    .podcast_progress(&episode, 15000, Some(20000), false)
1575                    .unwrap();
1576                engine.enable_background_media().unwrap();
1577                if active {
1578                    engine.play_episode(&id, false, None).unwrap();
1579                }
1580                let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1581                connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1582                engine
1583                    .podcast_action(Action::Mark {
1584                        id: id.clone(),
1585                        state: state.into(),
1586                    })
1587                    .unwrap();
1588                let stored = engine.store().podcast_episode(&id).unwrap();
1589                assert_eq!(stored.position_ms, 15000);
1590                assert!(!stored.completed);
1591                engine.play_episode(&id, false, None).unwrap();
1592                let playing = engine.status().episode.as_ref().unwrap();
1593                assert_eq!(playing.position_ms, 0, "{state}, active={active}");
1594                assert!(!playing.completed);
1595                connection.execute_batch("ROLLBACK").unwrap();
1596                engine.shutdown().unwrap();
1597                assert_eq!(engine.store().podcast_episode(&id).unwrap().position_ms, 0);
1598            }
1599        }
1600    }
1601
1602    #[test]
1603    fn replay_preserves_uncommitted_progress_for_unchanged_media() {
1604        use crate::podcast::{Episode, Feed, Preview};
1605        let dir = tempfile::tempdir().unwrap();
1606        let mut config = crate::test_support::config(dir.path());
1607        config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1608            .to_string_lossy()
1609            .into_owned();
1610        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1611        let preview = Preview {
1612            feed: Feed {
1613                url: "https://example.test/feed".into(),
1614                ..Default::default()
1615            },
1616            episodes: vec![Episode {
1617                url: "https://example.test/audio".into(),
1618                duration_ms: Some(20000),
1619                ..Default::default()
1620            }],
1621        };
1622        let feed = engine
1623            .store()
1624            .podcast_subscribe(&preview, &preview.feed.url)
1625            .unwrap();
1626        let mut episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1627        let id = episode.id.clone();
1628        engine.enable_background_media().unwrap();
1629        let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1630        connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1631        episode.position_ms = 8000;
1632        engine.playback.episode = Some(episode);
1633        engine
1634            .playback
1635            .save_episode(&mut engine.session, false)
1636            .unwrap();
1637        engine.playback.episode = None;
1638        assert_eq!(engine.store().podcast_episode(&id).unwrap().position_ms, 0);
1639        engine.play_episode(&id, false, None).unwrap();
1640        assert_eq!(engine.status().episode.as_ref().unwrap().position_ms, 8000);
1641        connection.execute_batch("ROLLBACK").unwrap();
1642        engine.shutdown().unwrap();
1643        assert_eq!(
1644            engine.store().podcast_episode(&id).unwrap().position_ms,
1645            8000
1646        );
1647    }
1648
1649    #[test]
1650    fn download_removal_checks_the_active_input_instead_of_the_saved_episode() {
1651        use crate::podcast::{self, Action, Episode, Feed, Preview};
1652        for streaming in [false, true] {
1653            for background in [false, true] {
1654                let dir = tempfile::tempdir().unwrap();
1655                let mut config = crate::test_support::config(dir.path());
1656                config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1657                    .to_string_lossy()
1658                    .into_owned();
1659                let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1660                if background {
1661                    engine.enable_background_media().unwrap();
1662                }
1663                let p = Preview {
1664                    feed: Feed {
1665                        url: "https://example.test/rss".into(),
1666                        ..Default::default()
1667                    },
1668                    episodes: vec![Episode {
1669                        guid: Some("episode".into()),
1670                        url: "https://example.test/audio".into(),
1671                        ..Default::default()
1672                    }],
1673                };
1674                let feed = engine.store().podcast_subscribe(&p, &p.feed.url).unwrap();
1675                let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1676                let path = podcast::download_path(engine.config(), &episode.id);
1677                std::fs::create_dir_all(path.parent().unwrap()).unwrap();
1678                std::fs::write(&path, b"fixture").unwrap();
1679                let download = podcast::Download {
1680                    episode_id: episode.id.clone(),
1681                    url: episode.url.clone(),
1682                    media: Some(episode.media()),
1683                    state: "complete".into(),
1684                    path: path.to_string_lossy().into_owned(),
1685                    bytes: 7,
1686                    ..Default::default()
1687                };
1688                // An online player must not reserve a download completed later.
1689                if !streaming {
1690                    engine.store().podcast_save_download(&download).unwrap();
1691                }
1692                engine.play_episode(&episode.id, false, None).unwrap();
1693                if streaming {
1694                    engine.store().podcast_save_download(&download).unwrap();
1695                }
1696                assert!(engine.playback_active());
1697                let remove = Action::Downloads {
1698                    action: podcast::DownloadAction::Remove {
1699                        id: episode.id.clone(),
1700                    },
1701                };
1702                if !streaming {
1703                    assert!(engine.podcast_action(remove.clone()).is_err());
1704                    assert!(path.exists());
1705                    engine.stop_playback().unwrap();
1706                    assert!(!engine.playback_active());
1707                    assert_eq!(engine.status().episode.as_ref().unwrap().id, episode.id);
1708                }
1709                engine.podcast_action(remove).unwrap();
1710                let deadline = Instant::now() + Duration::from_secs(3);
1711                let result = loop {
1712                    if let Some(result) = engine.poll_podcast() {
1713                        break result.unwrap();
1714                    }
1715                    assert!(Instant::now() < deadline);
1716                    std::thread::sleep(Duration::from_millis(10));
1717                };
1718                assert_eq!(result["state"], "removed");
1719                assert!(!path.exists());
1720                if streaming {
1721                    assert!(engine.playback_active());
1722                }
1723                engine.shutdown().unwrap();
1724            }
1725        }
1726    }
1727
1728    #[test]
1729    fn background_media_preserves_the_lock_budget_for_catalog_writes() {
1730        let dir = tempfile::tempdir().unwrap();
1731        let config = crate::test_support::config(dir.path());
1732        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1733        let station = crate::service::add_station(
1734            &mut engine.session.store,
1735            "Custom".into(),
1736            "https://example.test/live".into(),
1737            &[],
1738        )
1739        .unwrap();
1740        engine.enable_background_media().unwrap();
1741        // Every operation waits through a short publication transaction. The
1742        // former 20 ms owner budget failed each one while the lock was held.
1743        for operation in 0..5 {
1744            let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1745            connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1746            let release = std::thread::spawn(move || {
1747                std::thread::sleep(Duration::from_millis(100));
1748                connection.execute_batch("ROLLBACK").unwrap();
1749            });
1750            let result = match operation {
1751                0 => engine.toggle_favorite(&station.stationuuid).map(|_| ()),
1752                1 => engine
1753                    .change_station(crate::service::StationCommand::Backups {
1754                        uuid: station.stationuuid.clone(),
1755                        add: vec!["https://example.test/backup".into()],
1756                        remove: vec![],
1757                    })
1758                    .map(|_| ()),
1759                2 => engine.store().upsert(&station),
1760                3 => engine.store().save_recording(
1761                    &serde_json::from_value(serde_json::json!({
1762                        "id":"record", "stationuuid":station.stationuuid,
1763                        "station_name":station.name, "source_url_resolved":station.url,
1764                        "started_at":"2026-11-01T00:00:00Z", "codec":"mp3", "container":"mp3",
1765                        "path":"record.mp3", "size_bytes":0, "status":"recording"
1766                    }))
1767                    .unwrap(),
1768                ),
1769                4 => engine
1770                    .change_station(crate::service::StationCommand::Remove {
1771                        uuid: station.stationuuid.clone(),
1772                        keep_references: true,
1773                    })
1774                    .map(|_| ()),
1775                _ => unreachable!(),
1776            };
1777            release.join().unwrap();
1778            result.unwrap();
1779        }
1780        engine.shutdown().unwrap();
1781    }
1782
1783    #[test]
1784    fn background_session_writes_keep_controls_responsive_under_a_write_lock() {
1785        let dir = tempfile::tempdir().unwrap();
1786        let config = crate::test_support::config(dir.path());
1787        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1788        let station = Station {
1789            stationuuid: uuid::Uuid::new_v4().to_string(),
1790            name: "Remembered".into(),
1791            active: true,
1792            ..Station::default()
1793        };
1794        engine.session.store.upsert(&station).unwrap();
1795        engine.enable_background_media().unwrap();
1796        let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1797        connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1798        let started = Instant::now();
1799        for _ in 0..10 {
1800            engine.volume(-1).unwrap();
1801        }
1802        engine.save_preference("pref_source", "favorites").unwrap();
1803        engine.session.remember_play(&station.stationuuid).unwrap();
1804        engine.stop_playback().unwrap();
1805        engine.tick().unwrap();
1806        assert!(started.elapsed() < Duration::from_millis(250));
1807        assert_eq!(engine.session.status.volume, 70);
1808        // Let the writer hit contention before sending the newer value.
1809        std::thread::sleep(Duration::from_millis(150));
1810        engine.volume(-5).unwrap();
1811        connection.execute_batch("ROLLBACK").unwrap();
1812        // Closing flushes the latest value even before the debounce expires.
1813        engine.shutdown().unwrap();
1814        assert_eq!(
1815            engine.session.store.meta("pref_volume").unwrap().as_deref(),
1816            Some("65")
1817        );
1818        assert_eq!(
1819            engine.session.store.meta("pref_source").unwrap().as_deref(),
1820            Some("favorites")
1821        );
1822        assert_eq!(
1823            engine
1824                .session
1825                .store
1826                .meta("pref_last_station")
1827                .unwrap()
1828                .as_deref(),
1829            Some(station.stationuuid.as_str())
1830        );
1831        assert_eq!(
1832            engine
1833                .session
1834                .store
1835                .search_count(&Filter {
1836                    history: true,
1837                    ..Filter::default()
1838                })
1839                .unwrap(),
1840            1
1841        );
1842    }
1843
1844    #[test]
1845    fn background_session_write_failures_are_reported() {
1846        let dir = tempfile::tempdir().unwrap();
1847        let config = crate::test_support::config(dir.path());
1848        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1849        engine
1850            .session
1851            .store
1852            .test_connection()
1853            .execute_batch(
1854                "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
1855             BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
1856            )
1857            .unwrap();
1858        engine.enable_background_media().unwrap();
1859        engine.volume(-1).unwrap();
1860        let deadline = Instant::now() + Duration::from_secs(3);
1861        loop {
1862            if let Err(error) = engine.tick() {
1863                assert!(format!("{error:#}").contains("preference denied"));
1864                break;
1865            }
1866            assert!(Instant::now() < deadline);
1867            std::thread::sleep(Duration::from_millis(10));
1868        }
1869        assert!(engine.shutdown().is_err());
1870        assert!(engine.session.persistence.is_none());
1871        engine.shutdown().unwrap();
1872    }
1873
1874    #[test]
1875    fn shutdown_drains_finalization_after_a_session_write_failure() {
1876        let dir = tempfile::tempdir().unwrap();
1877        let config = crate::test_support::config(dir.path());
1878        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1879        engine
1880            .store()
1881            .test_connection()
1882            .execute_batch(
1883                "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
1884             BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
1885            )
1886            .unwrap();
1887        engine.enable_background_media().unwrap();
1888        engine.volume(-1).unwrap();
1889        let (completed, receive) = std::sync::mpsc::channel();
1890        engine.recording.finalizing = Some(
1891            Background::start("test-finalization", move |_| {
1892                std::thread::sleep(Duration::from_millis(150));
1893                completed.send(()).unwrap();
1894                bail!("finalization fixture");
1895            })
1896            .unwrap(),
1897        );
1898        let error = engine.shutdown().unwrap_err();
1899        assert!(format!("{error:#}").contains("preference denied"));
1900        receive
1901            .try_recv()
1902            .expect("finalization must finish before shutdown returns");
1903        assert!(engine.recording.finalizing.is_none());
1904        assert!(engine.session.persistence.is_none());
1905        assert!(matches!(
1906            engine.status().recording_state,
1907            RecordingState::Failed { .. }
1908        ));
1909        engine.shutdown().unwrap();
1910    }
1911
1912    #[test]
1913    fn shutdown_stops_pending_writes_before_reporting_a_flush_timeout() {
1914        let dir = tempfile::tempdir().unwrap();
1915        let config = crate::test_support::config(dir.path());
1916        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1917        engine.enable_background_media().unwrap();
1918        let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1919        connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1920        engine.volume(-1).unwrap();
1921        let (cancelled, receive) = std::sync::mpsc::channel();
1922        engine.recording.finalizing = Some(
1923            Background::start("test-finalization", move |cancel| {
1924                while !cancel.load(std::sync::atomic::Ordering::Relaxed) {
1925                    std::thread::sleep(Duration::from_millis(5));
1926                }
1927                cancelled.send(()).unwrap();
1928                bail!("cancelled finalization fixture");
1929            })
1930            .unwrap(),
1931        );
1932        assert!(
1933            engine
1934                .shutdown_with_budget(Duration::from_millis(150))
1935                .is_err()
1936        );
1937        assert!(engine.session.persistence.is_none());
1938        assert!(engine.recording.finalizing.is_none());
1939        receive.recv_timeout(Duration::from_secs(1)).unwrap();
1940        connection.execute_batch("ROLLBACK").unwrap();
1941        // The writer has settled, so releasing the lock cannot produce a late
1942        // successful write after the caller was told that flushing failed.
1943        assert!(engine.store().meta("pref_volume").unwrap().is_none());
1944        engine.shutdown().unwrap();
1945    }
1946
1947    #[test]
1948    fn invalid_subtitle_model_reports_id_without_changing_settings() {
1949        let dir = tempfile::tempdir().unwrap();
1950        let config = crate::test_support::config(dir.path());
1951        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1952        let original = engine.session.config.settings.subtitles.model.clone();
1953        for id in ["unknown", "silero-vad", "../../model"] {
1954            let error = engine.set_subtitle_model(id.into()).unwrap_err();
1955            let error = error.downcast_ref::<DomainError>().unwrap();
1956            assert_eq!(error.code, ErrorCode::SubtitleModel);
1957            assert_eq!(engine.session.config.settings.subtitles.model, original);
1958        }
1959    }
1960
1961    #[test]
1962    fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
1963        use crate::test_support::{Server, fake_mpv};
1964        use std::sync::atomic::{AtomicUsize, Ordering};
1965        let requests = Arc::new(AtomicUsize::new(0));
1966        let counter = requests.clone();
1967        let server = Server::new(move |_, _| {
1968            counter.fetch_add(1, Ordering::Relaxed);
1969        });
1970        let dir = tempfile::tempdir().unwrap();
1971        let mpv = fake_mpv(dir.path());
1972        for background in [false, true] {
1973            let data = dir.path().join(background.to_string());
1974            let mut config = crate::test_support::config_with_api(&data, &server.url);
1975            config.settings.mpv = mpv.to_string_lossy().into_owned();
1976            config.settings.audio_device = Some("test/fail".into());
1977            let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1978            engine.session.background_media = background;
1979            let station = Station {
1980                stationuuid: uuid::Uuid::new_v4().to_string(),
1981                name: "Catalog station".into(),
1982                url: format!("{}/live", server.url),
1983                active: true,
1984                ..Station::default()
1985            };
1986            engine.session.store.upsert(&station).unwrap();
1987            engine
1988                .session
1989                .store
1990                .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
1991                .unwrap();
1992            engine.play(&station.stationuuid).unwrap();
1993            engine.playback.random_filter = Some(Filter::default());
1994            engine.playback.session_started = true;
1995            let deadline = Instant::now() + Duration::from_secs(3);
1996            while !engine.session.playback_failed {
1997                engine.tick().unwrap();
1998                assert!(
1999                    Instant::now() < deadline,
2000                    "{}",
2001                    engine.session.status.message
2002                );
2003                std::thread::sleep(Duration::from_millis(10));
2004            }
2005            let error = engine.playback_error().unwrap();
2006            assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
2007            assert_eq!(error.params["device"], "test/fail");
2008            assert_eq!(engine.playback.tried.len(), 1);
2009            assert!(!engine.playback_active());
2010            assert!(!engine.playback.refreshed);
2011            assert!(engine.playback.reconnect_window.is_empty());
2012            engine.shutdown().unwrap();
2013        }
2014        assert_eq!(requests.load(Ordering::Relaxed), 0);
2015        let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
2016        assert_eq!(
2017            commands
2018                .lines()
2019                .filter(|s| s.contains("\"loadfile\""))
2020                .count(),
2021            2
2022        );
2023    }
2024
2025    #[test]
2026    fn background_player_startup_preserves_dependency_failure() {
2027        let dir = tempfile::tempdir().unwrap();
2028        let mut config = crate::test_support::config(dir.path());
2029        config.settings.mpv = dir
2030            .path()
2031            .join("missing-mpv")
2032            .to_string_lossy()
2033            .into_owned();
2034        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2035        engine.enable_background_media().unwrap();
2036        engine.play("https://example.com/live").unwrap();
2037        let deadline = Instant::now() + Duration::from_secs(3);
2038        while !engine.session.playback_failed {
2039            engine.tick().unwrap();
2040            assert!(Instant::now() < deadline);
2041            std::thread::sleep(Duration::from_millis(10));
2042        }
2043        assert_eq!(
2044            engine.playback_error().unwrap().code,
2045            ErrorCode::MissingDependency
2046        );
2047        assert!(!engine.playback_active());
2048    }
2049
2050    #[test]
2051    fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
2052        use crate::test_support::{Server, config, fixture, response};
2053        let bytes = fixture("libmp3lame", "mp3");
2054        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
2055        let dir = tempfile::tempdir().unwrap();
2056        let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
2057        let station = Station {
2058            stationuuid: uuid::Uuid::new_v4().to_string(),
2059            name: "Saved station".into(),
2060            url: server.url.clone(),
2061            active: true,
2062            custom: true,
2063            ..Station::default()
2064        };
2065        engine.session.store.upsert(&station).unwrap();
2066        engine.session.status.station = Some(station.clone());
2067        engine.session.status.playback_state = PlaybackState::Playing;
2068        engine.playback.url = server.url.clone();
2069        engine.record_current(None, None).unwrap();
2070        let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
2071        conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
2072        assert!(engine.play("https://example.com/audition").is_err());
2073        assert_eq!(
2074            engine.session.status.station.as_ref().unwrap().stationuuid,
2075            station.stationuuid
2076        );
2077        assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
2078    }
2079
2080    #[test]
2081    fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
2082        use crate::test_support::{Server, config, fixture, response};
2083        let bytes = fixture("libmp3lame", "mp3");
2084        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
2085        for background in [false, true] {
2086            for title in [
2087                "Björk / 中文\x1b\n".to_owned(),
2088                String::new(),
2089                "曲".repeat(100),
2090            ] {
2091                let dir = tempfile::tempdir().unwrap();
2092                let mut engine =
2093                    Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
2094                if background {
2095                    engine.enable_background_media().unwrap();
2096                }
2097                let station = Station {
2098                    stationuuid: uuid::Uuid::new_v4().to_string(),
2099                    name: if title.starts_with('曲') {
2100                        "台".repeat(60)
2101                    } else {
2102                        "Station".into()
2103                    },
2104                    url: server.url.clone(),
2105                    custom: true,
2106                    active: true,
2107                    ..Station::default()
2108                };
2109                engine.session.store.upsert(&station).unwrap();
2110                engine.session.status.station = Some(station);
2111                engine.session.status.playback_state = PlaybackState::Playing;
2112                engine.session.status.title = title.clone();
2113                engine.playback.url = server.url.clone();
2114                engine
2115                    .record_current(Some(Duration::from_secs(1)), None)
2116                    .unwrap();
2117                engine.session.status.title = "Next track".into();
2118                let deadline = Instant::now() + Duration::from_secs(8);
2119                while engine.session.status.recording_path.is_empty() {
2120                    engine.tick().unwrap();
2121                    assert!(
2122                        Instant::now() < deadline,
2123                        "{}",
2124                        engine.session.status.message
2125                    );
2126                    std::thread::sleep(Duration::from_millis(10));
2127                }
2128                let record = engine.session.store.recordings(1).unwrap().remove(0);
2129                let expected = crate::clean_text(&title).trim().to_owned();
2130                assert_eq!(
2131                    record.track.as_deref(),
2132                    (!expected.is_empty()).then_some(expected.as_str())
2133                );
2134                let final_path = record.final_path.clone().unwrap();
2135                let name = std::path::Path::new(&record.path)
2136                    .file_name()
2137                    .unwrap()
2138                    .to_str()
2139                    .unwrap();
2140                assert!(name.len() + ".json.tmp".len() <= 255);
2141                if title.starts_with("Björk") {
2142                    assert!(name.contains("-Station-Björk_中文-"));
2143                }
2144                if title.is_empty() {
2145                    assert!(name.contains("-Station-"));
2146                }
2147                while engine.session.status.recording()
2148                    || engine.session.status.recording_state == RecordingState::Finalizing
2149                {
2150                    engine.tick().unwrap();
2151                    assert!(
2152                        Instant::now() < deadline,
2153                        "{}",
2154                        engine.session.status.message
2155                    );
2156                    std::thread::sleep(Duration::from_millis(10));
2157                }
2158                let saved = engine.session.store.recording(&record.id).unwrap();
2159                assert_eq!(saved.status, "complete", "{:?}", saved.error);
2160                assert_eq!(saved.path, final_path);
2161                assert_eq!(saved.track, record.track);
2162                let sidecar: crate::model::Recording =
2163                    serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
2164                        .unwrap();
2165                assert_eq!(sidecar.track, saved.track);
2166                let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
2167                assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
2168            }
2169        }
2170    }
2171
2172    #[test]
2173    fn changing_station_clears_finished_recording_status() {
2174        let dir = tempfile::tempdir().unwrap();
2175        let config = crate::test_support::config(dir.path());
2176        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2177        for state in [
2178            RecordingState::Done,
2179            RecordingState::Failed {
2180                reason: "disk".into(),
2181            },
2182        ] {
2183            engine.session.status.recording_state = state;
2184            engine.session.status.recording_path = "old.mp3".into();
2185            engine.session.status.recording_ms = 1000;
2186            // No source reaches mpv; the new station still owns clean status.
2187            assert!(
2188                engine
2189                    .playback
2190                    .play_source(
2191                        &mut engine.session,
2192                        &mut engine.recording,
2193                        Station::default(),
2194                        vec![],
2195                        playback::SourceKind::Catalog
2196                    )
2197                    .is_err()
2198            );
2199            assert_eq!(engine.session.status.recording_state, RecordingState::Idle);
2200            assert!(engine.session.status.recording_path.is_empty());
2201            assert_eq!(engine.session.status.recording_ms, 0);
2202        }
2203    }
2204
2205    #[test]
2206    fn flapping_reconnects_have_a_sliding_window_limit() {
2207        let dir = tempfile::tempdir().unwrap();
2208        let config = crate::test_support::config(dir.path());
2209        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2210        engine.session.status.station = Some(Station {
2211            custom: true,
2212            ..Station::default()
2213        });
2214        engine.playback.session_started = true;
2215        engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
2216        engine
2217            .playback
2218            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2219            .unwrap();
2220        assert!(engine.session.playback_failed);
2221        assert!(!engine.session.status.muted);
2222        assert_eq!(engine.playback.reconnect_attempts, 0);
2223        assert!(engine.playback.reconnect_window.is_empty());
2224        assert!(engine.playback.reconnect_due.is_none());
2225        let failed_state = engine.session.status.playback_state.clone();
2226        for _ in 0..3 {
2227            engine.tick().unwrap();
2228            assert!(engine.session.playback_failed);
2229            assert_eq!(engine.session.status.playback_state, failed_state);
2230            assert!(!engine.playback_active());
2231        }
2232        engine.playback.reconnect_window =
2233            std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
2234        engine
2235            .playback
2236            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2237            .unwrap();
2238        assert!(engine.playback.reconnect_due.is_some());
2239        assert_eq!(engine.playback.reconnect_window.len(), 1);
2240    }
2241
2242    #[test]
2243    fn reconnect_budget_is_bounded_and_stop_cancels_it() {
2244        let dir = tempfile::tempdir().unwrap();
2245        let config = crate::test_support::config(dir.path());
2246        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2247        engine.session.status.station = Some(Station {
2248            custom: true,
2249            name: "Test".into(),
2250            ..Station::default()
2251        });
2252        engine.session.status.muted = true;
2253        engine.playback.session_started = true;
2254        for delay in [1, 3, 7] {
2255            engine
2256                .playback
2257                .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2258                .unwrap();
2259            let remaining = engine
2260                .playback
2261                .reconnect_due
2262                .unwrap()
2263                .saturating_duration_since(Instant::now());
2264            assert!(remaining <= Duration::from_secs(delay));
2265            assert!(remaining > Duration::from_millis(delay * 1000 - 100));
2266            assert!(!engine.session.playback_failed);
2267        }
2268        engine.playback.reconnect_due = None;
2269        engine
2270            .playback
2271            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2272            .unwrap();
2273        assert!(engine.session.playback_failed);
2274        assert!(!engine.session.status.muted);
2275        assert_eq!(engine.playback.reconnect_attempts, 0);
2276        assert!(engine.playback.reconnect_window.is_empty());
2277        assert!(engine.playback.reconnect_due.is_none());
2278        engine.playback.reconnect_attempts = 0;
2279        engine
2280            .playback
2281            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2282            .unwrap();
2283        engine.session.status.muted = true;
2284        engine.stop_playback().unwrap();
2285        assert!(!engine.session.status.muted);
2286        assert_eq!(engine.playback.reconnect_attempts, 0);
2287        assert!(engine.playback.reconnect_window.is_empty());
2288        assert!(engine.playback.reconnect_due.is_none());
2289        let generation = engine.playback.generation;
2290        engine.tick().unwrap();
2291        assert_eq!(engine.playback.generation, generation);
2292        assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
2293    }
2294}