Skip to content

Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.

76.3 KB
Raw Blame
use super::App;
use crate::providers::models::ProviderKind;
use crate::tui::text::parse_duration_seconds;
use crate::tui::{action::Action, overlay::NotificationKind, state::Screen};

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum PlaybackResolution {
    Available(crate::tui::state::PlayerKind),
    ExplicitPlayerIncompatible {
        chosen: crate::tui::state::PlayerKind,
        compatible_alternatives: Vec<crate::tui::state::PlayerKind>,
    },
    NoCompatiblePlayer {
        available: Vec<crate::tui::state::PlayerKind>,
    },
    NoPlayersInstalled,
}

impl App {
    pub(super) fn resolve_playback_player(
        &self,
        source: &crate::providers::models::PlaybackSource,
    ) -> PlaybackResolution {
        if self.state.available_players.is_empty() {
            return PlaybackResolution::NoPlayersInstalled;
        }

        let preferred = std::env::var(crate::player::ENV_MOVIEBOX_PLAYER)
            .ok()
            .and_then(|value| crate::tui::state::PlayerKind::parse(&value))
            .or_else(|| {
                let configured = self
                    .state
                    .default_player
                    .as_deref()
                    .filter(|p| !p.eq_ignore_ascii_case("auto"))
                    .and_then(crate::tui::state::PlayerKind::parse);
                if crate::player::has_graphical_display()
                    && configured == Some(crate::tui::state::PlayerKind::AndroidIntent)
                    && self
                        .state
                        .available_players
                        .iter()
                        .any(|&p| p != crate::tui::state::PlayerKind::AndroidIntent)
                {
                    None
                } else {
                    configured
                }
            });

        if let Some(chosen) = preferred {
            if self.state.available_players.contains(&chosen) {
                if crate::tui::player::supports_headers(chosen, &source.headers) {
                    return PlaybackResolution::Available(chosen);
                }
                let compatible_alternatives = self
                    .state
                    .available_players
                    .iter()
                    .copied()
                    .filter(|&k| {
                        k != chosen && crate::tui::player::supports_headers(k, &source.headers)
                    })
                    .collect::<Vec<_>>();
                return PlaybackResolution::ExplicitPlayerIncompatible {
                    chosen,
                    compatible_alternatives,
                };
            }
        }

        if let Some(player) = self
            .state
            .available_players
            .iter()
            .copied()
            .find(|kind| crate::tui::player::supports_headers(*kind, &source.headers))
        {
            PlaybackResolution::Available(player)
        } else {
            PlaybackResolution::NoCompatiblePlayer {
                available: self.state.available_players.clone(),
            }
        }
    }

    pub(super) fn dispatch_playback_or_notify(
        &mut self,
        source: crate::providers::models::PlaybackSource,
    ) {
        match self.resolve_playback_player(&source) {
            PlaybackResolution::Available(player) => {
                self.action_sender
                    .send(Action::LaunchPlayback(player, source))
                    .ok();
            }
            PlaybackResolution::ExplicitPlayerIncompatible {
                chosen,
                compatible_alternatives,
            } => {
                self.state.is_resolving_playback = false;
                self.state.pending_playback_source = None;
                let chosen_name = chosen.label();
                let body = if let Some(first) = compatible_alternatives.first() {
                    format!(
                        "{chosen_name} lacks header support. Switch to {} in /settings.",
                        first.label()
                    )
                } else {
                    format!("{chosen_name} lacks custom header support.")
                };
                self.state.notify(
                    NotificationKind::Warning,
                    format!("{chosen_name} Incompatible"),
                    body,
                );
            }
            PlaybackResolution::NoCompatiblePlayer { available: _ } => {
                self.state.is_resolving_playback = false;
                self.state.pending_playback_source = None;
                self.state.notify(
                    NotificationKind::Error,
                    "Incompatible Player",
                    "Installed player lacks custom stream header support.".to_string(),
                );
            }
            PlaybackResolution::NoPlayersInstalled => {
                self.state.is_resolving_playback = false;
                self.state.pending_playback_source = None;
                let custom_path = match self.state.default_player.as_deref() {
                    Some("vlc") => self.state.vlc_path.as_deref(),
                    Some("mpv") => self.state.mpv_path.as_deref(),
                    Some("iina") => self.state.iina_path.as_deref(),
                    _ => None,
                };
                let (title, message) = if let Some(bad_path) = custom_path {
                    (
                        "Invalid Player Path",
                        format!("Player path not found: {bad_path}"),
                    )
                } else if crate::config::is_termux_environment() {
                    (
                        "No Media Player",
                        "No Android video player or termux-tools detected.".to_string(),
                    )
                } else {
                    (
                        "No Media Player",
                        "No supported media player (mpv, IINA, VLC) found.".to_string(),
                    )
                };
                self.state.notify(NotificationKind::Error, title, message);
            }
        }
    }

    fn build_watch_history_item(&self) -> Option<crate::history::WatchHistoryItem> {
        let subject_id = self.state.active_subject_id.as_ref()?;
        let provider = self.provider_for_subject(subject_id).cache_key();
        let season = self.state.selected_season;
        let episode = self.state.selected_episode;
        let selected_stream_filename = self.get_selected_release().map(|r| r.filename.clone());

        if let Some(details) = &self.state.selected_details {
            let mut item =
                crate::history::WatchHistoryItem::from_details(provider, details, season, episode);
            item.stream_filename = selected_stream_filename;
            if item.cover_url.is_none() {
                item.cover_url = self
                    .state
                    .search_results
                    .iter()
                    .find(|r| r.id == *subject_id)
                    .and_then(|r| r.cover_url.clone())
                    .or_else(|| {
                        self.state
                            .search_preview
                            .as_ref()
                            .filter(|p| p.id.value == *subject_id)
                            .and_then(|p| p.cover_url().map(|s| s.to_string()))
                    });
            }
            if item.duration_seconds.is_none() {
                item.duration_seconds = self
                    .state
                    .search_preview
                    .as_ref()
                    .filter(|p| p.id.value == *subject_id)
                    .and_then(|p| p.duration.as_deref().and_then(parse_duration_seconds));
            }
            return Some(item);
        }

        let res = self
            .state
            .search_results
            .iter()
            .find(|r| r.id == *subject_id);
        let title = res
            .map(|r| r.title.clone())
            .unwrap_or_else(|| "Unknown".to_string());
        let cover_url = res.and_then(|r| r.cover_url.clone());
        let stype = res.map(|r| r.stype).unwrap_or(1);
        let release_year = res
            .map(|r| r.release_year.clone())
            .unwrap_or_else(|| "Unknown".to_string());
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        Some(crate::history::WatchHistoryItem {
            provider: provider.to_string(),
            subject_id: subject_id.clone(),
            title,
            cover_url,
            stype,
            release_year,
            season,
            episode,
            timestamp,
            duration_seconds: None,
            progress_seconds: 0,
            completed: false,
            stream_filename: selected_stream_filename,
        })
    }

