Skip to main content

radio_cli/
engine.rs

1pub(crate) mod artwork;
2mod playback;
3mod recording;
4mod status;
5use playback::PlaybackController;
6use recording::RecordingController;
7pub use status::{PlaybackState, RecordingState};
8
9use crate::error::{DomainError, ErrorCode};
10use crate::{
11    config::Config,
12    directory::Directory,
13    model::{Filter, Station},
14    player::{Event, Player},
15    process::{Background, MediaLock},
16    recorder::{self, Recorder},
17    store::Store,
18};
19use anyhow::{Context, Result, bail};
20use std::{
21    collections::VecDeque,
22    sync::{Arc, atomic::AtomicBool},
23    time::{Duration, Instant},
24};
25
26#[derive(Debug, Clone, PartialEq, Eq)]
27pub struct Status {
28    pub station: Option<Station>,
29    pub title: String,
30    pub message: String,
31    pub playback_state: PlaybackState,
32    pub volume: u8,
33    pub muted: bool,
34    pub recording_state: RecordingState,
35    pub recording_ms: u64,
36    pub recording_path: String,
37    pub source_url: String,
38}
39
40impl Status {
41    pub(crate) fn control_eq(&self, other: &Self) -> bool {
42        self.station == other.station
43            && self.title == other.title
44            && self.message == other.message
45            && self.playback_state == other.playback_state
46            && self.recording_state == other.recording_state
47            && self.volume == other.volume
48            && self.muted == other.muted
49            && self.recording_path == other.recording_path
50            && self.source_url == other.source_url
51    }
52    pub(crate) fn ui_eq(&self, other: &Self) -> bool {
53        self.control_eq(other) && self.recording_ms / 1000 == other.recording_ms / 1000
54    }
55    pub fn playing(&self) -> bool {
56        matches!(
57            self.playback_state,
58            PlaybackState::Playing | PlaybackState::Paused
59        )
60    }
61    pub fn paused(&self) -> bool {
62        self.playback_state == PlaybackState::Paused
63    }
64    pub fn recording(&self) -> bool {
65        matches!(
66            self.recording_state,
67            RecordingState::Probing | RecordingState::Recording
68        )
69    }
70}
71
72pub struct Engine {
73    session: Session,
74    playback: PlaybackController,
75    recording: RecordingController,
76}
77
78/// Shared services and published session state owned by the engine.
79pub struct Session {
80    pub subtitles: crate::speech::Controller,
81    pub(crate) artwork: artwork::Controller,
82    pub config: Config,
83    pub store: Store,
84    pub directory: Directory,
85    pub status: Status,
86    pub stop: Arc<AtomicBool>,
87    pub(crate) _lock: Arc<MediaLock>,
88    pub(crate) background_media: bool,
89    pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
90    pub(crate) library_task: Option<Background<String>>,
91    pub playback_failed: bool,
92}
93
94impl std::ops::Deref for Engine {
95    type Target = Session;
96    fn deref(&self) -> &Session {
97        &self.session
98    }
99}
100impl std::ops::DerefMut for Engine {
101    fn deref_mut(&mut self) -> &mut Session {
102        &mut self.session
103    }
104}
105
106impl Engine {
107    pub fn bootstrap(&mut self) -> Result<usize> {
108        self.session.directory.bootstrap(&mut self.session.store)
109    }
110    pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
111        let lock = MediaLock::acquire(&config.runtime_dir)?;
112        let store = Store::open(&config.data_dir.join("radio.db"))?;
113        if let Some(volume) = store
114            .meta("pref_volume")?
115            .and_then(|v| v.parse::<u8>().ok())
116            .filter(|v| *v <= 100)
117        {
118            config.settings.volume = volume;
119        }
120        let recovery_warnings = recorder::recover(&store)?;
121        let directory = Directory::new(&config, stop.clone())?;
122        let status = Status {
123            station: None,
124            title: String::new(),
125            message: if recovery_warnings.is_empty() {
126                crate::t!("status_ready").into()
127            } else {
128                recovery_warnings.join("\n")
129            },
130            playback_state: PlaybackState::Idle,
131            volume: config.settings.volume,
132            muted: false,
133            recording_state: RecordingState::Idle,
134            recording_ms: 0,
135            recording_path: String::new(),
136            source_url: String::new(),
137        };
138        Ok(Self {
139            session: Session {
140                subtitles: crate::speech::Controller::default(),
141                artwork: artwork::Controller::default(),
142                config,
143                store,
144                directory,
145                status,
146                stop,
147                _lock: Arc::new(lock),
148                background_media: false,
149                diagnostics: None,
150                library_task: None,
151                playback_failed: false,
152            },
153            playback: PlaybackController {
154                generation: 0,
155                refresh_task: None,
156                click_task: None,
157                player: None,
158                player_start: None,
159                retiring: vec![],
160                url: String::new(),
161                candidates: VecDeque::new(),
162                tried: vec![],
163                refreshed: false,
164                confirmed: false,
165                session_started: false,
166                source_kind: playback::SourceKind::Catalog,
167                local_recording_id: None,
168                reconnect_attempts: 0,
169                reconnect_due: None,
170                reconnect_window: VecDeque::new(),
171                started: Instant::now(),
172                random_filter: None,
173                random_tried: vec![],
174                failure: None,
175            },
176            recording: RecordingController {
177                recording_probe: None,
178                retiring_probes: vec![],
179                finalizing: None,
180                recorder: None,
181            },
182        })
183    }
184
185    pub fn play(&mut self, uuid: &str) -> Result<()> {
186        let result = self
187            .playback
188            .play(&mut self.session, &mut self.recording, uuid);
189        if let Err(error) = &result
190            && !self.playback_active()
191        {
192            self.status.playback_state = PlaybackState::Failed {
193                reason: format!("{error:#}"),
194            };
195        }
196        result
197    }
198
199    pub fn resume_last_station(&mut self) -> Result<()> {
200        self.playback
201            .resume_last_station(&mut self.session, &mut self.recording)
202    }
203
204    pub fn play_recording(&mut self, id: &str) -> Result<()> {
205        let result = self
206            .playback
207            .play_recording(&mut self.session, &mut self.recording, id);
208        if let Err(error) = &result
209            && !self.playback_active()
210        {
211            self.status.playback_state = PlaybackState::Failed {
212                reason: format!("{error:#}"),
213            };
214        }
215        result
216    }
217
218    pub fn random(&mut self, filter: Filter) -> Result<()> {
219        let result = self
220            .playback
221            .random(&mut self.session, &mut self.recording, filter);
222        if let Err(error) = &result
223            && !self.playback_active()
224        {
225            self.status.playback_state = PlaybackState::Failed {
226                reason: format!("{error:#}"),
227            };
228        }
229        result
230    }
231
232    pub fn tick(&mut self) -> Result<()> {
233        self.poll_background()?;
234        self.playback.tick(&mut self.session, &mut self.recording)?;
235        self.recording
236            .recording_tick(&mut self.session, &mut self.playback)?;
237        self.subtitle_tick();
238        self.artwork_tick();
239        Ok(())
240    }
241
242    fn subtitle_tick(&mut self) {
243        if !self.background_media {
244            return;
245        }
246        if self.subtitles.snapshot.enabled && !self.artwork.quiescent() {
247            self.artwork.cancel();
248            return;
249        }
250        let playing = self.status.playback_state == PlaybackState::Playing;
251        let paused = self.status.paused();
252        let local = self.playback.source_kind == playback::SourceKind::Local;
253        let generation = self.playback.generation;
254        let session = &mut self.session;
255        let key = (generation, session.status.source_url.as_str());
256        session
257            .subtitles
258            .update(&session.config, key, playing, paused, local, &session.stop);
259    }
260
261    pub fn set_subtitles(&mut self, enabled: bool) {
262        self.subtitles.enabled(enabled);
263    }
264    pub fn retry_subtitles(&mut self) {
265        self.subtitles.retry();
266    }
267    pub fn clear_subtitles(&mut self) {
268        self.subtitles.clear();
269    }
270    pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
271        crate::speech::validate_model(&id)?;
272        let mut settings = self.config.settings.subtitles.clone();
273        settings.model = id;
274        settings.validate()?;
275        self.config.settings.subtitles = settings;
276        self.subtitles.retry();
277        self.subtitles.clear();
278        Ok(())
279    }
280
281    fn artwork_tick(&mut self) {
282        let request = (self.background_media
283            && !self.subtitles.snapshot.enabled
284            && self.subtitles.quiescent()
285            && self.config.settings.artwork == crate::config::ArtworkMode::Track
286            && self.status.playback_state == PlaybackState::Playing
287            && !matches!(
288                self.status.recording_state,
289                RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
290            )
291            && self.playback.source_kind != playback::SourceKind::Local
292            && self.playback.retiring.is_empty()
293            && self.recording.retiring_probes.is_empty()
294            && !self.status.title.is_empty())
295        .then(|| self.status.station.as_ref())
296        .flatten()
297        .filter(|station| {
298            station.hls == 0 && self.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
299        })
300        .filter(|_| crate::config::validate_url(&self.status.source_url).is_ok())
301        .map(|station| artwork::Request {
302            stationuuid: station.stationuuid.clone(),
303            source_url: self.status.source_url.clone(),
304            title: self.status.title.clone(),
305        });
306        let session = &mut self.session;
307        session.artwork.update(&session.config, request);
308    }
309
310    pub fn pause(&mut self) -> Result<()> {
311        self.playback.pause(&mut self.session, &mut self.recording)
312    }
313    pub fn mute(&mut self) -> Result<()> {
314        self.playback
315            .player
316            .as_mut()
317            .context(DomainError::new(ErrorCode::NotPlaying))?
318            .toggle_mute()
319    }
320
321    pub fn volume(&mut self, delta: i32) -> Result<()> {
322        self.playback
323            .volume(&mut self.session, &mut self.recording, delta)
324    }
325
326    pub fn stop_playback(&mut self) -> Result<()> {
327        self.playback
328            .stop_playback(&mut self.session, &mut self.recording)
329    }
330
331    pub fn toggle_recording(&mut self) -> Result<()> {
332        let result = self
333            .recording
334            .toggle_recording(&mut self.session, &mut self.playback);
335        if let Err(error) = &result
336            && self.recording.recorder.is_none()
337            && self.recording.recording_probe.is_none()
338            && self.recording.finalizing.is_none()
339        {
340            self.status.recording_state = RecordingState::Failed {
341                reason: format!("{error:#}"),
342            };
343        }
344        result
345    }
346
347    pub fn record_current(
348        &mut self,
349        duration: Option<Duration>,
350        dir: Option<&std::path::Path>,
351    ) -> Result<()> {
352        let result =
353            self.recording
354                .record_current(&mut self.session, &mut self.playback, duration, dir);
355        if let Err(error) = &result
356            && self.recording.recorder.is_none()
357            && self.recording.recording_probe.is_none()
358            && self.recording.finalizing.is_none()
359        {
360            self.status.recording_state = RecordingState::Failed {
361                reason: format!("{error:#}"),
362            };
363        }
364        result
365    }
366
367    pub fn standalone_record(
368        &mut self,
369        uuid: &str,
370        duration: Option<Duration>,
371        dir: Option<&std::path::Path>,
372    ) -> Result<()> {
373        let result = self.recording.standalone_record(
374            &mut self.session,
375            &mut self.playback,
376            uuid,
377            duration,
378            dir,
379        );
380        if let Err(error) = &result
381            && self.recording.recorder.is_none()
382            && self.recording.recording_probe.is_none()
383            && self.recording.finalizing.is_none()
384        {
385            self.status.recording_state = RecordingState::Failed {
386                reason: format!("{error:#}"),
387            };
388        }
389        result
390    }
391
392    pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
393        self.recording
394            .stop_recording(&mut self.session, &mut self.playback, reason)
395    }
396
397    pub(crate) fn enable_background_media(&mut self) {
398        self.background_media = true;
399        let enabled = self.config.settings.subtitles.enabled;
400        self.subtitles.enabled(enabled);
401    }
402
403    pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
404        if self.library_task.is_some() {
405            bail!(DomainError::new(ErrorCode::RecordingBusy));
406        }
407        if self.playback.local_recording_id.as_deref() == Some(&id) {
408            self.stop_playback()?;
409        }
410        let path = self.config.data_dir.join("radio.db");
411        let lock = self._lock.clone();
412        self.library_task = Some(Background::start(
413            "radio-recording-delete",
414            move |cancel| {
415                let _lock = lock;
416                if cancel.load(std::sync::atomic::Ordering::Relaxed) {
417                    bail!(DomainError::new(ErrorCode::Cancelled));
418                }
419                crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
420                Ok(crate::t!("recording_deleted", "id" => id))
421            },
422        )?);
423        Ok(())
424    }
425
426    pub fn open_recordings(&mut self) -> Result<()> {
427        if self.library_task.is_some() {
428            bail!(DomainError::new(ErrorCode::RecordingBusy));
429        }
430        let dir = self.config.recording_dir.clone();
431        self.library_task = Some(Background::start("radio-open-recordings", move |cancel| {
432            crate::service::open_recordings(&dir, &cancel)?;
433            Ok(crate::t!("recordings_opened", "path" => dir.display()))
434        })?);
435        Ok(())
436    }
437
438    pub fn playback_active(&self) -> bool {
439        self.playback.player.is_some()
440            || self.playback.player_start.is_some()
441            || self.playback.refresh_task.is_some()
442            || self.playback.reconnect_due.is_some()
443    }
444
445    pub fn playback_error(&self) -> Option<&DomainError> {
446        self.playback.failure.as_ref()
447    }
448
449    pub fn shutdown(&mut self) -> Result<()> {
450        self.stop_playback()?;
451        self.subtitles.enabled(false);
452        self.playback.click_task = None;
453        self.diagnostics = None;
454        // Allow normal finalization, then cancel verification if its budget
455        // expires. Outstanding HTTP results never need joining.
456        let deadline = Instant::now() + Duration::from_secs(6);
457        while (self.recording.finalizing.is_some()
458            || !self.playback.retiring.is_empty()
459            || !self.recording.retiring_probes.is_empty()
460            || !self.artwork.quiescent()
461            || !self.subtitles.quiescent())
462            && Instant::now() < deadline
463        {
464            self.poll_background()?;
465            std::thread::sleep(Duration::from_millis(10));
466        }
467        self.recording.finalizing = None;
468        Ok(())
469    }
470
471    fn poll_background(&mut self) -> Result<()> {
472        self.subtitles.poll_retiring();
473        if let Some(result) = self.library_task.as_ref().and_then(Background::poll) {
474            self.library_task = None;
475            self.status.message = match result {
476                Ok(message) => message,
477                Err(error) => {
478                    crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
479                }
480            };
481        }
482        self.playback
483            .poll_background(&mut self.session, &mut self.recording)?;
484        self.recording
485            .record_poll_background(&mut self.session, &mut self.playback)
486    }
487}
488
489impl Drop for Engine {
490    fn drop(&mut self) {
491        let _ = self.shutdown();
492    }
493}
494
495#[cfg(test)]
496mod tests {
497    use super::*;
498
499    #[test]
500    fn invalid_subtitle_model_reports_id_without_changing_settings() {
501        let dir = tempfile::tempdir().unwrap();
502        let config = crate::test_support::config(dir.path());
503        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
504        let original = engine.config.settings.subtitles.model.clone();
505        for id in ["unknown", "silero-vad", "../../model"] {
506            let error = engine.set_subtitle_model(id.into()).unwrap_err();
507            let error = error.downcast_ref::<DomainError>().unwrap();
508            assert_eq!(error.code, ErrorCode::SubtitleModel);
509            assert_eq!(engine.config.settings.subtitles.model, original);
510        }
511    }
512
513    #[test]
514    fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
515        use crate::test_support::{Server, fake_mpv};
516        use std::sync::atomic::{AtomicUsize, Ordering};
517        let requests = Arc::new(AtomicUsize::new(0));
518        let counter = requests.clone();
519        let server = Server::new(move |_, _| {
520            counter.fetch_add(1, Ordering::Relaxed);
521        });
522        let dir = tempfile::tempdir().unwrap();
523        let mpv = fake_mpv(dir.path());
524        for background in [false, true] {
525            let data = dir.path().join(background.to_string());
526            let mut config = crate::test_support::config_with_api(&data, &server.url);
527            config.settings.mpv = mpv.to_string_lossy().into_owned();
528            config.settings.audio_device = Some("test/fail".into());
529            let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
530            engine.session.background_media = background;
531            let station = Station {
532                stationuuid: uuid::Uuid::new_v4().to_string(),
533                name: "Catalog station".into(),
534                url: format!("{}/live", server.url),
535                active: true,
536                ..Station::default()
537            };
538            engine.store.upsert(&station).unwrap();
539            engine
540                .store
541                .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
542                .unwrap();
543            engine.play(&station.stationuuid).unwrap();
544            engine.playback.random_filter = Some(Filter::default());
545            engine.playback.session_started = true;
546            let deadline = Instant::now() + Duration::from_secs(3);
547            while !engine.playback_failed {
548                engine.tick().unwrap();
549                assert!(Instant::now() < deadline, "{}", engine.status.message);
550                std::thread::sleep(Duration::from_millis(10));
551            }
552            let error = engine.playback_error().unwrap();
553            assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
554            assert_eq!(error.params["device"], "test/fail");
555            assert_eq!(engine.playback.tried.len(), 1);
556            assert!(!engine.playback_active());
557            assert!(!engine.playback.refreshed);
558            assert!(engine.playback.reconnect_window.is_empty());
559            engine.shutdown().unwrap();
560        }
561        assert_eq!(requests.load(Ordering::Relaxed), 0);
562        let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
563        assert_eq!(
564            commands
565                .lines()
566                .filter(|s| s.contains("\"loadfile\""))
567                .count(),
568            2
569        );
570    }
571
572    #[test]
573    fn background_player_startup_preserves_dependency_failure() {
574        let dir = tempfile::tempdir().unwrap();
575        let mut config = crate::test_support::config(dir.path());
576        config.settings.mpv = dir
577            .path()
578            .join("missing-mpv")
579            .to_string_lossy()
580            .into_owned();
581        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
582        engine.enable_background_media();
583        engine.play("https://example.com/live").unwrap();
584        let deadline = Instant::now() + Duration::from_secs(3);
585        while !engine.playback_failed {
586            engine.tick().unwrap();
587            assert!(Instant::now() < deadline);
588            std::thread::sleep(Duration::from_millis(10));
589        }
590        assert_eq!(
591            engine.playback_error().unwrap().code,
592            ErrorCode::MissingDependency
593        );
594        assert!(!engine.playback_active());
595    }
596
597    #[test]
598    fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
599        use crate::test_support::{Server, config, fixture, response};
600        let bytes = fixture("libmp3lame", "mp3");
601        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
602        let dir = tempfile::tempdir().unwrap();
603        let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
604        let station = Station {
605            stationuuid: uuid::Uuid::new_v4().to_string(),
606            name: "Saved station".into(),
607            url: server.url.clone(),
608            active: true,
609            custom: true,
610            ..Station::default()
611        };
612        engine.store.upsert(&station).unwrap();
613        engine.status.station = Some(station.clone());
614        engine.status.playback_state = PlaybackState::Playing;
615        engine.playback.url = server.url.clone();
616        engine.record_current(None, None).unwrap();
617        let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
618        conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
619        assert!(engine.play("https://example.com/audition").is_err());
620        assert_eq!(
621            engine.status.station.as_ref().unwrap().stationuuid,
622            station.stationuuid
623        );
624        assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
625    }
626
627    #[test]
628    fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
629        use crate::test_support::{Server, config, fixture, response};
630        let bytes = fixture("libmp3lame", "mp3");
631        let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
632        for background in [false, true] {
633            for title in [
634                "Björk / 中文\x1b\n".to_owned(),
635                String::new(),
636                "曲".repeat(100),
637            ] {
638                let dir = tempfile::tempdir().unwrap();
639                let mut engine =
640                    Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
641                if background {
642                    engine.enable_background_media();
643                }
644                let station = Station {
645                    stationuuid: uuid::Uuid::new_v4().to_string(),
646                    name: if title.starts_with('曲') {
647                        "台".repeat(60)
648                    } else {
649                        "Station".into()
650                    },
651                    url: server.url.clone(),
652                    custom: true,
653                    active: true,
654                    ..Station::default()
655                };
656                engine.store.upsert(&station).unwrap();
657                engine.status.station = Some(station);
658                engine.status.playback_state = PlaybackState::Playing;
659                engine.status.title = title.clone();
660                engine.playback.url = server.url.clone();
661                engine
662                    .record_current(Some(Duration::from_secs(1)), None)
663                    .unwrap();
664                engine.status.title = "Next track".into();
665                let deadline = Instant::now() + Duration::from_secs(8);
666                while engine.status.recording_path.is_empty() {
667                    engine.tick().unwrap();
668                    assert!(Instant::now() < deadline, "{}", engine.status.message);
669                    std::thread::sleep(Duration::from_millis(10));
670                }
671                let record = engine.store.recordings(1).unwrap().remove(0);
672                let expected = crate::clean_text(&title).trim().to_owned();
673                assert_eq!(
674                    record.track.as_deref(),
675                    (!expected.is_empty()).then_some(expected.as_str())
676                );
677                let final_path = record.final_path.clone().unwrap();
678                let name = std::path::Path::new(&record.path)
679                    .file_name()
680                    .unwrap()
681                    .to_str()
682                    .unwrap();
683                assert!(name.len() + ".json.tmp".len() <= 255);
684                if title.starts_with("Björk") {
685                    assert!(name.contains("-Station-Björk_中文-"));
686                }
687                if title.is_empty() {
688                    assert!(name.contains("-Station-"));
689                }
690                while engine.status.recording()
691                    || engine.status.recording_state == RecordingState::Finalizing
692                {
693                    engine.tick().unwrap();
694                    assert!(Instant::now() < deadline, "{}", engine.status.message);
695                    std::thread::sleep(Duration::from_millis(10));
696                }
697                let saved = engine.store.recording(&record.id).unwrap();
698                assert_eq!(saved.status, "complete", "{:?}", saved.error);
699                assert_eq!(saved.path, final_path);
700                assert_eq!(saved.track, record.track);
701                let sidecar: crate::model::Recording =
702                    serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
703                        .unwrap();
704                assert_eq!(sidecar.track, saved.track);
705                let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
706                assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
707            }
708        }
709    }
710
711    #[test]
712    fn changing_station_clears_finished_recording_status() {
713        let dir = tempfile::tempdir().unwrap();
714        let config = crate::test_support::config(dir.path());
715        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
716        for state in [
717            RecordingState::Done,
718            RecordingState::Failed {
719                reason: "disk".into(),
720            },
721        ] {
722            engine.status.recording_state = state;
723            engine.status.recording_path = "old.mp3".into();
724            engine.status.recording_ms = 1000;
725            // No source reaches mpv; the new station still owns clean status.
726            assert!(
727                engine
728                    .playback
729                    .play_source(
730                        &mut engine.session,
731                        &mut engine.recording,
732                        Station::default(),
733                        vec![],
734                        playback::SourceKind::Catalog
735                    )
736                    .is_err()
737            );
738            assert_eq!(engine.status.recording_state, RecordingState::Idle);
739            assert!(engine.status.recording_path.is_empty());
740            assert_eq!(engine.status.recording_ms, 0);
741        }
742    }
743
744    #[test]
745    fn flapping_reconnects_have_a_sliding_window_limit() {
746        let dir = tempfile::tempdir().unwrap();
747        let config = crate::test_support::config(dir.path());
748        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
749        engine.status.station = Some(Station {
750            custom: true,
751            ..Station::default()
752        });
753        engine.playback.session_started = true;
754        engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
755        engine
756            .playback
757            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
758            .unwrap();
759        assert!(engine.playback_failed);
760        assert!(!engine.status.muted);
761        assert_eq!(engine.playback.reconnect_attempts, 0);
762        assert!(engine.playback.reconnect_window.is_empty());
763        assert!(engine.playback.reconnect_due.is_none());
764        let failed_state = engine.status.playback_state.clone();
765        for _ in 0..3 {
766            engine.tick().unwrap();
767            assert!(engine.playback_failed);
768            assert_eq!(engine.status.playback_state, failed_state);
769            assert!(!engine.playback_active());
770        }
771        engine.playback.reconnect_window =
772            std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
773        engine
774            .playback
775            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
776            .unwrap();
777        assert!(engine.playback.reconnect_due.is_some());
778        assert_eq!(engine.playback.reconnect_window.len(), 1);
779    }
780
781    #[test]
782    fn reconnect_budget_is_bounded_and_stop_cancels_it() {
783        let dir = tempfile::tempdir().unwrap();
784        let config = crate::test_support::config(dir.path());
785        let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
786        engine.status.station = Some(Station {
787            custom: true,
788            name: "Test".into(),
789            ..Station::default()
790        });
791        engine.status.muted = true;
792        engine.playback.session_started = true;
793        for delay in [1, 3, 7] {
794            engine
795                .playback
796                .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
797                .unwrap();
798            let remaining = engine
799                .playback
800                .reconnect_due
801                .unwrap()
802                .saturating_duration_since(Instant::now());
803            assert!(remaining <= Duration::from_secs(delay));
804            assert!(remaining > Duration::from_millis(delay * 1000 - 100));
805            assert!(!engine.playback_failed);
806        }
807        engine.playback.reconnect_due = None;
808        engine
809            .playback
810            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
811            .unwrap();
812        assert!(engine.playback_failed);
813        assert!(!engine.status.muted);
814        assert_eq!(engine.playback.reconnect_attempts, 0);
815        assert!(engine.playback.reconnect_window.is_empty());
816        assert!(engine.playback.reconnect_due.is_none());
817        engine.playback.reconnect_attempts = 0;
818        engine
819            .playback
820            .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
821            .unwrap();
822        engine.status.muted = true;
823        engine.stop_playback().unwrap();
824        assert!(!engine.status.muted);
825        assert_eq!(engine.playback.reconnect_attempts, 0);
826        assert!(engine.playback.reconnect_window.is_empty());
827        assert!(engine.playback.reconnect_due.is_none());
828        let generation = engine.playback.generation;
829        engine.tick().unwrap();
830        assert_eq!(engine.playback.generation, generation);
831        assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
832    }
833}