Skip to main content

radio_cli/
engine.rs

1pub(crate) mod artwork;
2mod persistence;
3mod playback;
4mod recording;
5mod status;
6use playback::PlaybackController;
7use recording::RecordingController;
8pub use status::{PlaybackState, RecordingState};
9
10use crate::error::{DomainError, ErrorCode};
11use crate::{
12    config::Config,
13    directory::Directory,
14    model::{Filter, Station},
15    player::{Event, Player},
16    process::{Background, MediaLock},
17    recorder::{self, Recorder},
18    store::Store,
19};
20use anyhow::{Context, Result, bail};
21use std::{
22    collections::VecDeque,
23    sync::{Arc, atomic::AtomicBool},
24    time::{Duration, Instant},
25};
26
27#[derive(Debug, Clone, PartialEq)]
28pub struct Status {
29    pub station: Option<Station>,
30    pub title: String,
31    pub message: String,
32    pub playback_state: PlaybackState,
33    pub volume: u8,
34    pub muted: bool,
35    pub recording_state: RecordingState,
36    pub recording_ms: u64,
37    pub recording_path: String,
38    pub source_url: String,
39}
40
41impl Status {
42    pub(crate) fn control_eq(&self, other: &Self) -> bool {
43        self.station == other.station
44            && self.title == other.title
45            && self.message == other.message
46            && self.playback_state == other.playback_state
47            && self.recording_state == other.recording_state
48            && self.volume == other.volume
49            && self.muted == other.muted
50            && self.recording_path == other.recording_path
51            && self.source_url == other.source_url
52    }
53    pub(crate) fn ui_eq(&self, other: &Self) -> bool {
54        self.control_eq(other) && self.recording_ms / 1000 == other.recording_ms / 1000
55    }
56    pub fn playing(&self) -> bool {
57        matches!(
58            self.playback_state,
59            PlaybackState::Playing | PlaybackState::Paused
60        )
61    }
62    pub fn paused(&self) -> bool {
63        self.playback_state == PlaybackState::Paused
64    }
65    pub fn recording(&self) -> bool {
66        matches!(
67            self.recording_state,
68            RecordingState::Probing | RecordingState::Recording
69        )
70    }
71}
72
73pub struct Engine {
74    session: Session,
75    playback: PlaybackController,
76    recording: RecordingController,
77}
78
79/// Shared services and published session state owned by the engine.
80pub(crate) struct Session {
81    persistence: Option<persistence::Writer>,
82    pub subtitles: crate::speech::Controller,
83    pub(crate) artwork: artwork::Controller,
84    pub config: Config,
85    pub store: Store,
86    pub directory: Directory,
87    pub status: Status,
88    pub stop: Arc<AtomicBool>,
89    pub(crate) _lock: Arc<MediaLock>,
90    pub(crate) background_media: bool,
91    pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
92    pub(crate) library_task: Option<Background<String>>,
93    pub playback_failed: bool,
94}
95
96impl Session {
97    pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
98        if let Some(writer) = &self.persistence {
99            writer.preference(key, value)
100        } else {
101            self.store.set_meta(key, value)
102        }
103    }
104
105    fn remember_play(&self, uuid: &str) -> Result<()> {
106        if let Some(writer) = &self.persistence {
107            writer.played(uuid)
108        } else {
109            self.store.played(uuid)?;
110            self.store.set_meta("pref_last_station", uuid)
111        }
112    }
113}
114
115impl Engine {
116    pub fn status(&self) -> &Status {
117        &self.session.status
118    }
119
120    pub fn config(&self) -> &Config {
121        &self.session.config
122    }
123
124    pub fn store(&self) -> &Store {
125        &self.session.store
126    }
127
128    pub fn subtitles(&self) -> &crate::speech::Snapshot {
129        &self.session.subtitles.snapshot
130    }
131
132    pub fn playback_failed(&self) -> bool {
133        self.session.playback_failed
134    }
135
136    /// Add, edit, remove, or change backup URLs without exposing session state.
137    pub fn change_station(
138        &mut self,
139        command: crate::service::StationCommand,
140    ) -> Result<crate::service::StationChange> {
141        crate::service::change_station(&mut self.session.store, command)
142    }
143
144    /// Atomically toggle a favorite and return its new state.
145    pub fn toggle_favorite(&mut self, uuid: &str) -> Result<bool> {
146        self.session.store.toggle_favorite(uuid)
147    }
148
149    pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
150        self.session.save_preference(key, value)
151    }
152
153    pub(crate) fn set_language(&mut self, language: String) {
154        crate::messages::init(Some(&language), None);
155        self.session.config.settings.language = Some(language.clone());
156        self.session.status.message = crate::t!("language_set", "language" => language);
157    }
158
159    pub(crate) fn request_artwork(&mut self, station: Option<String>) {
160        self.session.artwork.demand = station;
161    }
162
163    pub(crate) fn track_artwork(&self) -> &Option<artwork::TrackArtwork> {
164        &self.session.artwork.cover
165    }
166
167    pub(crate) fn start_diagnostics(&mut self) -> Result<()> {
168        if self.session.diagnostics.is_some() {
169            bail!(crate::t!("diagnostics_busy"));
170        }
171        let config = self.session.config.clone();
172        self.session.diagnostics = Some(Background::start("radio-doctor", move |cancel| {
173            crate::service::doctor_report(&config, &cancel)
174        })?);
175        Ok(())
176    }
177
178    pub(crate) fn poll_diagnostics(&mut self) -> Option<Result<(serde_json::Value, bool)>> {
179        let result = self.session.diagnostics.as_ref()?.poll()?;
180        self.session.diagnostics = None;
181        Some(result)
182    }
183
184    pub(crate) fn stop(&mut self) -> Result<()> {
185        self.stop_playback()?;
186        self.session.status.message = crate::t!("playback_stopped").into();
187        Ok(())
188    }
189
190    #[cfg(test)]
191    pub(crate) fn test_session(&mut self) -> &mut Session {
192        &mut self.session
193    }
194
195    pub fn bootstrap(&mut self) -> Result<usize> {
196        self.session.directory.bootstrap(&mut self.session.store)
197    }
198
199    /// Fetch and publish a full catalog. This call performs blocking I/O.
200    pub fn sync(&mut self, progress: impl FnMut(usize)) -> Result<usize> {
201        self.sync_with_policy(progress, false)
202    }
203
204    /// Sync with explicit permission to accept a catalog shrink over 25%.
205    /// This call performs blocking I/O.
206    pub fn sync_with_policy(
207        &mut self,
208        progress: impl FnMut(usize),
209        accept_shrink: bool,
210    ) -> Result<usize> {
211        self.session
212            .directory
213            .sync_with_policy(&mut self.session.store, progress, accept_shrink)
214    }
215
216    /// Fetch current directory metadata without persisting it. Performs I/O.
217    pub fn refresh_station(&mut self, uuid: &str) -> Result<Option<Station>> {
218        self.session.directory.refresh(uuid)
219    }
220
221    /// Report a confirmed play to the directory. This call performs blocking I/O.
222    pub fn report_click(&mut self, uuid: &str) -> Result<()> {
223        self.session.directory.click(uuid)
224    }
225    pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
226        let lock = MediaLock::acquire(&config.runtime_dir)?;
227        let store = Store::open(&config.data_dir.join("radio.db"))?;
228        if let Some(volume) = store
229            .meta("pref_volume")?
230            .and_then(|v| v.parse::<u8>().ok())
231            .filter(|v| *v <= 100)
232        {
233            config.settings.volume = volume;
234        }
235        let recovery_warnings = recorder::recover(&store)?;
236        let directory = Directory::new(&config, stop.clone())?;
237        let status = Status {
238            station: None,
239            title: String::new(),
240            message: if recovery_warnings.is_empty() {
241                crate::t!("status_ready").into()
242            } else {
243                recovery_warnings.join("\n")
244            },
245            playback_state: PlaybackState::Idle,
246            volume: config.settings.volume,
247            muted: false,
248            recording_state: RecordingState::Idle,
249            recording_ms: 0,
250            recording_path: String::new(),
251            source_url: String::new(),
252        };
253        Ok(Self {
254            session: Session {
255                persistence: None,
256                subtitles: crate::speech::Controller::default(),
257                artwork: artwork::Controller::default(),
258                config,
259                store,
260                directory,
261                status,
262                stop,
263                _lock: Arc::new(lock),
264                background_media: false,
265                diagnostics: None,
266                library_task: None,
267                playback_failed: false,
268            },
269            playback: PlaybackController {
270                generation: 0,
271                refresh_task: None,
272                click_task: None,
273                player: None,
274                player_start: None,
275                retiring: vec![],
276                url: String::new(),
277                candidates: VecDeque::new(),
278                tried: vec![],
279                refreshed: false,
280                confirmed: false,
281                session_started: false,
282                source_kind: playback::SourceKind::Catalog,
283                local_recording_id: None,
284                reconnect_attempts: 0,
285                reconnect_due: None,
286                reconnect_window: VecDeque::new(),
287                started: Instant::now(),
288                random_filter: None,
289                random_tried: vec![],
290                failure: None,
291            },
292            recording: RecordingController {
293                recording_probe: None,
294                retiring_probes: vec![],
295                finalizing: None,
296                recorder: None,
297            },
298        })
299    }
300
301    pub fn play(&mut self, uuid: &str) -> Result<()> {
302        let result = self
303            .playback
304            .play(&mut self.session, &mut self.recording, uuid);
305        if let Err(error) = &result
306            && !self.playback_active()
307        {
308            self.session.status.playback_state = PlaybackState::Failed {
309                reason: format!("{error:#}"),
310            };
311        }
312        result
313    }
314
315    pub fn resume_last_station(&mut self) -> Result<()> {
316        self.playback
317            .resume_last_station(&mut self.session, &mut self.recording)
318    }
319
320    pub fn play_recording(&mut self, id: &str) -> Result<()> {
321        let result = self
322            .playback
323            .play_recording(&mut self.session, &mut self.recording, id);
324        if let Err(error) = &result
325            && !self.playback_active()
326        {
327            self.session.status.playback_state = PlaybackState::Failed {
328                reason: format!("{error:#}"),
329            };
330        }
331        result
332    }
333
334    pub fn random(&mut self, filter: Filter) -> Result<()> {
335        let result = self
336            .playback
337            .random(&mut self.session, &mut self.recording, filter);
338        if let Err(error) = &result
339            && !self.playback_active()
340        {
341            self.session.status.playback_state = PlaybackState::Failed {
342                reason: format!("{error:#}"),
343            };
344        }
345        result
346    }
347
348    pub fn tick(&mut self) -> Result<()> {
349        self.poll_background()?;
350        self.playback.tick(&mut self.session, &mut self.recording)?;
351        self.recording
352            .recording_tick(&mut self.session, &mut self.playback)?;
353        self.subtitle_tick();
354        self.artwork_tick();
355        Ok(())
356    }
357
358    fn subtitle_tick(&mut self) {
359        if !self.session.background_media {
360            return;
361        }
362        if self.session.subtitles.snapshot.enabled && !self.session.artwork.quiescent() {
363            self.session.artwork.cancel();
364            return;
365        }
366        let playing = self.session.status.playback_state == PlaybackState::Playing;
367        let paused = self.session.status.paused();
368        let local = self.playback.source_kind == playback::SourceKind::Local;
369        let generation = self.playback.generation;
370        let session = &mut self.session;
371        let key = (generation, session.status.source_url.as_str());
372        session
373            .subtitles
374            .update(&session.config, key, playing, paused, local, &session.stop);
375    }
376
377    pub fn set_subtitles(&mut self, enabled: bool) {
378        self.session.subtitles.enabled(enabled);
379    }
380    pub fn retry_subtitles(&mut self) {
381        self.session.subtitles.retry();
382    }
383    pub fn clear_subtitles(&mut self) {
384        self.session.subtitles.clear();
385    }
386    pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
387        crate::speech::validate_model(&id)?;
388        let mut settings = self.session.config.settings.subtitles.clone();
389        settings.model = id;
390        settings.validate()?;
391        self.session.config.settings.subtitles = settings;
392        self.session.subtitles.retry();
393        self.session.subtitles.clear();
394        Ok(())
395    }
396
397    fn artwork_tick(&mut self) {
398        let request = (self.session.background_media
399            && !self.session.subtitles.snapshot.enabled
400            && self.session.subtitles.quiescent()
401            && self.session.config.settings.artwork == crate::config::ArtworkMode::Track
402            && self.session.status.playback_state == PlaybackState::Playing
403            && !matches!(
404                self.session.status.recording_state,
405                RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
406            )
407            && self.playback.source_kind != playback::SourceKind::Local
408            && self.playback.retiring.is_empty()
409            && self.recording.retiring_probes.is_empty()
410            && !self.session.status.title.is_empty())
411        .then_some(self.session.status.station.as_ref())
412        .flatten()
413        .filter(|station| {
414            station.hls == 0
415                && self.session.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
416        })
417        .filter(|_| crate::config::validate_url(&self.session.status.source_url).is_ok())
418        .map(|station| artwork::Request {
419            stationuuid: station.stationuuid.clone(),
420            source_url: self.session.status.source_url.clone(),
421            title: self.session.status.title.clone(),
422        });
423        let session = &mut self.session;
424        session.artwork.update(&session.config, request);
425    }
426
427    pub fn pause(&mut self) -> Result<()> {
428        self.playback.pause(&mut self.session, &mut self.recording)
429    }
430    pub fn mute(&mut self) -> Result<()> {
431        self.playback
432            .player
433            .as_mut()
434            .context(DomainError::new(ErrorCode::NotPlaying))?
435            .toggle_mute()
436    }
437
438    pub fn volume(&mut self, delta: i32) -> Result<()> {
439        self.playback
440            .volume(&mut self.session, &mut self.recording, delta)
441    }
442
443    pub fn stop_playback(&mut self) -> Result<()> {
444        self.playback
445            .stop_playback(&mut self.session, &mut self.recording)
446    }
447
448    pub fn toggle_recording(&mut self) -> Result<()> {
449        let result = self
450            .recording
451            .toggle_recording(&mut self.session, &mut self.playback);
452        if let Err(error) = &result
453            && self.recording.recorder.is_none()
454            && self.recording.recording_probe.is_none()
455            && self.recording.finalizing.is_none()
456        {
457            self.session.status.recording_state = RecordingState::Failed {
458                reason: format!("{error:#}"),
459            };
460        }
461        result
462    }
463
464    pub fn record_current(
465        &mut self,
466        duration: Option<Duration>,
467        dir: Option<&std::path::Path>,
468    ) -> Result<()> {
469        let result =
470            self.recording
471                .record_current(&mut self.session, &mut self.playback, duration, dir);
472        if let Err(error) = &result
473            && self.recording.recorder.is_none()
474            && self.recording.recording_probe.is_none()
475            && self.recording.finalizing.is_none()
476        {
477            self.session.status.recording_state = RecordingState::Failed {
478                reason: format!("{error:#}"),
479            };
480        }
481        result
482    }
483
484    pub fn standalone_record(
485        &mut self,
486        uuid: &str,
487        duration: Option<Duration>,
488        dir: Option<&std::path::Path>,
489    ) -> Result<()> {
490        let result = self.recording.standalone_record(
491            &mut self.session,
492            &mut self.playback,
493            uuid,
494            duration,
495            dir,
496        );
497        if let Err(error) = &result
498            && self.recording.recorder.is_none()
499            && self.recording.recording_probe.is_none()
500            && self.recording.finalizing.is_none()
501        {
502            self.session.status.recording_state = RecordingState::Failed {
503                reason: format!("{error:#}"),
504            };
505        }
506        result
507    }
508
509    pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
510        self.recording
511            .stop_recording(&mut self.session, &mut self.playback, reason)
512    }
513
514    pub(crate) fn enable_background_media(&mut self) -> Result<()> {
515        if self.session.persistence.is_none() {
516            self.session.persistence = Some(persistence::Writer::start(
517                self.session.config.data_dir.join("radio.db"),
518                self.session._lock.clone(),
519            )?);
520        }
521        self.session.background_media = true;
522        let enabled = self.session.config.settings.subtitles.enabled;
523        self.session.subtitles.enabled(enabled);
524        Ok(())
525    }
526
527    pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
528        if self.session.library_task.is_some() {
529            bail!(DomainError::new(ErrorCode::RecordingBusy));
530        }
531        if self.playback.local_recording_id.as_deref() == Some(&id) {
532            self.stop_playback()?;
533        }
534        let path = self.session.config.data_dir.join("radio.db");
535        let lock = self.session._lock.clone();
536        self.session.library_task = Some(Background::start(
537            "radio-recording-delete",
538            move |cancel| {
539                let _lock = lock;
540                if cancel.load(std::sync::atomic::Ordering::Relaxed) {
541                    bail!(DomainError::new(ErrorCode::Cancelled));
542                }
543                crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
544                Ok(crate::t!("recording_deleted", "id" => id))
545            },
546        )?);
547        Ok(())
548    }
549
550    pub fn open_recordings(&mut self) -> Result<()> {
551        if self.session.library_task.is_some() {
552            bail!(DomainError::new(ErrorCode::RecordingBusy));
553        }
554        let dir = self.session.config.recording_dir.clone();
555        self.session.library_task =
556            Some(Background::start("radio-open-recordings", move |cancel| {
557                crate::service::open_recordings(&dir, &cancel)?;
558                Ok(crate::t!("recordings_opened", "path" => dir.display()))
559            })?);
560        Ok(())
561    }
562
563    pub fn playback_active(&self) -> bool {
564        self.playback.player.is_some()
565            || self.playback.player_start.is_some()
566            || self.playback.refresh_task.is_some()
567            || self.playback.reconnect_due.is_some()
568    }
569
570    pub fn playback_error(&self) -> Option<&DomainError> {
571        self.playback.failure.as_ref()
572    }
573
574    pub fn shutdown(&mut self) -> Result<()> {
575        self.shutdown_with_budget(Duration::from_secs(6))
576    }
577
578    fn shutdown_with_budget(&mut self, budget: Duration) -> Result<()> {
579        let mut failure = self.stop_playback().err();
580        self.session.subtitles.enabled(false);
581        self.playback.click_task = None;
582        self.session.diagnostics = None;
583        self.session.library_task = None;
584        let deadline = Instant::now() + budget;
585        if let Some(writer) = &self.session.persistence {
586            writer.close(deadline);
587        }
588        // Allow normal finalization, then cancel verification if its budget
589        // expires. Outstanding HTTP results never need joining.
590        while (self.recording.finalizing.is_some()
591            || !self.playback.retiring.is_empty()
592            || !self.recording.retiring_probes.is_empty()
593            || !self.session.artwork.quiescent()
594            || !self.session.subtitles.quiescent()
595            || self
596                .session
597                .persistence
598                .as_ref()
599                .is_some_and(|writer| !writer.finished()))
600            && Instant::now() < deadline
601        {
602            if let Err(error) = self.poll_background() {
603                failure.get_or_insert(error);
604            }
605            std::thread::sleep(Duration::from_millis(10));
606        }
607        self.recording.finalizing = None;
608        if let Some(writer) = self.session.persistence.take()
609            && let Err(error) = writer.finish().context(crate::t!("session_save_failed"))
610        {
611            failure.get_or_insert(error);
612        }
613        failure.map_or(Ok(()), Err)
614    }
615
616    fn poll_background(&mut self) -> Result<()> {
617        if let Some(writer) = &self.session.persistence {
618            writer.poll().context(crate::t!("session_save_failed"))?;
619        }
620        self.session.subtitles.poll_retiring();
621        if let Some(result) = self
622            .session
623            .library_task
624            .as_ref()
625            .and_then(Background::poll)
626        {
627            self.session.library_task = None;
628            self.session.status.message = match result {
629                Ok(message) => message,
630                Err(error) => {
631                    crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
632                }
633            };
634        }
635        self.playback
636            .poll_background(&mut self.session, &mut self.recording)?;
637        self.recording
638            .record_poll_background(&mut self.session, &mut self.playback)
639    }
640}
641
642impl Drop for Engine {
643    fn drop(&mut self) {
644        let _ = self.shutdown();
645    }
646}
647
648#[cfg(test)]
649mod tests {
650    use super::*;
651
652    #[test]
653    fn background_media_preserves_the_lock_budget_for_catalog_writes() {
654        let dir = tempfile::tempdir().unwrap();
655        let config = crate::test_support::config(dir.path());
656        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
657        let station = crate::service::add_station(
658            &mut engine.session.store,
659            "Custom".into(),
660            "https://example.test/live".into(),
661            &[],
662        )
663        .unwrap();
664        engine.enable_background_media().unwrap();
665        // Every operation waits through a short publication transaction. The
666        // former 20 ms owner budget failed each one while the lock was held.
667        for operation in 0..5 {
668            let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
669            connection.execute_batch("BEGIN IMMEDIATE").unwrap();
670            let release = std::thread::spawn(move || {
671                std::thread::sleep(Duration::from_millis(100));
672                connection.execute_batch("ROLLBACK").unwrap();
673            });
674            let result = match operation {
675                0 => engine.toggle_favorite(&station.stationuuid).map(|_| ()),
676                1 => engine
677                    .change_station(crate::service::StationCommand::Backups {
678                        uuid: station.stationuuid.clone(),
679                        add: vec!["https://example.test/backup".into()],
680                        remove: vec![],
681                    })
682                    .map(|_| ()),
683                2 => engine.store().upsert(&station),
684                3 => engine.store().save_recording(
685                    &serde_json::from_value(serde_json::json!({
686                        "id":"record", "stationuuid":station.stationuuid,
687                        "station_name":station.name, "source_url_resolved":station.url,
688                        "started_at":"2026-11-01T00:00:00Z", "codec":"mp3", "container":"mp3",
689                        "path":"record.mp3", "size_bytes":0, "status":"recording"
690                    }))
691                    .unwrap(),
692                ),
693                4 => engine
694                    .change_station(crate::service::StationCommand::Remove {
695                        uuid: station.stationuuid.clone(),
696                        keep_references: true,
697                    })
698                    .map(|_| ()),
699                _ => unreachable!(),
700            };
701            release.join().unwrap();
702            result.unwrap();
703        }
704        engine.shutdown().unwrap();
705    }
706
707    #[test]
708    fn background_session_writes_keep_controls_responsive_under_a_write_lock() {
709        let dir = tempfile::tempdir().unwrap();
710        let config = crate::test_support::config(dir.path());
711        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
712        let station = Station {
713            stationuuid: uuid::Uuid::new_v4().to_string(),
714            name: "Remembered".into(),
715            active: true,
716            ..Station::default()
717        };
718        engine.session.store.upsert(&station).unwrap();
719        engine.enable_background_media().unwrap();
720        let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
721        connection.execute_batch("BEGIN IMMEDIATE").unwrap();
722        let started = Instant::now();
723        for _ in 0..10 {
724            engine.volume(-1).unwrap();
725        }
726        engine.save_preference("pref_source", "favorites").unwrap();
727        engine.session.remember_play(&station.stationuuid).unwrap();
728        engine.stop_playback().unwrap();
729        engine.tick().unwrap();
730        assert!(started.elapsed() < Duration::from_millis(250));
731        assert_eq!(engine.session.status.volume, 70);
732        // Let the writer hit contention before sending the newer value.
733        std::thread::sleep(Duration::from_millis(150));
734        engine.volume(-5).unwrap();
735        connection.execute_batch("ROLLBACK").unwrap();
736        // Closing flushes the latest value even before the debounce expires.
737        engine.shutdown().unwrap();
738        assert_eq!(
739            engine.session.store.meta("pref_volume").unwrap().as_deref(),
740            Some("65")
741        );
742        assert_eq!(
743            engine.session.store.meta("pref_source").unwrap().as_deref(),
744            Some("favorites")
745        );
746        assert_eq!(
747            engine
748                .session
749                .store
750                .meta("pref_last_station")
751                .unwrap()
752                .as_deref(),
753            Some(station.stationuuid.as_str())
754        );
755        assert_eq!(
756            engine
757                .session
758                .store
759                .search_count(&Filter {
760                    history: true,
761                    ..Filter::default()
762                })
763                .unwrap(),
764            1
765        );
766    }
767
768    #[test]
769    fn background_session_write_failures_are_reported() {
770        let dir = tempfile::tempdir().unwrap();
771        let config = crate::test_support::config(dir.path());
772        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
773        engine
774            .session
775            .store
776            .test_connection()
777            .execute_batch(
778                "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
779             BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
780            )
781            .unwrap();
782        engine.enable_background_media().unwrap();
783        engine.volume(-1).unwrap();
784        let deadline = Instant::now() + Duration::from_secs(3);
785        loop {
786            if let Err(error) = engine.tick() {
787                assert!(format!("{error:#}").contains("preference denied"));
788                break;
789            }
790            assert!(Instant::now() < deadline);
791            std::thread::sleep(Duration::from_millis(10));
792        }
793        assert!(engine.shutdown().is_err());
794        assert!(engine.session.persistence.is_none());
795        engine.shutdown().unwrap();
796    }
797
798    #[test]
799    fn shutdown_drains_finalization_after_a_session_write_failure() {
800        let dir = tempfile::tempdir().unwrap();
801        let config = crate::test_support::config(dir.path());
802        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
803        engine
804            .store()
805            .test_connection()
806            .execute_batch(
807                "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
808             BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
809            )
810            .unwrap();
811        engine.enable_background_media().unwrap();
812        engine.volume(-1).unwrap();
813        let (completed, receive) = std::sync::mpsc::channel();
814        engine.recording.finalizing = Some(
815            Background::start("test-finalization", move |_| {
816                std::thread::sleep(Duration::from_millis(150));
817                completed.send(()).unwrap();
818                bail!("finalization fixture");
819            })
820            .unwrap(),
821        );
822        let error = engine.shutdown().unwrap_err();
823        assert!(format!("{error:#}").contains("preference denied"));
824        receive
825            .try_recv()
826            .expect("finalization must finish before shutdown returns");
827        assert!(engine.recording.finalizing.is_none());
828        assert!(engine.session.persistence.is_none());
829        assert!(matches!(
830            engine.status().recording_state,
831            RecordingState::Failed { .. }
832        ));
833        engine.shutdown().unwrap();
834    }
835
836    #[test]
837    fn shutdown_stops_pending_writes_before_reporting_a_flush_timeout() {
838        let dir = tempfile::tempdir().unwrap();
839        let config = crate::test_support::config(dir.path());
840        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
841        engine.enable_background_media().unwrap();
842        let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
843        connection.execute_batch("BEGIN IMMEDIATE").unwrap();
844        engine.volume(-1).unwrap();
845        let (cancelled, receive) = std::sync::mpsc::channel();
846        engine.recording.finalizing = Some(
847            Background::start("test-finalization", move |cancel| {
848                while !cancel.load(std::sync::atomic::Ordering::Relaxed) {
849                    std::thread::sleep(Duration::from_millis(5));
850                }
851                cancelled.send(()).unwrap();
852                bail!("cancelled finalization fixture");
853            })
854            .unwrap(),
855        );
856        assert!(
857            engine
858                .shutdown_with_budget(Duration::from_millis(150))
859                .is_err()
860        );
861        assert!(engine.session.persistence.is_none());
862        assert!(engine.recording.finalizing.is_none());
863        receive.recv_timeout(Duration::from_secs(1)).unwrap();
864        connection.execute_batch("ROLLBACK").unwrap();
865        // The writer has settled, so releasing the lock cannot produce a late
866        // successful write after the caller was told that flushing failed.
867        assert!(engine.store().meta("pref_volume").unwrap().is_none());
868        engine.shutdown().unwrap();
869    }
870
871    #[test]
872    fn invalid_subtitle_model_reports_id_without_changing_settings() {
873        let dir = tempfile::tempdir().unwrap();
874        let config = crate::test_support::config(dir.path());
875        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
876        let original = engine.session.config.settings.subtitles.model.clone();
877        for id in ["unknown", "silero-vad", "../../model"] {
878            let error = engine.set_subtitle_model(id.into()).unwrap_err();
879            let error = error.downcast_ref::<DomainError>().unwrap();
880            assert_eq!(error.code, ErrorCode::SubtitleModel);
881            assert_eq!(engine.session.config.settings.subtitles.model, original);
882        }
883    }
884
885    #[test]
886    fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
887        use crate::test_support::{Server, fake_mpv};
888        use std::sync::atomic::{AtomicUsize, Ordering};
889        let requests = Arc::new(AtomicUsize::new(0));
890        let counter = requests.clone();
891        let server = Server::new(move |_, _| {
892            counter.fetch_add(1, Ordering::Relaxed);
893        });
894        let dir = tempfile::tempdir().unwrap();
895        let mpv = fake_mpv(dir.path());
896        for background in [false, true] {
897            let data = dir.path().join(background.to_string());
898            let mut config = crate::test_support::config_with_api(&data, &server.url);
899            config.settings.mpv = mpv.to_string_lossy().into_owned();
900            config.settings.audio_device = Some("test/fail".into());
901            let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
902            engine.session.background_media = background;
903            let station = Station {
904                stationuuid: uuid::Uuid::new_v4().to_string(),
905                name: "Catalog station".into(),
906                url: format!("{}/live", server.url),
907                active: true,
908                ..Station::default()
909            };
910            engine.session.store.upsert(&station).unwrap();
911            engine
912                .session
913                .store
914                .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
915                .unwrap();
916            engine.play(&station.stationuuid).unwrap();
917            engine.playback.random_filter = Some(Filter::default());
918            engine.playback.session_started = true;
919            let deadline = Instant::now() + Duration::from_secs(3);
920            while !engine.session.playback_failed {
921                engine.tick().unwrap();
922                assert!(
923                    Instant::now() < deadline,
924                    "{}",
925                    engine.session.status.message
926                );
927                std::thread::sleep(Duration::from_millis(10));
928            }
929            let error = engine.playback_error().unwrap();
930            assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
931            assert_eq!(error.params["device"], "test/fail");
932            assert_eq!(engine.playback.tried.len(), 1);
933            assert!(!engine.playback_active());
934            assert!(!engine.playback.refreshed);
935            assert!(engine.playback.reconnect_window.is_empty());
936            engine.shutdown().unwrap();
937        }
938        assert_eq!(requests.load(Ordering::Relaxed), 0);
939        let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
940        assert_eq!(
941            commands
942                .lines()
943                .filter(|s| s.contains("\"loadfile\""))
944                .count(),
945            2
946        );
947    }
948
949    #[test]
950    fn background_player_startup_preserves_dependency_failure() {
951        let dir = tempfile::tempdir().unwrap();
952        let mut config = crate::test_support::config(dir.path());
953        config.settings.mpv = dir
954            .path()
955            .join("missing-mpv")
956            .to_string_lossy()
957            .into_owned();
958        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
959        engine.enable_background_media().unwrap();
960        engine.play("https://example.com/live").unwrap();
961        let deadline = Instant::now() + Duration::from_secs(3);
962        while !engine.session.playback_failed {
963            engine.tick().unwrap();
964            assert!(Instant::now() < deadline);
965            std::thread::sleep(Duration::from_millis(10));
966        }
967        assert_eq!(
968            engine.playback_error().unwrap().code,
969            ErrorCode::MissingDependency
970        );
971        assert!(!engine.playback_active());
972    }
973
974    #[test]
975    fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
976        use crate::test_support::{Server, config, fixture, response};
977        let bytes = fixture("libmp3lame", "mp3");
978        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
979        let dir = tempfile::tempdir().unwrap();
980        let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
981        let station = Station {
982            stationuuid: uuid::Uuid::new_v4().to_string(),
983            name: "Saved station".into(),
984            url: server.url.clone(),
985            active: true,
986            custom: true,
987            ..Station::default()
988        };
989        engine.session.store.upsert(&station).unwrap();
990        engine.session.status.station = Some(station.clone());
991        engine.session.status.playback_state = PlaybackState::Playing;
992        engine.playback.url = server.url.clone();
993        engine.record_current(None, None).unwrap();
994        let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
995        conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
996        assert!(engine.play("https://example.com/audition").is_err());
997        assert_eq!(
998            engine.session.status.station.as_ref().unwrap().stationuuid,
999            station.stationuuid
1000        );
1001        assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
1002    }
1003
1004    #[test]
1005    fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
1006        use crate::test_support::{Server, config, fixture, response};
1007        let bytes = fixture("libmp3lame", "mp3");
1008        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
1009        for background in [false, true] {
1010            for title in [
1011                "Björk / 中文\x1b\n".to_owned(),
1012                String::new(),
1013                "曲".repeat(100),
1014            ] {
1015                let dir = tempfile::tempdir().unwrap();
1016                let mut engine =
1017                    Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
1018                if background {
1019                    engine.enable_background_media().unwrap();
1020                }
1021                let station = Station {
1022                    stationuuid: uuid::Uuid::new_v4().to_string(),
1023                    name: if title.starts_with('曲') {
1024                        "台".repeat(60)
1025                    } else {
1026                        "Station".into()
1027                    },
1028                    url: server.url.clone(),
1029                    custom: true,
1030                    active: true,
1031                    ..Station::default()
1032                };
1033                engine.session.store.upsert(&station).unwrap();
1034                engine.session.status.station = Some(station);
1035                engine.session.status.playback_state = PlaybackState::Playing;
1036                engine.session.status.title = title.clone();
1037                engine.playback.url = server.url.clone();
1038                engine
1039                    .record_current(Some(Duration::from_secs(1)), None)
1040                    .unwrap();
1041                engine.session.status.title = "Next track".into();
1042                let deadline = Instant::now() + Duration::from_secs(8);
1043                while engine.session.status.recording_path.is_empty() {
1044                    engine.tick().unwrap();
1045                    assert!(
1046                        Instant::now() < deadline,
1047                        "{}",
1048                        engine.session.status.message
1049                    );
1050                    std::thread::sleep(Duration::from_millis(10));
1051                }
1052                let record = engine.session.store.recordings(1).unwrap().remove(0);
1053                let expected = crate::clean_text(&title).trim().to_owned();
1054                assert_eq!(
1055                    record.track.as_deref(),
1056                    (!expected.is_empty()).then_some(expected.as_str())
1057                );
1058                let final_path = record.final_path.clone().unwrap();
1059                let name = std::path::Path::new(&record.path)
1060                    .file_name()
1061                    .unwrap()
1062                    .to_str()
1063                    .unwrap();
1064                assert!(name.len() + ".json.tmp".len() <= 255);
1065                if title.starts_with("Björk") {
1066                    assert!(name.contains("-Station-Björk_中文-"));
1067                }
1068                if title.is_empty() {
1069                    assert!(name.contains("-Station-"));
1070                }
1071                while engine.session.status.recording()
1072                    || engine.session.status.recording_state == RecordingState::Finalizing
1073                {
1074                    engine.tick().unwrap();
1075                    assert!(
1076                        Instant::now() < deadline,
1077                        "{}",
1078                        engine.session.status.message
1079                    );
1080                    std::thread::sleep(Duration::from_millis(10));
1081                }
1082                let saved = engine.session.store.recording(&record.id).unwrap();
1083                assert_eq!(saved.status, "complete", "{:?}", saved.error);
1084                assert_eq!(saved.path, final_path);
1085                assert_eq!(saved.track, record.track);
1086                let sidecar: crate::model::Recording =
1087                    serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
1088                        .unwrap();
1089                assert_eq!(sidecar.track, saved.track);
1090                let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
1091                assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
1092            }
1093        }
1094    }
1095
1096    #[test]
1097    fn changing_station_clears_finished_recording_status() {
1098        let dir = tempfile::tempdir().unwrap();
1099        let config = crate::test_support::config(dir.path());
1100        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1101        for state in [
1102            RecordingState::Done,
1103            RecordingState::Failed {
1104                reason: "disk".into(),
1105            },
1106        ] {
1107            engine.session.status.recording_state = state;
1108            engine.session.status.recording_path = "old.mp3".into();
1109            engine.session.status.recording_ms = 1000;
1110            // No source reaches mpv; the new station still owns clean status.
1111            assert!(
1112                engine
1113                    .playback
1114                    .play_source(
1115                        &mut engine.session,
1116                        &mut engine.recording,
1117                        Station::default(),
1118                        vec![],
1119                        playback::SourceKind::Catalog
1120                    )
1121                    .is_err()
1122            );
1123            assert_eq!(engine.session.status.recording_state, RecordingState::Idle);
1124            assert!(engine.session.status.recording_path.is_empty());
1125            assert_eq!(engine.session.status.recording_ms, 0);
1126        }
1127    }
1128
1129    #[test]
1130    fn flapping_reconnects_have_a_sliding_window_limit() {
1131        let dir = tempfile::tempdir().unwrap();
1132        let config = crate::test_support::config(dir.path());
1133        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1134        engine.session.status.station = Some(Station {
1135            custom: true,
1136            ..Station::default()
1137        });
1138        engine.playback.session_started = true;
1139        engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
1140        engine
1141            .playback
1142            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1143            .unwrap();
1144        assert!(engine.session.playback_failed);
1145        assert!(!engine.session.status.muted);
1146        assert_eq!(engine.playback.reconnect_attempts, 0);
1147        assert!(engine.playback.reconnect_window.is_empty());
1148        assert!(engine.playback.reconnect_due.is_none());
1149        let failed_state = engine.session.status.playback_state.clone();
1150        for _ in 0..3 {
1151            engine.tick().unwrap();
1152            assert!(engine.session.playback_failed);
1153            assert_eq!(engine.session.status.playback_state, failed_state);
1154            assert!(!engine.playback_active());
1155        }
1156        engine.playback.reconnect_window =
1157            std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
1158        engine
1159            .playback
1160            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1161            .unwrap();
1162        assert!(engine.playback.reconnect_due.is_some());
1163        assert_eq!(engine.playback.reconnect_window.len(), 1);
1164    }
1165
1166    #[test]
1167    fn reconnect_budget_is_bounded_and_stop_cancels_it() {
1168        let dir = tempfile::tempdir().unwrap();
1169        let config = crate::test_support::config(dir.path());
1170        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1171        engine.session.status.station = Some(Station {
1172            custom: true,
1173            name: "Test".into(),
1174            ..Station::default()
1175        });
1176        engine.session.status.muted = true;
1177        engine.playback.session_started = true;
1178        for delay in [1, 3, 7] {
1179            engine
1180                .playback
1181                .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1182                .unwrap();
1183            let remaining = engine
1184                .playback
1185                .reconnect_due
1186                .unwrap()
1187                .saturating_duration_since(Instant::now());
1188            assert!(remaining <= Duration::from_secs(delay));
1189            assert!(remaining > Duration::from_millis(delay * 1000 - 100));
1190            assert!(!engine.session.playback_failed);
1191        }
1192        engine.playback.reconnect_due = None;
1193        engine
1194            .playback
1195            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1196            .unwrap();
1197        assert!(engine.session.playback_failed);
1198        assert!(!engine.session.status.muted);
1199        assert_eq!(engine.playback.reconnect_attempts, 0);
1200        assert!(engine.playback.reconnect_window.is_empty());
1201        assert!(engine.playback.reconnect_due.is_none());
1202        engine.playback.reconnect_attempts = 0;
1203        engine
1204            .playback
1205            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1206            .unwrap();
1207        engine.session.status.muted = true;
1208        engine.stop_playback().unwrap();
1209        assert!(!engine.session.status.muted);
1210        assert_eq!(engine.playback.reconnect_attempts, 0);
1211        assert!(engine.playback.reconnect_window.is_empty());
1212        assert!(engine.playback.reconnect_due.is_none());
1213        let generation = engine.playback.generation;
1214        engine.tick().unwrap();
1215        assert_eq!(engine.playback.generation, generation);
1216        assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
1217    }
1218}