    pub(super) fn launch_player(
        &mut self,
        kind: crate::tui::state::PlayerKind,
        link: String,
        subtitle: Option<String>,
        headers: Vec<(String, String)>,
        max_height: Option<u64>,
    ) {
        if !crate::tui::text::is_http_url(&link) {
            self.state.is_playing = false;
            self.state.is_resolving_playback = false;
            self.state.notify(
                NotificationKind::Error,
                "Unsupported stream",
                "Only HTTP/HTTPS streams supported.",
            );
            return;
        }

        let history_item = self.build_watch_history_item();
        let resume_seconds = if let Some(item) = &history_item {
            self.state
                .history
                .get_item(
                    &item.provider,
                    &item.subject_id,
                    item.season,
                    item.episode,
                    Some(&item.title),
                )
                .filter(|existing| existing.is_in_progress())
                .map(|existing| existing.progress_seconds)
        } else {
            None
        };

        self.state.is_playing = true;
        self.state.is_resolving_playback = false;

        let tracker_opts = history_item.as_ref().map(|item| {
            (
                item.provider.clone(),
                item.subject_id.clone(),
                item.season,
                item.episode,
            )
        });
        if let Some(item) = &history_item {
            self.state
                .history
                .record_start(item, resume_seconds.unwrap_or(0));
        }

        if matches!(kind, crate::tui::state::PlayerKind::Mpv)
            && let (Some((p, s, se, ep)), Some(item)) = (&tracker_opts, &history_item)
        {
            if let Some(state_path) = crate::player::tracker::state_file_path(p, s, *se, *ep) {
                let initial_state = crate::history::PendingPlaybackState::from_item(
                    item,
                    resume_seconds.unwrap_or(0),
                    item.duration_seconds,
                    false,
                );
                if let Ok(serialized) = serde_json::to_string(&initial_state) {
                    tokio::task::spawn_blocking(move || {
                        if let Err(e) = std::fs::write(&state_path, serialized) {
                            log::warn!(
                                "failed to write initial playback state to {}: {e}",
                                crate::logging::sanitize_path(&state_path)
                            );
                        }
                    });
                }
            }
        }

        let sender = self.action_sender.clone();
        let cell_size = self
            .state
            .image_picker
            .as_ref()
            .map(|picker| picker.font_size());
        let window = crossterm::terminal::size().ok().map(|(cols, rows)| {
            let (cell_width, cell_height) = cell_size
                .filter(|size| size.width > 0 && size.height > 0)
                .map(|size| (size.width as u32, size.height as u32))
                .unwrap_or((8, 16));
            (
                (cols as u32 * cell_width).clamp(320, 1920),
                (rows as u32 * cell_height).clamp(180, 1080),
            )
        });
        let preferred_sub_name = history_item.as_ref().map(|item| {
            if item.season > 0 || item.episode > 0 {
                format!(
                    "{} - S{:02}E{:02}",
                    item.title,
                    item.season.max(1),
                    item.episode.max(1)
                )
            } else {
                item.title.clone()
            }
        });
        let service = self.service.clone();
        tokio::spawn(async move {
            let is_android = matches!(kind, crate::tui::state::PlayerKind::AndroidIntent);
            let is_dash = crate::player::is_dash_url(&link);
            let has_extra_headers = headers.iter().any(|(name, _)| {
                !name.eq_ignore_ascii_case("referer") && !name.eq_ignore_ascii_case("user-agent")
            });
            let eager_proxy = is_dash
                || (matches!(
                    kind,
                    crate::tui::state::PlayerKind::Vlc
                        | crate::tui::state::PlayerKind::AndroidIntent
                ) && has_extra_headers);
            let sidecar_sub = if is_android {
                subtitle.as_deref()
            } else {
                None
            };

            let eager_sidecar_fut = async {
                if eager_proxy {
                    let link_c = link.clone();
                    let headers_c = headers.clone();
                    let sub_c = sidecar_sub.map(str::to_string);
                    tokio::task::spawn_blocking(move || {
                        crate::proxy::spawn_sidecar(
                            &link_c,
                            &headers_c,
                            sub_c.as_deref(),
                            max_height,
                        )
                    })
                    .await
                    .ok()
                } else {
                    None
                }
            };

            let sub_fut = async {
                if let Some(url) = &subtitle {
                    Some(
                        service
                            .download_subtitle_file(url, &headers, preferred_sub_name.as_deref())
                            .await,
                    )
                } else {
                    None
                }
            };

            let (eager_sidecar_res, sub_res) = tokio::join!(eager_sidecar_fut, sub_fut);

            let mut local_subtitle = subtitle.clone();
            let mut temporary_subtitle = None;
            if let (Some(url), Some(download_res)) = (&subtitle, sub_res) {
                match download_res {
                    Ok(path) => {
                        local_subtitle = Some(path.to_string_lossy().into_owned());
                        if !is_android {
                            temporary_subtitle = Some(path);
                        }
                    }
                    Err(err) => {
                        log::warn!(
                            "subtitle download failed for {:?} player ({err}, url was {})",
                            kind,
                            crate::logging::sanitize_url(url)
                        );
                        if !matches!(kind, crate::tui::state::PlayerKind::Mpv) {
                            local_subtitle = None;
                            let _ = sender.send(Action::SetStatus(format!(
                                "Warning: Subtitle unavailable ({err}); playing without subs."
                            )));
                        }
                    }
                }
            }

            let tracker_ref = tracker_opts
                .as_ref()
                .map(|(p, s, se, ep)| (p.as_str(), s.as_str(), *se, *ep));

            let android_sub_is_private = is_android
                && local_subtitle
                    .as_deref()
                    .is_some_and(|p| p.starts_with("/data/data/com.termux/"));
            let needs_proxy = eager_proxy
                || (is_android
                    && subtitle.is_some()
                    && (local_subtitle.is_none() || android_sub_is_private));

            let mut sidecar_child = None;
            let (effective_link, effective_subtitle) = if needs_proxy {
                let sidecar_outcome = match eager_sidecar_res {
                    Some(res) => res,
                    None => {
                        let link_c = link.clone();
                        let headers_c = headers.clone();
                        let sub_c = sidecar_sub.map(str::to_string);
                        tokio::task::spawn_blocking(move || {
                            crate::proxy::spawn_sidecar(
                                &link_c,
                                &headers_c,
                                sub_c.as_deref(),
                                max_height,
                            )
                        })
                        .await
                        .unwrap_or_else(|e| Err(format!("join error: {e}")))
                    }
                };
                match sidecar_outcome {
                    Ok((local_url, sc_child)) => {
                        sidecar_child = Some(sc_child);
                        let sub_url = if is_android {
                            if local_subtitle.is_some() && !android_sub_is_private {
                                local_subtitle.clone()
                            } else if let Some(remote_sub) = &subtitle {
                                if let Some(authority) = local_url
                                    .strip_prefix("http://")
                                    .and_then(|s| s.split('/').next())
                                {
                                    let encoded = percent_encoding::utf8_percent_encode(
                                        remote_sub,
                                        percent_encoding::NON_ALPHANUMERIC,
                                    );
                                    Some(format!("http://{authority}/sub/{encoded}"))
                                } else {
                                    None
                                }
                            } else {
                                None
                            }
                        } else {
                            local_subtitle.clone()
                        };
                        (local_url, sub_url)
                    }
                    Err(err) => {
                        if matches!(
                            kind,
                            crate::tui::state::PlayerKind::Mpv
                                | crate::tui::state::PlayerKind::Iina
                        ) {
                            log::warn!(
                                "Failed to spawn stream proxy sidecar ({err}), falling back to direct playback"
                            );
                            (link.clone(), local_subtitle.clone())
                        } else {
                            log::error!("Failed to spawn stream proxy sidecar: {err}");
                            let _ = sender.send(Action::PlayerExited);
                            let _ = sender.send(Action::SetStatus(format!(
                                "Error: Stream proxy failed ({err})"
                            )));
                            return;
                        }
                    }
                }
            } else {
                (link.clone(), local_subtitle.clone())
            };

            let log_dir = std::env::temp_dir().join("moviebox-tui").join("subs");
            let _ = std::fs::create_dir_all(&log_dir);
            let log_stamp = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_nanos();
            let log_path = log_dir.join(format!("player_{}_{log_stamp}.log", std::process::id()));

            let spawn_configured_command =
                |mut cmd: std::process::Command, capture_stdout: bool| {
                    cmd.stdin(std::process::Stdio::null());
                    let log_file = std::fs::File::create(&log_path).ok();
                    if capture_stdout {
                        if let Some(cloned) = log_file.as_ref().and_then(|f| f.try_clone().ok()) {
                            cmd.stdout(std::process::Stdio::from(cloned));
                        } else {
                            cmd.stdout(std::process::Stdio::null());
                        }
                    } else {
                        cmd.stdout(std::process::Stdio::null());
                    }
                    if let Some(file) = log_file {
                        cmd.stderr(std::process::Stdio::from(file));
                    } else {
                        cmd.stderr(std::process::Stdio::null());
                    }
                    crate::player::configure_detached_process(&mut cmd);
                    cmd.spawn()
                };
            let command = crate::tui::player::command(
                kind,
                &effective_link,
                effective_subtitle.as_deref(),
                &headers,
                window,
                resume_seconds,
                tracker_ref,
                max_height,
            );
            if kind == crate::tui::state::PlayerKind::Iina
                && crate::player::iina_is_app_fallback()
                && (!headers.is_empty() || subtitle.is_some())
            {
                let _ = sender.send(Action::SetStatus(
                    "Warning: IINA opened without iina-cli: headers and subtitles unavailable."
                        .to_string(),
                ));
            }

            let spawn_result = if is_android {
                let candidates = crate::player::android_intent_commands(
                    &effective_link,
                    effective_subtitle.as_deref(),
                    &headers,
                );
                let mut spawned = None;
                let mut last_err = None;
                for (opener, cmd) in candidates {
                    match spawn_configured_command(cmd, true) {
                        Ok(child) => {
                            log::info!("spawned android opener: {opener:?}");
                            spawned = Some(child);
                            break;
                        }
                        Err(err) => {
                            log::warn!("failed to spawn opener {opener:?}: {err}");
                            last_err = Some(err);
                        }
                    }
                }
                match spawned {
                    Some(child) => Ok(child),
                    None => Err(last_err.unwrap_or_else(|| {
                        std::io::Error::new(
                            std::io::ErrorKind::NotFound,
                            "No Android intent tools found",
                        )
                    })),
                }
            } else {
                log::info!("launching player: {kind:?}");
                spawn_configured_command(command, false)
            };

            match spawn_result {
                Ok(mut child) => {
                    let start_time = std::time::Instant::now();
                    let fallback_link = effective_link.clone();
                    let fallback_sub = effective_subtitle.clone();
                    let fallback_headers = headers.clone();
                    tokio::task::spawn_blocking(move || {
                        let result = child.wait();
                        let error_output = std::fs::read_to_string(&log_path).unwrap_or_default();
                        let _ = std::fs::remove_file(&log_path);

                        match &result {
                            Ok(status)
                                if status.success()
                                    || is_vlc_normal_exit(
                                        kind,
                                        status.code(),
                                        error_output.trim(),
                                    )
                                    || is_user_quit(status) =>
                            {
                                log::info!(
                                    "player {kind:?} finished cleanly (code: {:?}, duration: {}s)",
                                    status.code(),
                                    start_time.elapsed().as_secs()
                                );
                                let has_tracker = tracker_opts.is_some()
                                    && matches!(kind, crate::tui::state::PlayerKind::Mpv);

                                if has_tracker {
                                    sender.send(Action::ReconcileHistory).ok();
                                } else if let Some(item) = history_item {
                                    let elapsed = start_time.elapsed().as_secs();
                                    if elapsed >= 30 {
                                        let duration = item.duration_seconds;
                                        let start_pos = resume_seconds.unwrap_or(0);
                                        let total_pos = start_pos.saturating_add(elapsed);
                                        let progress = if let Some(d) = duration {
                                            total_pos.min(d)
                                        } else {
                                            total_pos
                                        };
                                        let completed = duration.is_some_and(|d| {
                                            d > 0 && progress >= (d as f64 * 0.90) as u64
                                        });
                                        sender
                                            .send(Action::UpdateProgress {
                                                item: Box::new(item),
                                                progress,
                                                duration,
                                                completed,
                                            })
                                            .ok();
                                    }
                                }
                            }
                            Ok(status) => {
                                let is_termux_socket_err = is_android
                                    && (error_output.contains("am.sock")
                                        || error_output.contains("Could not connect to socket")
                                        || error_output.contains("termux-am"));

                                if is_termux_socket_err {
                                    let secondary =
                                        crate::player::android_openers()
                                            .iter()
                                            .find(|op| {
                                                matches!(
                                                op,
                                                crate::player::AndroidOpener::TermuxOpen(_)
                                                    | crate::player::AndroidOpener::TermuxOpenUrl(_)
                                            )
                                            })
                                            .cloned();
                                    if let Some(op) = secondary {
                                        log::warn!(
                                            "primary opener failed socket connection, retrying with fallback opener {op:?}"
                                        );
                                        let mut fallback_cmd =
                                            crate::player::android_intent_command_for_opener(
                                                &op,
                                                &fallback_link,
                                                fallback_sub.as_deref(),
                                                &fallback_headers,
                                            );
                                        fallback_cmd.stdin(std::process::Stdio::null());
                                        fallback_cmd.stdout(std::process::Stdio::null());
                                        fallback_cmd.stderr(std::process::Stdio::null());
                                        crate::player::configure_detached_process(
                                            &mut fallback_cmd,
                                        );
                                        if let Ok(mut retry_child) = fallback_cmd.spawn() {
                                            if let Ok(retry_status) = retry_child.wait() {
                                                if retry_status.success() {
                                                    log::info!(
                                                        "fallback android opener {op:?} succeeded"
                                                    );
                                                    if let Some(path) = temporary_subtitle {
                                                        let _ = std::fs::remove_file(path);
                                                    }
                                                    sender.send(Action::PlayerExited).ok();
                                                    return;
                                                }
                                            }
                                        }
                                    }
                                }

                                #[cfg(unix)]
                                let signal = {
                                    use std::os::unix::process::ExitStatusExt;
                                    status.signal()
                                };
                                #[cfg(not(unix))]
                                let signal = None;
                                let clean_error =
                                    clean_player_error(status.code(), signal, error_output.trim());
                                sender
                                    .send(Action::PlayerCrashed(status.code(), clean_error))
                                    .ok();
                            }
                            Err(error) => {
                                sender
                                    .send(Action::PlayerCrashed(
                                        None,
                                        format!("Failed waiting for player process: {error}"),
                                    ))
                                    .ok();
                            }
                        }
                        if !is_android
                            && (matches!(kind, crate::tui::state::PlayerKind::Mpv)
                                || start_time.elapsed() >= std::time::Duration::from_secs(3)
                                || result.as_ref().is_ok_and(|s| !s.success()))
                            && let Some(mut sc) = sidecar_child
                        {
                            let _ = sc.kill();
                            let _ = sc.wait();
                        }
                        if start_time.elapsed() >= std::time::Duration::from_secs(3)
                            && let Some(path) = temporary_subtitle
                        {
                            let _ = std::fs::remove_file(path);
                        }
                        sender.send(Action::PlayerExited).ok();
                    });
                }
                Err(error) => {
                    log::error!(
                        "failed to spawn player {:?} for {}: {error}",
                        kind,
                        crate::logging::sanitize_url(&link)
                    );
                    let _ = tokio::fs::remove_file(&log_path).await;
                    if let Some(mut sc) = sidecar_child {
                        let _ = sc.kill();
                        let _ = sc.wait();
                    }
                    if let Some(path) = temporary_subtitle {
                        let _ = tokio::fs::remove_file(path).await;
                    }
                    sender
                        .send(Action::PlayerCrashed(
                            None,
                            format!("Failed to spawn player executable: {error}"),
                        ))
                        .ok();
                    sender.send(Action::PlayerExited).ok();
                }
            }
        });
    }
}
fn is_vlc_normal_exit(
    kind: crate::tui::state::PlayerKind,
    code: Option<i32>,
    stderr: &str,
) -> bool {
    matches!(kind, crate::tui::state::PlayerKind::Vlc)
        && (code == Some(1) || code == Some(0))
        && stderr.is_empty()
}

fn is_user_quit(status: &std::process::ExitStatus) -> bool {
    #[cfg(unix)]
    {
        use std::os::unix::process::ExitStatusExt;
        status.signal() == Some(15)
    }
    #[cfg(not(unix))]
    {
        let _ = status;
        false
    }
}

fn clean_player_error(code: Option<i32>, signal: Option<i32>, stderr: &str) -> String {
    let trimmed = stderr.trim();
    if !trimmed.is_empty() {
        let lower = trimmed.to_ascii_lowercase();
        if lower.contains("403 forbidden") || lower.contains("http error 403") {
            return "Stream forbidden by server (HTTP 403).".to_string();
        }
        if lower.contains("404 not found") || lower.contains("http error 404") {
            return "Stream link not found (HTTP 404).".to_string();
        }
        if lower.contains("410 gone") || lower.contains("http error 410") {
            return "Stream link expired (HTTP 410).".to_string();
        }
        if lower.contains("connection refused") {
            return "Stream connection refused.".to_string();
        }
        if lower.contains("timed out") || lower.contains("timeout") {
            return "Stream connection timed out.".to_string();
        }
        if lower.contains("unrecognized option") || lower.contains("unknown option") {
            return "Unsupported player CLI option.".to_string();
        }
        let best_line = trimmed
            .lines()
            .rev()
            .map(str::trim)
            .find(|l| {
                !l.is_empty()
                    && (l.contains("error")
                        || l.contains("Error")
                        || l.contains("ERROR")
                        || l.contains("failed")
                        || l.contains("Failed"))
            })
            .or_else(|| trimmed.lines().rev().map(str::trim).find(|l| !l.is_empty()))
            .unwrap_or(trimmed);
        let bounded = if best_line.len() > 120 {
            let mut end = 120;
            while end > 0 && !best_line.is_char_boundary(end) {
                end -= 1;
            }
            &best_line[..end]
        } else {
            best_line
        };
        return bounded.to_string();
    }

    if let Some(value) = code {
        format!("Player exited with status code {value}.")
    } else if let Some(sig) = signal {
        format!("Player terminated by signal {sig}.")
    } else {
        "Player exited unsuccessfully without error output.".to_string()
    }
}

impl App {
    pub(super) async fn handle_playback(&mut self, action: Action) -> Option<()> {
        match action {
            Action::PlayStream => {
                if self.state.is_playing {
                    self.state.notify(
                        NotificationKind::Warning,
                        "Playback active",
                        "Player is already running.",
                    );
                    return None;
                }
                if self.state.is_resolving_playback
                    || self.state.last_playback_launch.elapsed().as_millis() < 500
                {
                    return None;
                }
                self.state.last_playback_launch = std::time::Instant::now();
                self.state.is_resolving_playback = true;
                if self.current_subject_provider() == ProviderKind::FourKHdHub
                    || self.current_subject_provider() == ProviderKind::Addons
                    || self.current_subject_provider() == ProviderKind::Dramachi
                    || self.current_subject_provider().is_bdix()
                {
                    if let Some(release) = self.get_selected_release() {
                        let Some(first_mirror) = release.mirrors.first().cloned() else {
                            self.state.is_resolving_playback = false;
                            self.state.notify(
                                NotificationKind::Error,
                                "Playback unavailable",
                                "No playable mirrors were found for this release.",
                            );
                            return None;
                        };
                        self.state.notify(
                            NotificationKind::Info,
                            "Preparing playback",
                            format!("Resolving {}...", first_mirror.label),
                        );
                        let max_height = Some(release.resolution_u64()).filter(|&h| h > 0);
                        let direct_source = crate::providers::models::PlaybackSource {
                            provider: release.provider,
                            url: first_mirror.resolver_url.clone(),
                            headers: first_mirror.headers.clone(),
                            subtitle: None,
                            source_label: first_mirror.label.clone(),
                            max_height,
                        };
                        let client = if release.provider == ProviderKind::Addons
                            || release.provider == ProviderKind::Dramachi
                            || release.provider == ProviderKind::BdixCircleFtp
                            || release.provider == ProviderKind::BdixDhakaFlix
                        {
                            self.dispatch_playback_or_notify(direct_source);
                            return None;
                        } else {
                            match self.service.fourk_client.clone() {
                                Some(client) => client,
                                None => {
                                    self.state.is_resolving_playback = false;
                                    self.action_sender
                                        .send(Action::SetStatus(
                                            "Error: 4KHDHub provider is unavailable".to_string(),
                                        ))
                                        .ok();
                                    return None;
                                }
                            }
                        };
                        let sender = self.action_sender.clone();
                        self.request_tasks.spawn_playback_resolve(async move {
                            let result = tokio::time::timeout(
                                std::time::Duration::from_secs(18),
                                client.resolve_release(
                                    &release,
                                    crate::providers::ResolutionIntent::Playback,
                                ),
                            )
                            .await;
                            match result {
                                Ok(Ok(source)) => {
                                    sender.send(Action::DispatchPlayback(source)).ok();
                                }
                                Ok(Err(error)) => {
                                    log::error!("4KHDHub resolve failed: {error}");
                                    sender.send(Action::PlayerExited).ok();
                                    sender
                                        .send(Action::SetStatus(format!(
                                            "Error: 4KHDHub: {}",
                                            error.user_message()
                                        )))
                                        .ok();
                                }
                                Err(_) => {
                                    log::error!("4KHDHub resolve timed out");
                                    sender.send(Action::PlayerExited).ok();
                                    sender
                                        .send(Action::SetStatus(
                                            "Error: 4KHDHub: Timed out.".to_string(),
                                        ))
                                        .ok();
                                }
                            }
                        });
                    } else {
                        self.state.is_resolving_playback = false;
                    }
                    return None;
                }
                if self.state.active_screen == Screen::Details
                    && let Some(release) = self.get_selected_release()
                {
                    let Some(first_mirror) = release.mirrors.first().cloned() else {
                        self.state.is_resolving_playback = false;
                        self.state.notify(
                            NotificationKind::Error,
                            "Playback unavailable",
                            "No playable mirrors were found for this release.",
                        );
                        return None;
                    };
                    let max_height = Some(release.resolution_u64()).filter(|&h| h > 0);
                    let direct_source = crate::providers::models::PlaybackSource {
                        provider: release.provider,
                        url: first_mirror.resolver_url.clone(),
                        headers: first_mirror.headers.clone(),
                        subtitle: None,
                        source_label: first_mirror.label.clone(),
                        max_height,
                    };
                    let subject_id = self.state.active_subject_id.clone().unwrap_or_default();
                    let resource_id = self.get_selected_resource_id();

                    if let Some(rid) = resource_id {
                        self.state.notify(
                            NotificationKind::Info,
                            "Preparing playback",
                            format!("Preparing {}...", release.filename),
                        );
                        self.state.pending_playback_source = Some(direct_source.clone());
                        let service = self.service.clone();
                        let sender = self.action_sender.clone();
                        let source_clone = direct_source.clone();
                        let sibling_ids: Vec<String> = self
                            .state
                            .selected_details
                            .as_ref()
                            .map(|d| d.sibling_ids())
                            .unwrap_or_default();
                        let season = self.state.selected_season;
                        let episode = self.state.selected_episode;
                        self.request_tasks.spawn_playback_resolve(async move {
                            let result = tokio::time::timeout(
                                std::time::Duration::from_secs(15),
                                service.get_ext_captions(
                                    &subject_id,
                                    &rid,
                                    &sibling_ids,
                                    season,
                                    episode,
                                ),
                            )
                            .await;
                            match result {
                                Ok(Ok(res)) => {
                                    sender
                                        .send(Action::ShowSubtitlePopup(source_clone.url, res))
                                        .ok();
                                }
                                Err(_) => {
                                    log::warn!(
                                        "[playback] Subtitle resolution timed out after 15s for rid={rid}"
                                    );
                                    sender.send(Action::DispatchPlayback(source_clone)).ok();
                                }
                                Ok(Err(err)) => {
                                    log::warn!(
                                        "[playback] Subtitle resolution failed for rid={rid}: {err}"
                                    );
                                    sender.send(Action::DispatchPlayback(source_clone)).ok();
                                }
                            }
                        });
                    } else {
                        self.dispatch_playback_or_notify(direct_source);
                    }
                } else {
                    self.state.is_resolving_playback = false;
                }
            }
            Action::ShowSubtitlePopup(link, subtitles) => {
                self.state.is_resolving_playback = false;
                let mut options = vec![("None".to_string(), "".to_string())];
                options.extend(subtitles.into_iter().map(|s| (s.name, s.url)));
                if options.len() > 1 {
                    self.state.show_help = false;
                    self.state.show_overview_modal = false;
                    self.state.player_picker_popup = false;
                    self.state.is_download_subtitle_popup = false;
                    self.state.subtitle_popup = true;
                    self.state.subtitle_list = options;
                    self.state.subtitle_list_state.select(Some(0));
                    self.state.pending_play_link = Some(link);
                } else {
                    if let Some(source) = self.state.pending_playback_source.take() {
                        self.dispatch_playback_or_notify(source);
                    } else {
                        let source = crate::providers::models::PlaybackSource {
                            provider: self.state.active_provider,
                            url: link,
                            headers: vec![(
                                "User-Agent".to_string(),
                                self.service.client.user_agent().to_string(),
                            )],
                            subtitle: None,
                            source_label: "Direct".to_string(),
                            max_height: None,
                        };
                        self.dispatch_playback_or_notify(source);
                    }
                }
            }
            Action::ShowDownloadSubtitlePopup(subtitles) => {
                self.state.is_resolving_playback = false;
                let mut options = vec![("None".to_string(), "".to_string())];
                options.extend(subtitles.into_iter().map(|s| (s.name, s.url)));
                if options.len() > 1 {
                    self.state.show_help = false;
                    self.state.show_overview_modal = false;
                    self.state.player_picker_popup = false;
                    self.state.subtitle_popup = false;
                    self.state.is_download_subtitle_popup = true;
                    self.state.subtitle_list = options;
                    self.state.subtitle_list_state.select(Some(0));
                } else {
                    self.action_sender.send(Action::DownloadStream(None)).ok();
                }
            }

            Action::LaunchPlayback(kind, source) => {
                self.state.is_resolving_playback = false;
                self.state.player_picker_popup = false;
                self.state.last_playback_launch = std::time::Instant::now();
                if !crate::tui::player::supports_headers(kind, &source.headers) {
                    self.state.notify(
                        NotificationKind::Error,
                        format!("{} Incompatible", kind.label()),
                        format!("{} lacks stream header support.", kind.label()),
                    );
                    return None;
                }
                self.launch_player(
                    kind,
                    source.url,
                    source.subtitle,
                    source.headers,
                    source.max_height,
                );
            }
            Action::DispatchPlayback(source) => {
                self.dispatch_playback_or_notify(source);
            }
            Action::MarkWatched(item) => {
                self.state.history.mark_watched(*item);
            }
            Action::UpdateProgress {
                item,
                progress,
                duration,
                completed,
            } => {
                self.state
                    .history
                    .update_progress(*item, progress, duration, completed);
            }
            Action::ReconcileHistory => {
                self.state.history.reconcile_pending_playback_states();
            }
            Action::PlayerExited => {
                self.state.history.reconcile_pending_playback_states();
                self.state.is_playing = false;
                self.state.is_resolving_playback = false;
            }
            Action::PlayerCrashed(code, error_msg) => {
                self.state.history.reconcile_pending_playback_states();
                self.state.is_playing = false;
                self.state.is_resolving_playback = false;
                let code_str = code
                    .map(|c| c.to_string())
                    .unwrap_or_else(|| "unknown".into());
                log::error!("player crashed (code {code_str}): {error_msg}");

                let is_termux = crate::config::is_termux_environment();
                let error_lower = error_msg.to_ascii_lowercase();
                let is_missing_activity = is_termux
                    && (error_lower.contains("no activity found")
                        || error_lower.contains("activitynotfoundexception"));
                let is_termux_tool_crash = is_termux
                    && (code == Some(126)
                        || error_msg.contains("Permission denied")
                        || error_msg.contains("/system/bin/am")
                        || error_msg.contains("termux-open")
                        || error_msg.contains("termux-am")
                        || error_msg.contains("am.sock")
                        || error_msg.contains("Could not connect to socket")
                        || (code == Some(1)
                            && (error_msg.is_empty()
                                || error_msg.contains("status code 1")
                                || error_msg.contains("broadcast"))));

                let is_headless_mpv = is_termux
                    && (error_lower.contains("failed to open display")
                        || error_lower.contains("video_out")
                        || error_lower.contains("vo/gpu")
                        || error_lower.contains("vo=gpu"));
                let (title, message) = if is_missing_activity {
                    ("No Player", "Install a video player.".to_string())
                } else if is_headless_mpv {
                    (
                        "CLI mpv",
                        "Switch to Android Player in /settings.".to_string(),
                    )
                } else if is_termux_tool_crash {
                    (
                        "Termux Setup",
                        "Missing termux-tools package in Termux.".to_string(),
                    )
                } else {
                    let has_specific =
                        !error_msg.is_empty() && !error_msg.starts_with("Player exited");
                    match code {
                        Some(2) => (
                            "Stream Error",
                            if has_specific {
                                error_msg
                            } else {
                                "Player failed to open stream (exit code 2).".to_string()
                            },
                        ),
                        Some(1) => (
                            "Player Error",
                            if has_specific {
                                error_msg
                            } else {
                                "Player exited with error code 1.".to_string()
                            },
                        ),
                        Some(c) => (
                            "Playback Failed",
                            if has_specific {
                                error_msg
                            } else {
                                format!("Player exited ({c}).")
                            },
                        ),
                        None => (
                            "Playback Failed",
                            if has_specific {
                                error_msg
                            } else {
                                "Player terminated.".to_string()
                            },
                        ),
                    }
                };

                self.state.notify(NotificationKind::Error, title, message);
            }
            _ => return None,
        }
        None
    }
}

#[cfg(test)]
mod tests {
    use super::clean_player_error;

    #[test]
    fn failed_player_with_stderr_keeps_diagnostic() {
        assert_eq!(
            clean_player_error(Some(1), None, "VLC failed to open the stream"),
            "VLC failed to open the stream"
        );
    }

    #[test]
    fn failed_player_without_stderr_still_reports_failure() {
        assert_eq!(
            clean_player_error(Some(1), None, ""),
            "Player exited with status code 1."
        );
        assert_eq!(
            clean_player_error(None, Some(9), ""),
            "Player terminated by signal 9."
        );
        assert_eq!(
            clean_player_error(None, None, ""),
            "Player exited unsuccessfully without error output."
        );
    }
    #[test]
    fn player_exit_code_interpretation() {
        assert_eq!(
            clean_player_error(Some(2), None, "ffmpeg/http: HTTP error 403 Forbidden"),
            "Stream forbidden by server (HTTP 403)."
        );
        assert_eq!(
            clean_player_error(Some(2), None, "Connection timed out"),
            "Stream connection timed out."
        );
    }

    #[test]
    fn vlc_exit_code_1_empty_stderr_is_normal_exit() {
        use crate::tui::state::PlayerKind;
        assert!(super::is_vlc_normal_exit(PlayerKind::Vlc, Some(1), ""));
        assert!(super::is_vlc_normal_exit(PlayerKind::Vlc, Some(0), ""));
        assert!(!super::is_vlc_normal_exit(
            PlayerKind::Vlc,
            Some(1),
            "Error opening stream"
        ));
        assert!(!super::is_vlc_normal_exit(PlayerKind::Mpv, Some(1), ""));
        assert!(!super::is_vlc_normal_exit(PlayerKind::Vlc, Some(2), ""));
    }

    #[tokio::test]
    async fn show_popup_when_subtitles_available() {
        let mut app = crate::tui::app::App::new();

        let ext_captions = vec![
            crate::providers::models::SubtitleOption {
                name: "Spanish".to_string(),
                url: "https://example.com/es.srt".to_string(),
            },
            crate::providers::models::SubtitleOption {
                name: "French".to_string(),
                url: "https://example.com/fr.srt".to_string(),
            },
        ];

        app.handle_playback(crate::tui::action::Action::ShowSubtitlePopup(
            "https://example.com/video.mp4".to_string(),
            ext_captions,
        ))
        .await;

        assert!(app.state.subtitle_popup);
        assert_eq!(app.state.subtitle_list.len(), 3);
    }

    #[tokio::test]
    async fn test_get_selected_resource_id_resolution() {
        let mut app = crate::tui::app::App::new();
        assert_eq!(app.get_selected_resource_id(), None);

        app.state.selected_resources = vec![
            crate::providers::models::Release {
                provider: crate::providers::models::ProviderKind::MovieBox,
                filename: "Movie.1080p.mkv".to_string(),
                quality: Some("1080p".to_string()),
                codec: Some("hevc".to_string()),
                language: None,
                size_bytes: Some(1024),
                season: None,
                episode: None,
                mirrors: vec![],
                resource_id: Some("167282974499786072".to_string()),
            },
            crate::providers::models::Release {
                provider: crate::providers::models::ProviderKind::MovieBox,
                filename: "Movie.720p.mkv".to_string(),
                quality: Some("720p".to_string()),
                codec: Some("h264".to_string()),
                language: None,
                size_bytes: Some(512),
                season: None,
                episode: None,
                mirrors: vec![],
                resource_id: None,
            },
        ];

        app.state.resource_list_state.select(Some(0));
        assert_eq!(
            app.get_selected_resource_id().as_deref(),
            Some("167282974499786072")
        );

        app.state.resource_list_state.select(Some(1));
        assert_eq!(app.get_selected_resource_id(), None);
    }

    #[tokio::test]
    async fn test_play_stream_notifies_preparing_playback_accurately() {
        let mut app = crate::tui::app::App::new();
        app.state.active_provider = crate::providers::models::ProviderKind::MovieBox;
        app.state.active_screen = crate::tui::state::Screen::Details;
        app.state.selected_resources = vec![crate::providers::models::Release {
            provider: crate::providers::models::ProviderKind::MovieBox,
            filename: "Movie.1080p.mkv".to_string(),
            quality: Some("1080p".to_string()),
            codec: Some("hevc".to_string()),
            language: None,
            size_bytes: Some(1024),
            season: None,
            episode: None,
            mirrors: vec![crate::providers::models::SourceMirror {
                label: "Direct".to_string(),
                resolver_url: "https://example.com/video.mp4".to_string(),
                headers: vec![],
                direct_file: true,
            }],
            resource_id: Some("12345".to_string()),
        }];
        app.state.resource_list_state.select(Some(0));

        app.handle_playback(crate::tui::action::Action::PlayStream)
            .await;

        let notif = app.state.notifications.back().expect("notification posted");
        assert_eq!(notif.title, "Preparing playback");
        assert_eq!(notif.message, "Preparing Movie.1080p.mkv...");
    }

    #[test]
    fn test_subtitle_popup_renders_in_app_draw() {
        let backend = ratatui::backend::TestBackend::new(80, 24);
        let mut terminal = ratatui::Terminal::new(backend).unwrap();
        let mut app = crate::tui::app::App::new();

        app.state.subtitle_popup = true;
        app.state.subtitle_list = vec![
            ("None".to_string(), String::new()),
            (
                "English".to_string(),
                "https://example.com/en.srt".to_string(),
            ),
        ];
        app.state.subtitle_list_state.select(Some(0));

        terminal.draw(|frame| app.draw(frame)).unwrap();

        let buffer = terminal.backend().buffer();
        let content = buffer
            .content()
            .iter()
            .map(|c| c.symbol())
            .collect::<String>();

        assert!(content.contains("Subtitles"));
        assert!(content.contains("No subtitles"));
        assert!(content.contains("English"));
        let items = vec!["No subtitles".to_string(), "English".to_string()];
        let popup_layout = crate::tui::overlay::picker_layout(
            ratatui::layout::Rect::new(0, 0, 80, 24),
            &items,
            "Use",
            20,
        );
        assert_eq!(popup_layout.height, 4);
        assert_eq!(popup_layout.width, 20);
    }

    #[tokio::test]
    async fn test_playback_resolving_lock_resets_on_incompatible_player() {
        let mut app = crate::tui::app::App::new();
        app.state.is_resolving_playback = true;
        app.state.available_players = vec![crate::tui::state::PlayerKind::AndroidIntent];

        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![("Cookie".to_string(), "CloudFront-Policy=test".to_string())],
            subtitle: None,
            source_label: "Multi-Res".to_string(),
            max_height: None,
        };

        assert_eq!(
            app.resolve_playback_player(&source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );
    }
    #[tokio::test]
    async fn test_dispatch_playback_notifies_bad_player_path() {
        let mut app = crate::tui::app::App::new();
        app.state.available_players.clear();
        app.state.default_player = Some("vlc".to_string());
        app.state.vlc_path = Some("D:\\PortableApps\\VLC\\vlc.exe".to_string());
        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/video.mp4".to_string(),
            headers: vec![],
            subtitle: None,
            source_label: "Direct".to_string(),
            max_height: None,
        };

        app.dispatch_playback_or_notify(source);

        let notif = app.state.notifications.back().expect("notification pushed");
        assert_eq!(notif.title, "Invalid Player Path");
        assert_eq!(
            notif.message,
            "Player path not found: D:\\PortableApps\\VLC\\vlc.exe"
        );
    }
    #[tokio::test]
    async fn test_explicit_player_incompatible_does_not_launch_alternative() {
        let mut app = crate::tui::app::App::new();
        app.state.available_players = vec![
            crate::tui::state::PlayerKind::Mpv,
            crate::tui::state::PlayerKind::AndroidIntent,
        ];
        app.state.default_player = Some("android".to_string());

        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![("Cookie".to_string(), "CloudFront-Policy=test".to_string())],
            subtitle: None,
            source_label: "Multi-Res".to_string(),
            max_height: None,
        };

        let resolution = app.resolve_playback_player(&source);
        assert_eq!(
            resolution,
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );

        app.state.is_resolving_playback = true;
        app.dispatch_playback_or_notify(source);
        assert!(app.state.pending_playback_source.is_none());
    }

    #[tokio::test]
    async fn test_vlc_resolves_as_available_for_cookie_source() {
        let mut app = crate::tui::app::App::new();
        app.state.available_players = vec![
            crate::tui::state::PlayerKind::Mpv,
            crate::tui::state::PlayerKind::Vlc,
        ];
        app.state.default_player = Some("vlc".to_string());

        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![("Cookie".to_string(), "CloudFront-Policy=test".to_string())],
            subtitle: None,
            source_label: "Multi-Res".to_string(),
            max_height: None,
        };

        let resolution = app.resolve_playback_player(&source);
        assert_eq!(
            resolution,
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::Vlc)
        );
    }
    #[tokio::test]
    async fn test_playback_resolving_lock_resets_on_player_crash() {
        let mut app = crate::tui::app::App::new();
        app.state.is_resolving_playback = true;
        app.state.is_playing = true;

        app.handle_playback(crate::tui::action::Action::PlayerCrashed(
            Some(1),
            "failed".to_string(),
        ))
        .await;

        assert!(!app.state.is_resolving_playback);
        assert!(!app.state.is_playing);
    }
    #[tokio::test]
    async fn test_android_player_allows_unauthenticated_and_referer_streams() {
        let mut app = crate::tui::app::App::new();
        app.state.available_players = vec![crate::tui::state::PlayerKind::AndroidIntent];
        app.state.default_player = Some("android".to_string());

        let bdix_source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::BdixCircleFtp,
            url: "http://10.16.100.244/movies/film.mkv".to_string(),
            headers: vec![],
            subtitle: None,
            source_label: "CircleFTP".to_string(),
            max_height: None,
        };
        assert_eq!(
            app.resolve_playback_player(&bdix_source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );

        let fourk_source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::FourKHdHub,
            url: "https://r2.example.com/stream.mkv".to_string(),
            headers: vec![
                ("Referer".to_string(), "https://hubcloud.one/".to_string()),
                ("User-Agent".to_string(), "Mozilla/5.0".to_string()),
            ],
            subtitle: None,
            source_label: "1080p".to_string(),
            max_height: None,
        };
        assert_eq!(
            app.resolve_playback_player(&fourk_source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );

        let auth_source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![("Cookie".to_string(), "CloudFront-Policy=test".to_string())],
            subtitle: None,
            source_label: "Multi-Res".to_string(),
            max_height: None,
        };
        assert_eq!(
            app.resolve_playback_player(&auth_source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );
    }

    static ENV_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
    #[tokio::test]
    async fn test_graphical_session_overrides_stale_android_default_player() {
        let _guard = ENV_LOCK.lock().await;
        let orig_display = std::env::var("DISPLAY").ok();
        let orig_player = std::env::var(crate::player::ENV_MOVIEBOX_PLAYER).ok();
        unsafe {
            std::env::set_var("DISPLAY", ":0.0");
            std::env::remove_var(crate::player::ENV_MOVIEBOX_PLAYER);
        }
        let mut app = crate::tui::app::App::new();
        app.state.available_players = vec![
            crate::tui::state::PlayerKind::Mpv,
            crate::tui::state::PlayerKind::Vlc,
            crate::tui::state::PlayerKind::AndroidIntent,
        ];
        app.state.default_player = Some("android".to_string());
        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![],
            subtitle: None,
            source_label: "1080p".to_string(),
            max_height: None,
        };
        assert_eq!(
            app.resolve_playback_player(&source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::Mpv)
        );
        unsafe {
            if let Some(val) = orig_display {
                std::env::set_var("DISPLAY", val);
            } else {
                std::env::remove_var("DISPLAY");
            }
            if let Some(val) = orig_player {
                std::env::set_var(crate::player::ENV_MOVIEBOX_PLAYER, val);
            } else {
                std::env::remove_var(crate::player::ENV_MOVIEBOX_PLAYER);
            }
        }
    }

    #[tokio::test]
    async fn test_graphical_session_respects_explicit_moviebox_player_env() {
        let _guard = ENV_LOCK.lock().await;
        let orig_display = std::env::var("DISPLAY").ok();
        let orig_player = std::env::var(crate::player::ENV_MOVIEBOX_PLAYER).ok();
        unsafe {
            std::env::set_var("DISPLAY", ":0.0");
            std::env::set_var(crate::player::ENV_MOVIEBOX_PLAYER, "android");
        }
        let mut app = crate::tui::app::App::new();
        app.state.available_players = vec![
            crate::tui::state::PlayerKind::Mpv,
            crate::tui::state::PlayerKind::Vlc,
            crate::tui::state::PlayerKind::AndroidIntent,
        ];
        app.state.default_player = Some("mpv".to_string());
        let source = crate::providers::models::PlaybackSource {
            provider: crate::providers::models::ProviderKind::MovieBox,
            url: "https://example.com/index.mpd".to_string(),
            headers: vec![],
            subtitle: None,
            source_label: "1080p".to_string(),
            max_height: None,
        };
        assert_eq!(
            app.resolve_playback_player(&source),
            super::PlaybackResolution::Available(crate::tui::state::PlayerKind::AndroidIntent)
        );
        unsafe {
            if let Some(val) = orig_display {
                std::env::set_var("DISPLAY", val);
            } else {
                std::env::remove_var("DISPLAY");
            }
            if let Some(val) = orig_player {
                std::env::set_var(crate::player::ENV_MOVIEBOX_PLAYER, val);
            } else {
                std::env::remove_var(crate::player::ENV_MOVIEBOX_PLAYER);
            }
        }
    }

    #[tokio::test]
    async fn test_player_crashed_termux_actionable_notification() {
        let mut app = crate::tui::app::App::new();
        let _guard = ENV_LOCK.lock().await;
        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
        }
        app.handle_playback(super::Action::PlayerCrashed(
            Some(126),
            "/system/bin/am[11]: /data/data/com.termux/files/usr/bin/cmd: Permission denied"
                .to_string(),
        ))
        .await;
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
        }
        let last_notification = app
            .state
            .notifications
            .back()
            .expect("expected notification");
        assert_eq!(last_notification.title, "Termux Setup");
        assert_eq!(
            last_notification.message,
            "Missing termux-tools package in Termux."
        );
    }

    #[tokio::test]
    async fn test_player_crashed_termux_missing_activity() {
        let mut app = crate::tui::app::App::new();
        let _guard = ENV_LOCK.lock().await;
        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
        }
        app.handle_playback(super::Action::PlayerCrashed(
            Some(1),
            "Error: Activity not started, no activity found to handle Intent".to_string(),
        ))
        .await;
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
        }
        let last_notification = app
            .state
            .notifications
            .back()
            .expect("expected notification");
        assert_eq!(last_notification.title, "No Player");
        assert_eq!(last_notification.message, "Install a video player.");
    }

    #[tokio::test]
    async fn test_player_crashed_termux_headless_mpv() {
        let mut app = crate::tui::app::App::new();
        let _guard = ENV_LOCK.lock().await;
        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
        }
        app.handle_playback(super::Action::PlayerCrashed(
            Some(1),
            "Error opening/initializing the selected video_out (--vo) device.".to_string(),
        ))
        .await;
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
        }
        let last_notification = app
            .state
            .notifications
            .back()
            .expect("expected notification");
        assert_eq!(last_notification.title, "CLI mpv");
        assert_eq!(
            last_notification.message,
            "Switch to Android Player in /settings."
        );
    }

    #[tokio::test]
    async fn test_player_crashed_termux_exit_code_1_generic() {
        let mut app = crate::tui::app::App::new();
        let _guard = ENV_LOCK.lock().await;
        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
        }
        app.handle_playback(super::Action::PlayerCrashed(
            Some(1),
            "Player exited with status code 1.".to_string(),
        ))
        .await;
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
        }
        let last_notification = app
            .state
            .notifications
            .back()
            .expect("expected notification");
        assert_eq!(last_notification.title, "Termux Setup");
        assert_eq!(
            last_notification.message,
            "Missing termux-tools package in Termux."
        );
    }

    #[tokio::test]
    async fn test_playback_captures_active_subject_and_episode() {
        let mut app = crate::tui::app::App::new();
        app.state.active_screen = crate::tui::state::Screen::Details;
        app.state.selected_season = 2;
        app.state.selected_episode = 5;
        app.state.active_subject_id = Some("dub_subject_42".to_string());
        app.state.selected_details = Some(crate::providers::models::MediaDetails {
            id: crate::providers::models::ProviderMediaId {
                provider: crate::providers::models::ProviderKind::MovieBox,
                value: "root_subject_100".to_string(),
            },
            title: "Test Series".to_string(),
            media_type: crate::models::MediaType::Series,
            year: None,
            description: None,
            tagline: None,
            imdb_rating: None,
            director: None,
            stars: None,
            prints: None,
            audios: None,
            poster_url: None,
            duration: None,
            genres: Vec::new(),
            seasons: Vec::new(),
            dubs: Vec::new(),
        });
        let mirror = crate::providers::models::SourceMirror {
            label: "1080p".to_string(),
            resolver_url: "https://example.com/video.mp4".to_string(),
            headers: Vec::new(),
            direct_file: true,
        };
        app.state.selected_resources = vec![crate::providers::models::Release {
            provider: crate::providers::models::ProviderKind::MovieBox,
            filename: "Test S02E05 1080p".to_string(),
            quality: Some("1080p".to_string()),
            codec: None,
            language: None,
            size_bytes: None,
            season: Some(2),
            episode: Some(5),
            mirrors: vec![mirror],
            resource_id: Some("res_s2e5".to_string()),
        }];
        app.state.resource_list_state.select(Some(0));
        assert_eq!(
            app.state.active_subject_id.as_deref(),
            Some("dub_subject_42")
        );
        assert_eq!(app.get_selected_resource_id().as_deref(), Some("res_s2e5"));
        assert_eq!(app.state.selected_season, 2);
        assert_eq!(app.state.selected_episode, 5);
    }

    #[tokio::test]
    async fn test_non_mpv_update_progress_is_retained_across_player_exited() {
        let mut app = crate::tui::app::App::new();
        let item = crate::history::WatchHistoryItem {
            provider: "moviebox".to_string(),
            subject_id: "vlc_retain_test".to_string(),
            title: "VLC Retention Movie".to_string(),
            cover_url: None,
            stype: 1,
            release_year: "2026".to_string(),
            season: 0,
            episode: 0,
            progress_seconds: 0,
            duration_seconds: Some(3600),
            completed: false,
            timestamp: 1000,
            stream_filename: Some("Movie.1080p.mkv".to_string()),
        };
        app.state.history.record_start(&item, 0);
        app.handle_playback(crate::tui::action::Action::UpdateProgress {
            item: Box::new(item),
            progress: 420,
            duration: Some(3600),
            completed: false,
        })
        .await;
        app.handle_playback(crate::tui::action::Action::PlayerExited)
            .await;

        let saved = app
            .state
            .history
            .get_item("moviebox", "vlc_retain_test", 0, 0, None)
            .expect("history item exists");
        assert_eq!(saved.progress_seconds, 420);
    }
}