Skip to content

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

78.7 KB
Raw Blame
pub mod tracker;

use std::{path::Path, process::Command};

pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
pub const ENV_MOVIEBOX_PLAYER: &str = "MOVIEBOX_PLAYER";

#[cfg(not(target_os = "windows"))]
pub const STANDARD_UNIX_BIN_DIRS: &[&str] = &[
    "/opt/homebrew/bin",
    "/usr/local/bin",
    "/usr/bin",
    "/bin",
    "/run/current-system/sw/bin",
    "/data/data/com.termux/files/usr/bin",
];

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PlayerKind {
    Mpv,
    Iina,
    Vlc,
    AndroidIntent,
}

impl PlayerKind {
    pub fn label(&self) -> &'static str {
        match self {
            PlayerKind::Mpv => "MPV",
            PlayerKind::Iina => "IINA",
            PlayerKind::Vlc => "VLC",
            PlayerKind::AndroidIntent => "Android Player",
        }
    }

    pub fn config_key(&self) -> &'static str {
        match self {
            PlayerKind::Mpv => "mpv",
            PlayerKind::Iina => "iina",
            PlayerKind::Vlc => "vlc",
            PlayerKind::AndroidIntent => "android",
        }
    }

    pub fn parse(value: &str) -> Option<PlayerKind> {
        match value.to_ascii_lowercase().as_str() {
            "mpv" => Some(PlayerKind::Mpv),
            "iina" => Some(PlayerKind::Iina),
            "vlc" => Some(PlayerKind::Vlc),
            "android" | "androidintent" | "android-intent" => Some(PlayerKind::AndroidIntent),
            _ => None,
        }
    }
}

pub fn has_graphical_display() -> bool {
    std::env::var("DISPLAY").is_ok_and(|v| !v.trim().is_empty())
        || std::env::var("WAYLAND_DISPLAY").is_ok_and(|v| !v.trim().is_empty())
}

pub fn detect() -> Vec<PlayerKind> {
    let mut players = Vec::new();

    let is_termux = crate::config::is_termux_environment();
    let has_gui = has_graphical_display();
    if is_termux && !has_gui && !android_openers().is_empty() {
        players.push(PlayerKind::AndroidIntent);
    }

    #[cfg(target_os = "macos")]
    if iina_resolution().is_some() {
        players.push(PlayerKind::Iina);
    }

    if mpv_executable().is_some() {
        players.push(PlayerKind::Mpv);
    }

    if vlc_executable().is_some() {
        players.push(PlayerKind::Vlc);
    }

    if (!is_termux || has_gui) && !android_openers().is_empty() {
        players.push(PlayerKind::AndroidIntent);
    }

    players
}

pub fn supports_headers(kind: PlayerKind, headers: &[(String, String)]) -> bool {
    if headers.is_empty() {
        return true;
    }
    #[cfg(target_os = "macos")]
    if kind == PlayerKind::Iina && matches!(iina_resolution(), Some(IinaResolution::AppFallback)) {
        return false;
    }
    match kind {
        PlayerKind::Mpv => true,
        PlayerKind::Iina => true,
        PlayerKind::Vlc => true,
        PlayerKind::AndroidIntent => true,
    }
}

pub fn header_capable_players() -> &'static [PlayerKind] {
    #[cfg(target_os = "macos")]
    {
        &[
            PlayerKind::Mpv,
            PlayerKind::Iina,
            PlayerKind::Vlc,
            PlayerKind::AndroidIntent,
        ]
    }
    #[cfg(not(target_os = "macos"))]
    {
        &[PlayerKind::Mpv, PlayerKind::Vlc, PlayerKind::AndroidIntent]
    }
}

pub fn is_dash_url(url: &str) -> bool {
    let clean = url.split('?').next().unwrap_or(url);
    clean.ends_with(".mpd") || clean.contains("/dash/")
}

pub fn ytdlp_format_selector(max_height: Option<u64>) -> String {
    if let Some(height) = max_height.filter(|&h| h > 0) {
        format!(
            "bestvideo[height<={height}]+bestaudio/best[height<={height}]/bestvideo+bestaudio/best"
        )
    } else {
        "bestvideo+bestaudio/best".to_string()
    }
}

pub fn configure_detached_process(cmd: &mut Command) {
    #[cfg(unix)]
    {
        use std::os::unix::process::CommandExt;
        unsafe {
            cmd.pre_exec(|| {
                let _ = libc::setsid();
                libc::signal(libc::SIGHUP, libc::SIG_IGN);
                Ok(())
            });
        }
    }
    #[cfg(windows)]
    {
        use std::os::windows::process::CommandExt;
        const DETACHED_PROCESS: u32 = 0x0000_0008;
        const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
        cmd.creation_flags(DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP);
    }
}

#[allow(clippy::too_many_arguments)]
pub fn command(
    kind: PlayerKind,
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
    window: Option<(u32, u32)>,
    resume_seconds: Option<u64>,
    tracker: Option<(&str, &str, usize, usize)>,
    max_height: Option<u64>,
) -> Command {
    match kind {
        PlayerKind::Mpv => mpv_command(
            url,
            subtitle,
            headers,
            false,
            window,
            resume_seconds,
            tracker,
            max_height,
        ),
        PlayerKind::Iina => iina_command(
            url,
            subtitle,
            headers,
            window,
            resume_seconds,
            tracker,
            max_height,
        ),
        PlayerKind::Vlc => vlc_command(url, subtitle, headers, window, resume_seconds, max_height),
        PlayerKind::AndroidIntent => android_intent_command(url, subtitle, headers),
    }
}

fn is_flatpak_executable(executable: &str) -> bool {
    executable.starts_with("flatpak run ")
        || executable.contains("/flatpak/exports/bin/")
        || matches!(executable, "io.mpv.Mpv" | "org.videolan.VLC")
}

fn build_player_process_command(executable: &str) -> Command {
    if let Some(rest) = executable.strip_prefix("flatpak run ") {
        let mut cmd = Command::new("flatpak");
        cmd.arg("run")
            .arg("--file-forwarding")
            .arg("--filesystem=xdg-cache/moviebox-tui:ro")
            .arg("--filesystem=xdg-data/moviebox-tui")
            .arg("--filesystem=/tmp:ro")
            .args(rest.split_whitespace());
        cmd
    } else if executable.contains("/flatpak/exports/bin/") {
        let app_id = executable.rsplit('/').next().unwrap_or(executable);
        let mut cmd = Command::new("flatpak");
        cmd.arg("run")
            .arg("--file-forwarding")
            .arg("--filesystem=xdg-cache/moviebox-tui:ro")
            .arg("--filesystem=xdg-data/moviebox-tui")
            .arg("--filesystem=/tmp:ro")
            .arg(app_id);
        cmd
    } else if matches!(executable, "io.mpv.Mpv" | "org.videolan.VLC") {
        let mut cmd = Command::new("flatpak");
        cmd.arg("run")
            .arg("--file-forwarding")
            .arg("--filesystem=xdg-cache/moviebox-tui:ro")
            .arg("--filesystem=xdg-data/moviebox-tui")
            .arg("--filesystem=/tmp:ro")
            .arg(executable);
        cmd
    } else {
        Command::new(executable)
    }
}

#[allow(clippy::enum_variant_names)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AndroidOpener {
    TermuxAm(String),
    TermuxOpen(String),
    TermuxOpenUrl(String),
    #[cfg(target_os = "android")]
    SystemAm(String),
}

pub fn probe_android_openers() -> Vec<AndroidOpener> {
    let mut openers = Vec::new();

    if let Some(custom) = configured_executable("MOVIEBOX_ANDROID_PLAYER_PATH") {
        if custom.ends_with("termux-open-url") {
            openers.push(AndroidOpener::TermuxOpenUrl(custom));
        } else if custom.ends_with("termux-am") {
            openers.push(AndroidOpener::TermuxAm(custom));
        } else {
            openers.push(AndroidOpener::TermuxOpen(custom));
        }
        return openers;
    }

    let mut push_unique = |opener: AndroidOpener| {
        if !openers.iter().any(|existing| match (existing, &opener) {
            (AndroidOpener::TermuxAm(a), AndroidOpener::TermuxAm(b))
            | (AndroidOpener::TermuxOpen(a), AndroidOpener::TermuxOpen(b))
            | (AndroidOpener::TermuxOpenUrl(a), AndroidOpener::TermuxOpenUrl(b)) => a == b,
            #[cfg(target_os = "android")]
            (AndroidOpener::SystemAm(a), AndroidOpener::SystemAm(b)) => a == b,
            _ => false,
        }) {
            openers.push(opener);
        }
    };

    #[cfg(target_os = "android")]
    let is_termux = crate::config::is_termux_environment();

    if let Ok(prefix) = std::env::var("PREFIX") {
        let termux_am = format!("{prefix}/bin/termux-am");
        if Path::new(&termux_am).is_file() {
            push_unique(AndroidOpener::TermuxAm(termux_am));
        }
        let termux_open = format!("{prefix}/bin/termux-open");
        if Path::new(&termux_open).is_file() {
            push_unique(AndroidOpener::TermuxOpen(termux_open));
        }
        let termux_open_url = format!("{prefix}/bin/termux-open-url");
        if Path::new(&termux_open_url).is_file() {
            push_unique(AndroidOpener::TermuxOpenUrl(termux_open_url));
        }
    }

    let termux_am_static = format!("{}/bin/termux-am", crate::config::TERMUX_PREFIX_USR);
    if Path::new(&termux_am_static).is_file() {
        push_unique(AndroidOpener::TermuxAm(termux_am_static));
    }
    let termux_open_static = format!("{}/bin/termux-open", crate::config::TERMUX_PREFIX_USR);
    if Path::new(&termux_open_static).is_file() {
        push_unique(AndroidOpener::TermuxOpen(termux_open_static));
    }
    let termux_open_url_static =
        format!("{}/bin/termux-open-url", crate::config::TERMUX_PREFIX_USR);
    if Path::new(&termux_open_url_static).is_file() {
        push_unique(AndroidOpener::TermuxOpenUrl(termux_open_url_static));
    }

    if let Some(path) = find_in_path("termux-am") {
        push_unique(AndroidOpener::TermuxAm(path));
    }
    if let Some(path) = find_in_path("termux-open") {
        push_unique(AndroidOpener::TermuxOpen(path));
    }
    if let Some(path) = find_in_path("termux-open-url") {
        push_unique(AndroidOpener::TermuxOpenUrl(path));
    }

    #[cfg(target_os = "android")]
    if !is_termux {
        let is_root = unsafe { libc::getuid() == 0 };
        if is_root {
            if Path::new("/system/bin/am").is_file() {
                push_unique(AndroidOpener::SystemAm("/system/bin/am".to_string()));
            }
            if let Some(path) = find_in_path("am") {
                push_unique(AndroidOpener::SystemAm(path));
            }
        }
    }

    openers
}

pub fn android_openers() -> Vec<AndroidOpener> {
    probe_android_openers()
}

fn append_android_intent_extras(
    cmd: &mut Command,
    subtitle: Option<&str>,
    headers: &[(String, String)],
) {
    if let Some(sub) = subtitle {
        cmd.arg("-e").arg("subtitles_location").arg(sub);
        cmd.arg("--eu").arg("subtitles_location").arg(sub);
        cmd.arg("-e").arg("subs").arg(sub);
        cmd.arg("--esal").arg("subs").arg(sub);
        cmd.arg("-e").arg("subs.enable").arg(sub);
        cmd.arg("--esal").arg("subs.enable").arg(sub);
        cmd.arg("-e").arg("sub").arg(sub);
        cmd.arg("--eu").arg("sub").arg(sub);
        cmd.arg("-e").arg("title_subtitle").arg(sub);
    }
    for (name, value) in headers {
        if name.eq_ignore_ascii_case("user-agent") {
            cmd.arg("-e").arg("User-Agent").arg(value);
        } else if name.eq_ignore_ascii_case("referer") {
            cmd.arg("-e").arg("Referer").arg(value);
        }
    }
}

pub fn android_intent_command_for_opener(
    opener: &AndroidOpener,
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
) -> Command {
    match opener {
        AndroidOpener::TermuxOpen(path) => {
            let mut cmd = Command::new(path);
            cmd.arg("--chooser")
                .arg("--content-type")
                .arg("video/*")
                .arg(url);
            cmd
        }
        AndroidOpener::TermuxOpenUrl(path) => {
            let mut cmd = Command::new(path);
            cmd.arg(url);
            cmd
        }
        AndroidOpener::TermuxAm(path) => {
            let mut cmd = Command::new(path);
            cmd.arg("start")
                .arg("-a")
                .arg("android.intent.action.VIEW")
                .arg("-d")
                .arg(url)
                .arg("-t")
                .arg("video/*");
            append_android_intent_extras(&mut cmd, subtitle, headers);
            cmd
        }
        #[cfg(target_os = "android")]
        AndroidOpener::SystemAm(path) => {
            let mut cmd = Command::new(path);
            cmd.arg("start")
                .arg("--user")
                .arg("0")
                .arg("-a")
                .arg("android.intent.action.VIEW")
                .arg("-d")
                .arg(url)
                .arg("-t")
                .arg("video/*");
            append_android_intent_extras(&mut cmd, subtitle, headers);
            let current_path = std::env::var("PATH").unwrap_or_default();
            cmd.env("PATH", format!("/system/bin:/system/xbin:{current_path}"));
            cmd.env_remove("LD_LIBRARY_PATH");
            cmd.env_remove("LD_PRELOAD");
            cmd
        }
    }
}

pub fn android_intent_commands(
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
) -> Vec<(AndroidOpener, Command)> {
    let openers = android_openers();
    if openers.is_empty() {
        let mut cmd = Command::new("termux-open");
        cmd.arg("--chooser")
            .arg("--content-type")
            .arg("video/*")
            .arg(url);
        return vec![(AndroidOpener::TermuxOpen("termux-open".to_string()), cmd)];
    }
    openers
        .iter()
        .map(|opener| {
            let cmd = android_intent_command_for_opener(opener, url, subtitle, headers);
            (opener.clone(), cmd)
        })
        .collect()
}

fn android_intent_command(
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
) -> Command {
    let commands = android_intent_commands(url, subtitle, headers);
    commands
        .into_iter()
        .next()
        .map(|(_, cmd)| cmd)
        .unwrap_or_else(|| {
            let mut cmd = Command::new("termux-open");
            cmd.arg("--chooser")
                .arg("--content-type")
                .arg("video/*")
                .arg(url);
            cmd
        })
}

#[allow(clippy::too_many_arguments)]
fn mpv_command(
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
    iina: bool,
    window: Option<(u32, u32)>,
    resume_seconds: Option<u64>,
    tracker: Option<(&str, &str, usize, usize)>,
    max_height: Option<u64>,
) -> Command {
    let fallback = if cfg!(target_os = "windows") {
        "mpv.exe"
    } else {
        "mpv"
    };
    let executable = mpv_executable().unwrap_or_else(|| fallback.into());
    let mut command = build_player_process_command(&executable);
    let prefix = if iina { "--mpv-" } else { "--" };

    if let Some((width, height)) = window {
        command.arg(format!("{prefix}autofit={width}x{height}"));
    }
    command.arg(format!("{prefix}geometry=50%:50%"));
    let is_dash = is_dash_url(url);
    command.arg(format!("{prefix}hwdec=auto-safe"));
    command.arg(format!("{prefix}cache=yes"));
    command.arg(format!("{prefix}cache-secs=120"));
    command.arg(format!("{prefix}cache-pause=yes"));
    command.arg(format!("{prefix}cache-pause-wait=3"));
    command.arg(format!("{prefix}cache-pause-initial=no"));
    let (max_bytes, back_bytes) =
        if cfg!(target_os = "android") || crate::config::is_termux_environment() {
            ("128M", "50M")
        } else {
            ("256M", "100M")
        };
    command.arg(format!("{prefix}demuxer-max-bytes={max_bytes}"));
    command.arg(format!("{prefix}demuxer-max-back-bytes={back_bytes}"));
    command.arg(format!("{prefix}demuxer-readahead-secs=120"));
    command.arg(format!("{prefix}demuxer-lavf-buffersize=1048576"));
    command.arg(format!("{prefix}stream-buffer-size=4M"));
    if is_dash {
        command.arg(format!("{prefix}force-seekable=yes"));
    } else {
        command.arg(format!("{prefix}ytdl=no"));
    }
    command.arg(format!(
        "{prefix}stream-lavf-o=reconnect=1,reconnect_streamed=1,reconnect_delay_max=5"
    ));
    if !iina {
        command.arg("--idle=no").arg("--keep-open=no");
    }
    let format_selector = ytdlp_format_selector(max_height);
    command.arg(format!("{prefix}ytdl-format={format_selector}"));
    if max_height.filter(|&h| h > 0).is_none() {
        command.arg(format!("{prefix}hls-bitrate=max"));
    }
    if let Some(start) = resume_seconds {
        if start > 0 {
            command.arg(format!("{prefix}start={start}"));
        }
    }

    if let Some((provider, subject_id, season, episode)) = tracker {
        if let Some(script_path) = tracker::ensure_tracker_script() {
            let script_str = normalize_player_path(&script_path.to_string_lossy());
            command.arg(format!("{prefix}script={script_str}"));
            if let Some(state_file) =
                tracker::state_file_path(provider, subject_id, season, episode)
            {
                let opts =
                    format_mpv_script_opts(provider, subject_id, season, episode, &state_file);
                command.arg(format!("{prefix}script-opts={opts}"));
            }
        }
    }

    if !headers.is_empty() {
        for (name, value) in headers {
            if name.eq_ignore_ascii_case("user-agent") {
                command.arg(format!("{prefix}user-agent={value}"));
            } else if name.eq_ignore_ascii_case("referer") {
                command.arg(format!("{prefix}referrer={value}"));
            }
        }
        for (name, value) in headers {
            if !name.eq_ignore_ascii_case("user-agent") && !name.eq_ignore_ascii_case("referer") {
                command.arg(format!("{prefix}http-header-fields={name}: {value}"));
                command.arg(format!(
                    "{prefix}ytdl-raw-options-append=add-header={name}:{value}"
                ));
            }
        }
    }
    if let Some(subtitle) = subtitle {
        let opt = if iina {
            "--mpv-sub-files"
        } else {
            "--sub-file"
        };
        let sub_path = normalize_player_path(subtitle);
        command.arg(format!("{opt}={sub_path}"));
    }

    if is_flatpak_executable(&executable) && (url.starts_with('/') || url.starts_with("file://")) {
        command.arg("@@").arg(url).arg("@@");
    } else {
        command.arg(url);
    }
    command
}

#[cfg(target_os = "macos")]
#[derive(Debug, Clone)]
enum IinaResolution {
    Cli(String),
    AppFallback,
}

#[cfg(target_os = "macos")]
fn probe_iina_resolution() -> Option<IinaResolution> {
    if let Some(executable) = configured_executable("MOVIEBOX_IINA_PATH") {
        return Some(IinaResolution::Cli(executable));
    }

    let cli_global = "/Applications/IINA.app/Contents/MacOS/iina-cli";
    if Path::new(cli_global).exists() {
        return Some(IinaResolution::Cli(cli_global.to_string()));
    }
    if let Some(home) = dirs::home_dir() {
        let user_cli = home.join("Applications/IINA.app/Contents/MacOS/iina-cli");
        if user_cli.exists() {
            return Some(IinaResolution::Cli(user_cli.to_string_lossy().into_owned()));
        }
        let nix_iina = home.join(".nix-profile/bin/iina-cli");
        if nix_iina.exists() {
            return Some(IinaResolution::Cli(nix_iina.to_string_lossy().into_owned()));
        }
    }

    for candidate in &[
        "/opt/homebrew/bin/iina-cli",
        "/usr/local/bin/iina-cli",
        "/opt/local/bin/iina-cli",
        "/run/current-system/sw/bin/iina-cli",
    ] {
        if Path::new(candidate).exists() {
            return Some(IinaResolution::Cli(candidate.to_string()));
        }
    }

    if let Some(path) = find_in_path("iina").or_else(|| find_in_path("iina-cli")) {
        return Some(IinaResolution::Cli(path));
    }
    if Path::new("/Applications/IINA.app").exists()
        || dirs::home_dir().is_some_and(|home| home.join("Applications/IINA.app").exists())
    {
        return Some(IinaResolution::AppFallback);
    }

    None
}

#[cfg(target_os = "macos")]
static IINA_CACHED: std::sync::RwLock<Option<Option<IinaResolution>>> =
    std::sync::RwLock::new(None);

#[cfg(target_os = "macos")]
fn iina_resolution() -> Option<IinaResolution> {
    if let Ok(guard) = IINA_CACHED.read() {
        if let Some(cached) = &*guard {
            return cached.clone();
        }
    }

    let detected = probe_iina_resolution();
    if let Ok(mut guard) = IINA_CACHED.write() {
        *guard = Some(detected.clone());
    }
    detected
}

#[allow(clippy::too_many_arguments)]
fn iina_command(
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
    window: Option<(u32, u32)>,
    resume_seconds: Option<u64>,
    tracker: Option<(&str, &str, usize, usize)>,
    max_height: Option<u64>,
) -> Command {
    #[cfg(target_os = "macos")]
    let mut command = match iina_resolution() {
        Some(IinaResolution::Cli(executable)) => {
            let mut c = Command::new(executable);
            c.arg("--keep-running").arg("--no-stdin");
            c
        }
        Some(IinaResolution::AppFallback) => {
            let mut c = Command::new("open");
            c.arg("-a").arg("IINA").arg(url);
            return c;
        }
        None => Command::new("iina"),
    };
    #[cfg(not(target_os = "macos"))]
    let mut command = Command::new("iina");
    let mpv = mpv_command(
        url,
        subtitle,
        headers,
        true,
        window,
        resume_seconds,
        tracker,
        max_height,
    );
    for arg in mpv.get_args() {
        let s = arg.to_string_lossy();
        if !s.starts_with("--mpv-script") {
            command.arg(arg);
        }
    }
    command
}

#[cfg(target_os = "macos")]
pub fn iina_is_app_fallback() -> bool {
    matches!(iina_resolution(), Some(IinaResolution::AppFallback))
}

#[cfg(not(target_os = "macos"))]
pub fn iina_is_app_fallback() -> bool {
    false
}

fn vlc_command(
    url: &str,
    subtitle: Option<&str>,
    headers: &[(String, String)],
    window: Option<(u32, u32)>,
    resume_seconds: Option<u64>,
    max_height: Option<u64>,
) -> Command {
    let fallback = if cfg!(target_os = "windows") {
        "vlc.exe"
    } else {
        "vlc"
    };
    let executable = vlc_executable().unwrap_or_else(|| fallback.into());
    let mut command = build_player_process_command(&executable);

    if let Some((width, height)) = window {
        command
            .arg(format!("--width={width}"))
            .arg(format!("--height={height}"));
    }
    #[cfg(not(target_os = "macos"))]
    command.arg("--no-one-instance");
    command.arg("--network-caching=3000");
    command.arg("--file-caching=3000");
    command.arg("--http-reconnect");
    command.arg("--adaptive-logic=predictive");
    if let Some(height) = max_height.filter(|&h| h > 0) {
        command.arg(format!("--adaptive-maxheight={height}"));
    }
    if let Some(start) = resume_seconds {
        if start > 0 {
            command.arg(format!("--start-time={start}"));
        }
    }

    for (name, value) in headers {
        if name.eq_ignore_ascii_case("referer") {
            command.arg(format!("--http-referrer={value}"));
        } else if name.eq_ignore_ascii_case("user-agent") {
            command.arg(format!("--http-user-agent={value}"));
        }
    }
    if let Some(subtitle) = subtitle {
        let sub_path = vlc_subtitle_path(subtitle);
        command.arg(format!("--sub-file={sub_path}"));
    }

    if is_flatpak_executable(&executable) && (url.starts_with('/') || url.starts_with("file://")) {
        command.arg("@@").arg(url).arg("@@");
    } else {
        command.arg(url);
    }
    command
}

fn probe_player_executable(
    env_var: &str,
    candidates: &[String],
    bin_names: &[&str],
    flatpak_id: Option<&str>,
) -> Option<String> {
    if let Some(executable) = configured_executable(env_var) {
        return Some(executable);
    }

    for path in candidates {
        if Path::new(path).is_file() {
            return Some(path.to_string());
        }
    }

    for bin in bin_names {
        if let Some(path) = find_in_path(bin) {
            return Some(path);
        }
    }

    if let Some(id) = flatpak_id {
        flatpak_executable(id)
    } else {
        None
    }
}

#[cfg(target_os = "windows")]
fn query_windows_registry_value(key: &str, value_name: Option<&str>) -> Option<String> {
    use std::os::windows::process::CommandExt;

    let mut cmd = Command::new("reg.exe");
    cmd.arg("query").arg(key);
    if let Some(val) = value_name {
        cmd.arg("/v").arg(val);
    } else {
        cmd.arg("/ve");
    }
    cmd.creation_flags(CREATE_NO_WINDOW);

    let output = cmd.output().ok()?;
    if !output.status.success() {
        return None;
    }
    let text = String::from_utf8_lossy(&output.stdout);
    for line in text.lines() {
        let trimmed = line.trim();
        if trimmed.starts_with("HKEY_") || trimmed.is_empty() {
            continue;
        }
        let parts: Vec<&str> = trimmed.split_whitespace().collect();
        if parts.len() >= 3 {
            if let Some(pos) = parts
                .iter()
                .position(|&p| p == "REG_SZ" || p == "REG_EXPAND_SZ")
            {
                let is_expand = parts[pos] == "REG_EXPAND_SZ";
                if pos + 1 < parts.len() {
                    let val = parts[pos + 1..].join(" ");
                    let clean = val.trim_matches('"').trim();
                    if !clean.is_empty() {
                        let expanded = if is_expand {
                            expand_env_vars(clean)
                        } else {
                            clean.to_string()
                        };
                        return Some(expanded);
                    }
                }
            }
        }
    }
    None
}

#[cfg(target_os = "windows")]
fn expand_env_vars(raw: &str) -> String {
    let mut result = String::with_capacity(raw.len());
    let mut chars = raw.chars().peekable();
    while let Some(ch) = chars.next() {
        if ch == '%' {
            let mut var_name = String::new();
            let mut found_end = false;
            for next_ch in chars.by_ref() {
                if next_ch == '%' {
                    found_end = true;
                    break;
                }
                var_name.push(next_ch);
            }
            if found_end && !var_name.is_empty() {
                if let Ok(val) = std::env::var(&var_name) {
                    result.push_str(&val);
                } else {
                    result.push('%');
                    result.push_str(&var_name);
                    result.push('%');
                }
            } else {
                result.push('%');
                result.push_str(&var_name);
            }
        } else {
            result.push(ch);
        }
    }
    result
}

pub fn windows_mpv_candidate_paths(
    localappdata: Option<&str>,
    appdata: Option<&str>,
    userprofile: Option<&Path>,
) -> Vec<String> {
    let mut candidates = Vec::new();

    if let Ok(exe_path) = std::env::current_exe() {
        if let Some(parent) = exe_path.parent() {
            for name in &[
                "mpv.exe",
                "mpv.com",
                "mpvnet.exe",
                "mpvnet.com",
                r"mpv\mpv.exe",
                r"mpv\mpv.com",
                r"mpv.net\mpvnet.exe",
                r"mpv.net\mpv.exe",
            ] {
                candidates.push(parent.join(name).to_string_lossy().into_owned());
            }
        }
    }
    if let Ok(cwd) = std::env::current_dir() {
        for name in &[
            "mpv.exe",
            "mpv.com",
            "mpvnet.exe",
            "mpvnet.com",
            r"mpv\mpv.exe",
            r"mpv\mpv.com",
            r"mpv.net\mpvnet.exe",
            r"mpv.net\mpv.exe",
        ] {
            candidates.push(cwd.join(name).to_string_lossy().into_owned());
        }
    }

    if let Some(local) = localappdata {
        candidates.push(format!(r"{local}\Microsoft\WinGet\Links\mpv.exe"));
        candidates.push(format!(r"{local}\Microsoft\WinGet\Links\mpv.com"));
        candidates.push(format!(r"{local}\Microsoft\WinGet\Links\mpvnet.exe"));
        candidates.push(format!(r"{local}\Programs\mpv\mpv.exe"));
        candidates.push(format!(r"{local}\Programs\mpv\mpv.com"));
        candidates.push(format!(r"{local}\Programs\mpv.net\mpvnet.exe"));
        candidates.push(format!(r"{local}\Programs\mpv.net\mpv.exe"));

        let packages_dir = std::path::PathBuf::from(format!(r"{local}\Microsoft\WinGet\Packages"));
        if packages_dir.is_dir() {
            if let Ok(entries) = std::fs::read_dir(&packages_dir) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    let name = path
                        .file_name()
                        .and_then(|n| n.to_str())
                        .unwrap_or("")
                        .to_ascii_lowercase();
                    if name.contains("mpv") && path.is_dir() {
                        candidates.push(path.join("mpv.exe").to_string_lossy().into_owned());
                        candidates.push(path.join("mpv.com").to_string_lossy().into_owned());
                        candidates.push(path.join("mpvnet.exe").to_string_lossy().into_owned());
                    }
                }
            }
        }
    }

    if let Some(appdata_dir) = appdata {
        candidates.push(format!(r"{appdata_dir}\mpv\mpv.exe"));
        candidates.push(format!(r"{appdata_dir}\mpv\mpv.com"));
    }

    if let Some(home) = userprofile {
        for sub in &["Downloads", "Desktop"] {
            let folder = home.join(sub);
            candidates.push(folder.join("mpv.exe").to_string_lossy().into_owned());
            candidates.push(folder.join("mpv.com").to_string_lossy().into_owned());
            candidates.push(folder.join("mpvnet.exe").to_string_lossy().into_owned());

            if folder.is_dir() {
                if let Ok(entries) = std::fs::read_dir(&folder) {
                    for entry in entries.flatten() {
                        let path = entry.path();
                        let folder_name = path
                            .file_name()
                            .and_then(|n| n.to_str())
                            .unwrap_or("")
                            .to_ascii_lowercase();
                        if folder_name.contains("mpv") && path.is_dir() {
                            candidates.push(path.join("mpv.exe").to_string_lossy().into_owned());
                            candidates.push(path.join("mpv.com").to_string_lossy().into_owned());
                            candidates.push(path.join("mpvnet.exe").to_string_lossy().into_owned());
                        }
                    }
                }
            }
        }

        candidates.push(
            home.join(r"scoop\shims\mpv.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\shims\mpv.com")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\shims\mpvnet.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\apps\mpv\current\mpv.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\apps\mpv\current\mpv.com")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\apps\mpv-git\current\mpv.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\apps\mpv.net\current\mpvnet.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(home.join(r"mpv\mpv.exe").to_string_lossy().into_owned());
        candidates.push(home.join(r"mpv\mpv.com").to_string_lossy().into_owned());
        candidates.push(home.join(r"bin\mpv.exe").to_string_lossy().into_owned());
    }

    candidates.push(r"C:\Program Files\mpv\mpv.exe".to_string());
    candidates.push(r"C:\Program Files\mpv\mpv.com".to_string());
    candidates.push(r"C:\Program Files\MPV Player\mpv.exe".to_string());
    candidates.push(r"C:\Program Files\MPV Player\mpv.com".to_string());
    candidates.push(r"C:\Program Files\mpv-player\mpv.exe".to_string());
    candidates.push(r"C:\Program Files\mpv-player\mpv.com".to_string());
    candidates.push(r"C:\Program Files\mpv.net\mpvnet.exe".to_string());
    candidates.push(r"C:\Program Files\mpv.net\mpv.exe".to_string());
    candidates.push(r"C:\Program Files (x86)\mpv\mpv.exe".to_string());
    candidates.push(r"C:\Program Files (x86)\mpv\mpv.com".to_string());
    candidates.push(r"C:\Program Files (x86)\mpv.net\mpvnet.exe".to_string());
    candidates.push(r"C:\mpv\mpv.exe".to_string());
    candidates.push(r"C:\mpv\mpv.com".to_string());
    candidates.push(r"D:\mpv\mpv.exe".to_string());
    candidates.push(r"D:\mpv\mpv.com".to_string());
    candidates.push(r"C:\tools\mpv\mpv.exe".to_string());
    candidates.push(r"C:\tools\mpv\mpv.com".to_string());
    candidates.push(r"C:\ProgramData\chocolatey\bin\mpv.exe".to_string());
    candidates.push(r"C:\ProgramData\scoop\shims\mpv.exe".to_string());
    candidates.push(r"C:\ProgramData\scoop\apps\mpv\current\mpv.exe".to_string());

    #[cfg(target_os = "windows")]
    {
        for key in &[
            r"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\mpv.exe",
            r"HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\mpv.exe",
            r"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\mpvnet.exe",
            r"HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\mpvnet.exe",
        ] {
            if let Some(reg_path) = query_windows_registry_value(key, None) {
                candidates.push(reg_path);
            }
        }
    }

    candidates
}

pub fn windows_vlc_candidate_paths(
    localappdata: Option<&str>,
    appdata: Option<&str>,
    userprofile: Option<&Path>,
) -> Vec<String> {
    let mut candidates = Vec::new();

    if let Ok(exe_path) = std::env::current_exe() {
        if let Some(parent) = exe_path.parent() {
            for name in &["vlc.exe", r"vlc\vlc.exe", r"VideoLAN\VLC\vlc.exe"] {
                candidates.push(parent.join(name).to_string_lossy().into_owned());
            }
        }
    }
    if let Ok(cwd) = std::env::current_dir() {
        for name in &["vlc.exe", r"vlc\vlc.exe", r"VideoLAN\VLC\vlc.exe"] {
            candidates.push(cwd.join(name).to_string_lossy().into_owned());
        }
    }

    if let Some(local) = localappdata {
        candidates.push(format!(r"{local}\Microsoft\WinGet\Links\vlc.exe"));
        candidates.push(format!(r"{local}\Programs\VLC\vlc.exe"));
        candidates.push(format!(r"{local}\Programs\VideoLAN\VLC\vlc.exe"));

        let packages_dir = std::path::PathBuf::from(format!(r"{local}\Microsoft\WinGet\Packages"));
        if packages_dir.is_dir() {
            if let Ok(entries) = std::fs::read_dir(&packages_dir) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    let name = path
                        .file_name()
                        .and_then(|n| n.to_str())
                        .unwrap_or("")
                        .to_ascii_lowercase();
                    if (name.contains("vlc") || name.contains("videolan")) && path.is_dir() {
                        candidates.push(path.join("vlc.exe").to_string_lossy().into_owned());
                        candidates.push(path.join(r"vlc\vlc.exe").to_string_lossy().into_owned());
                    }
                }
            }
        }
    }

    if let Some(appdata_dir) = appdata {
        candidates.push(format!(r"{appdata_dir}\vlc\vlc.exe"));
        candidates.push(format!(r"{appdata_dir}\VideoLAN\VLC\vlc.exe"));
    }

    if let Some(home) = userprofile {
        for sub in &["Downloads", "Desktop"] {
            let folder = home.join(sub);
            candidates.push(folder.join("vlc.exe").to_string_lossy().into_owned());
            if folder.is_dir() {
                if let Ok(entries) = std::fs::read_dir(&folder) {
                    for entry in entries.flatten() {
                        let path = entry.path();
                        let folder_name = path
                            .file_name()
                            .and_then(|n| n.to_str())
                            .unwrap_or("")
                            .to_ascii_lowercase();
                        if (folder_name.contains("vlc") || folder_name.contains("videolan"))
                            && path.is_dir()
                        {
                            candidates.push(path.join("vlc.exe").to_string_lossy().into_owned());
                        }
                    }
                }
            }
        }

        candidates.push(
            home.join(r"scoop\shims\vlc.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(
            home.join(r"scoop\apps\vlc\current\vlc.exe")
                .to_string_lossy()
                .into_owned(),
        );
        candidates.push(home.join(r"vlc\vlc.exe").to_string_lossy().into_owned());
        candidates.push(home.join(r"bin\vlc.exe").to_string_lossy().into_owned());
    }

    candidates.push(r"C:\Program Files\VideoLAN\VLC\vlc.exe".to_string());
    candidates.push(r"C:\Program Files (x86)\VideoLAN\VLC\vlc.exe".to_string());
    candidates.push(r"C:\vlc\vlc.exe".to_string());
    candidates.push(r"D:\vlc\vlc.exe".to_string());
    candidates.push(r"C:\tools\vlc\vlc.exe".to_string());
    candidates.push(r"C:\ProgramData\chocolatey\bin\vlc.exe".to_string());
    candidates.push(r"C:\ProgramData\scoop\shims\vlc.exe".to_string());
    candidates.push(r"C:\ProgramData\scoop\apps\vlc\current\vlc.exe".to_string());

    #[cfg(target_os = "windows")]
    {
        for key in &[
            r"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\vlc.exe",
            r"HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\vlc.exe",
        ] {
            if let Some(reg_path) = query_windows_registry_value(key, None) {
                candidates.push(reg_path);
            }
        }
    }

    candidates
}

fn probe_mpv() -> Option<String> {
    let mut candidates = Vec::new();

    #[cfg(target_os = "windows")]
    {
        let localappdata = std::env::var("LOCALAPPDATA").ok();
        let appdata = std::env::var("APPDATA").ok();
        let home = dirs::home_dir();
        candidates.extend(windows_mpv_candidate_paths(
            localappdata.as_deref(),
            appdata.as_deref(),
            home.as_deref(),
        ));
    }

    #[cfg(target_os = "macos")]
    {
        candidates.push("/Applications/mpv.app/Contents/MacOS/mpv".to_string());
        if let Some(home) = dirs::home_dir() {
            candidates.push(
                home.join("Applications/mpv.app/Contents/MacOS/mpv")
                    .to_string_lossy()
                    .into_owned(),
            );
            candidates.push(
                home.join(".nix-profile/bin/mpv")
                    .to_string_lossy()
                    .into_owned(),
            );
        }
        candidates.push("/opt/homebrew/bin/mpv".to_string());
        candidates.push("/opt/local/bin/mpv".to_string());
        candidates.push("/usr/local/bin/mpv".to_string());
        candidates.push("/run/current-system/sw/bin/mpv".to_string());
        candidates.push("/bin/mpv".to_string());
    }

    #[cfg(target_os = "android")]
    {
        if let Ok(prefix) = std::env::var("PREFIX") {
            candidates.push(format!("{prefix}/bin/mpv"));
        }
        candidates.push("/data/data/com.termux/files/usr/bin/mpv".to_string());
    }
    #[cfg(target_os = "linux")]
    {
        candidates.push("/usr/bin/mpv".to_string());
        candidates.push("/usr/local/bin/mpv".to_string());
        candidates.push("/bin/mpv".to_string());
        candidates.push("/run/current-system/sw/bin/mpv".to_string());
        if let Some(home) = dirs::home_dir() {
            candidates.push(
                home.join(".local/share/flatpak/exports/bin/io.mpv.Mpv")
                    .to_string_lossy()
                    .into_owned(),
            );
            candidates.push(home.join(".local/bin/mpv").to_string_lossy().into_owned());
            candidates.push(
                home.join(".nix-profile/bin/mpv")
                    .to_string_lossy()
                    .into_owned(),
            );
        }
        candidates.push("/var/lib/flatpak/exports/bin/io.mpv.Mpv".to_string());
        candidates.push("/snap/bin/mpv".to_string());
        candidates.push("/var/lib/snapd/snap/bin/mpv".to_string());
        candidates.push("/app/bin/mpv".to_string());
        if let Ok(prefix) = std::env::var("PREFIX") {
            candidates.push(format!("{prefix}/bin/mpv"));
        }
        candidates.push("/data/data/com.termux/files/usr/bin/mpv".to_string());
    }
    let bin_names = if cfg!(target_os = "windows") {
        &[
            "mpv.exe",
            "mpv.com",
            "mpv",
            "mpvnet.exe",
            "mpvnet.com",
            "mpvnet",
        ][..]
    } else {
        &["mpv", "io.mpv.Mpv"][..]
    };

    probe_player_executable(
        "MOVIEBOX_MPV_PATH",
        &candidates,
        bin_names,
        Some("io.mpv.Mpv"),
    )
}

fn probe_vlc() -> Option<String> {
    let mut candidates = Vec::new();

    #[cfg(target_os = "windows")]
    {
        let localappdata = std::env::var("LOCALAPPDATA").ok();
        let appdata = std::env::var("APPDATA").ok();
        let home = dirs::home_dir();
        candidates.extend(windows_vlc_candidate_paths(
            localappdata.as_deref(),
            appdata.as_deref(),
            home.as_deref(),
        ));
    }

    #[cfg(target_os = "macos")]
    {
        candidates.push("/Applications/VLC.app/Contents/MacOS/VLC".to_string());
        if let Some(home) = dirs::home_dir() {
            candidates.push(
                home.join("Applications/VLC.app/Contents/MacOS/VLC")
                    .to_string_lossy()
                    .into_owned(),
            );
            candidates.push(
                home.join(".nix-profile/bin/vlc")
                    .to_string_lossy()
                    .into_owned(),
            );
        }
        candidates.push("/opt/homebrew/bin/vlc".to_string());
        candidates.push("/opt/local/bin/vlc".to_string());
        candidates.push("/usr/local/bin/vlc".to_string());
        candidates.push("/run/current-system/sw/bin/vlc".to_string());
        candidates.push("/bin/vlc".to_string());
    }

    #[cfg(target_os = "android")]
    {
        if let Ok(prefix) = std::env::var("PREFIX") {
            candidates.push(format!("{prefix}/bin/vlc"));
        }
        candidates.push("/data/data/com.termux/files/usr/bin/vlc".to_string());
    }
    #[cfg(target_os = "linux")]
    {
        candidates.push("/usr/bin/vlc".to_string());
        candidates.push("/usr/local/bin/vlc".to_string());
        candidates.push("/bin/vlc".to_string());
        candidates.push("/run/current-system/sw/bin/vlc".to_string());
        if let Some(home) = dirs::home_dir() {
            candidates.push(
                home.join(".local/share/flatpak/exports/bin/org.videolan.VLC")
                    .to_string_lossy()
                    .into_owned(),
            );
            candidates.push(home.join(".local/bin/vlc").to_string_lossy().into_owned());
            candidates.push(
                home.join(".nix-profile/bin/vlc")
                    .to_string_lossy()
                    .into_owned(),
            );
        }
        candidates.push("/var/lib/flatpak/exports/bin/org.videolan.VLC".to_string());
        candidates.push("/snap/bin/vlc".to_string());
        candidates.push("/var/lib/snapd/snap/bin/vlc".to_string());
        candidates.push("/app/bin/vlc".to_string());
        if let Ok(prefix) = std::env::var("PREFIX") {
            candidates.push(format!("{prefix}/bin/vlc"));
        }
        candidates.push("/data/data/com.termux/files/usr/bin/vlc".to_string());
    }
    let bin_names = if cfg!(target_os = "windows") {
        &["vlc.exe", "vlc"][..]
    } else {
        &["vlc", "org.videolan.VLC"][..]
    };

    probe_player_executable(
        "MOVIEBOX_VLC_PATH",
        &candidates,
        bin_names,
        Some("org.videolan.VLC"),
    )
}

static MPV_CACHED: std::sync::RwLock<Option<Option<String>>> = std::sync::RwLock::new(None);
static VLC_CACHED: std::sync::RwLock<Option<Option<String>>> = std::sync::RwLock::new(None);

fn mpv_executable() -> Option<String> {
    if let Ok(guard) = MPV_CACHED.read() {
        if let Some(cached) = &*guard {
            if let Some(path) = cached {
                if path.starts_with("flatpak run ") || Path::new(path).is_file() {
                    return Some(path.clone());
                }
            } else {
                return None;
            }
        }
    }

    let detected = probe_mpv();
    if let Ok(mut guard) = MPV_CACHED.write() {
        *guard = Some(detected.clone());
    }
    detected
}

fn vlc_executable() -> Option<String> {
    if let Ok(guard) = VLC_CACHED.read() {
        if let Some(cached) = &*guard {
            if let Some(path) = cached {
                if path.starts_with("flatpak run ") || Path::new(path).is_file() {
                    return Some(path.clone());
                }
            } else {
                return None;
            }
        }
    }

    let detected = probe_vlc();
    if let Ok(mut guard) = VLC_CACHED.write() {
        *guard = Some(detected.clone());
    }
    detected
}
pub fn clear_cached_player_executables() {
    if let Ok(mut guard) = MPV_CACHED.write() {
        *guard = None;
    }
    if let Ok(mut guard) = VLC_CACHED.write() {
        *guard = None;
    }
    #[cfg(target_os = "macos")]
    if let Ok(mut guard) = IINA_CACHED.write() {
        *guard = None;
    }
}

fn flatpak_executable(app_id: &str) -> Option<String> {
    if !cfg!(target_os = "linux") {
        return None;
    }
    if find_in_path("flatpak").is_some() {
        let mut cmd = Command::new("flatpak");
        cmd.arg("info")
            .arg(app_id)
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null());
        if cmd.output().map(|o| o.status.success()).unwrap_or(false) {
            return Some(format!("flatpak run {}", app_id));
        }

        let mut user_cmd = Command::new("flatpak");
        user_cmd
            .arg("info")
            .arg("--user")
            .arg(app_id)
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null());
        if user_cmd
            .output()
            .map(|o| o.status.success())
            .unwrap_or(false)
        {
            return Some(format!("flatpak run {}", app_id));
        }
    }
    None
}

fn configured_executable(variable: &str) -> Option<String> {
    let raw = std::env::var(variable).ok().or_else(|| {
        let cfg = crate::config::load();
        match variable {
            "MOVIEBOX_VLC_PATH" => cfg.vlc_path,
            "MOVIEBOX_MPV_PATH" => cfg.mpv_path,
            "MOVIEBOX_IINA_PATH" => cfg.iina_path,
            _ => None,
        }
    })?;
    let trimmed = raw.trim();
    if trimmed.is_empty() {
        return None;
    }
    if trimmed.starts_with("flatpak run ")
        || Path::new(trimmed).exists()
        || find_in_path(trimmed).is_some()
    {
        Some(trimmed.to_string())
    } else {
        None
    }
}

pub(crate) fn find_in_path(name: &str) -> Option<String> {
    if std::path::Path::new(name).is_file() {
        return Some(name.to_string());
    }
    #[cfg(target_os = "windows")]
    {
        if std::path::Path::new(&format!("{name}.exe")).is_file() {
            return Some(format!("{name}.exe"));
        }
        if std::path::Path::new(&format!("{name}.com")).is_file() {
            return Some(format!("{name}.com"));
        }
    }

    let mut paths_to_search: Vec<std::path::PathBuf> = Vec::new();
    if let Some(path) = std::env::var_os("PATH") {
        paths_to_search.extend(std::env::split_paths(&path));
    }

    #[cfg(target_os = "windows")]
    {
        for (reg_key, reg_val) in &[
            (r"HKCU\Environment", "Path"),
            (
                r"HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment",
                "Path",
            ),
        ] {
            if let Some(raw_path) = query_windows_registry_value(reg_key, Some(reg_val)) {
                paths_to_search.extend(std::env::split_paths(&raw_path));
            }
        }
    }
    #[cfg(not(target_os = "windows"))]
    {
        for d in STANDARD_UNIX_BIN_DIRS {
            let p = std::path::PathBuf::from(d);
            if !paths_to_search.contains(&p) {
                paths_to_search.push(p);
            }
        }
        if let Ok(prefix) = std::env::var("PREFIX") {
            let p = std::path::PathBuf::from(format!("{prefix}/bin"));
            if !paths_to_search.contains(&p) {
                paths_to_search.push(p);
            }
        }
        if let Some(home) = dirs::home_dir() {
            let local_bin = home.join(".local/bin");
            if !paths_to_search.contains(&local_bin) {
                paths_to_search.push(local_bin);
            }
            let nix_bin = home.join(".nix-profile/bin");
            if !paths_to_search.contains(&nix_bin) {
                paths_to_search.push(nix_bin);
            }
        }
    }

    for dir in paths_to_search {
        let candidate = dir.join(name);
        #[cfg(target_os = "windows")]
        {
            let candidates = [
                candidate.clone(),
                candidate.with_extension("exe"),
                candidate.with_extension("com"),
                candidate.with_extension("cmd"),
                candidate.with_extension("bat"),
            ];
            for c in candidates {
                if c.is_file() {
                    return Some(c.to_string_lossy().into_owned());
                }
            }
        }
        #[cfg(not(target_os = "windows"))]
        {
            if candidate.is_file() {
                #[cfg(unix)]
                {
                    use std::os::unix::fs::PermissionsExt;
                    if candidate
                        .metadata()
                        .map(|m| m.permissions().mode() & 0o111 != 0)
                        .unwrap_or(false)
                    {
                        return Some(candidate.to_string_lossy().into_owned());
                    }
                }
                #[cfg(not(unix))]
                return Some(candidate.to_string_lossy().into_owned());
            }
        }
    }
    None
}

fn normalize_player_path(path: &str) -> String {
    if path.starts_with(r"\\") || path.starts_with("//") {
        path.to_string()
    } else {
        path.replace('\\', "/")
    }
}

fn vlc_subtitle_path(path: &str) -> String {
    if path.starts_with("http://") || path.starts_with("https://") {
        return path.to_string();
    }
    let bytes = path.as_bytes();
    let is_windows_drive = bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':';
    let is_unc = path.starts_with(r"\\") || path.starts_with("//");
    if is_windows_drive || is_unc {
        path.replace('/', r"\")
    } else {
        path.to_string()
    }
}

pub fn format_mpv_script_opts(
    provider: &str,
    subject_id: &str,
    season: usize,
    episode: usize,
    state_file: &Path,
) -> String {
    let state_file_str = normalize_player_path(&state_file.to_string_lossy()).replace(',', "_");
    let safe_provider = provider.replace(',', "_");
    let safe_subject = subject_id.replace(',', "_");
    format!(
        "moviebox-provider={safe_provider},moviebox-subject_id={safe_subject},moviebox-season={season},moviebox-episode={episode},moviebox-state_file={state_file_str}"
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn test_format_mpv_script_opts_windows_paths() {
        let win_path = PathBuf::from(
            r"C:\Users\User\AppData\Local\MovieBox-Tui\playback\moviebox_123_1_1.json",
        );
        let opts = format_mpv_script_opts("moviebox", "123", 1, 1, &win_path);
        assert!(!opts.contains(r"\"));
        assert!(opts.contains("moviebox-state_file=C:/Users/User/AppData/Local/MovieBox-Tui/playback/moviebox_123_1_1.json"));
    }

    #[test]
    fn test_format_mpv_script_opts_unix_paths() {
        let unix_path =
            PathBuf::from("/home/user/.local/share/moviebox-tui/playback/moviebox_123_1_1.json");
        let opts = format_mpv_script_opts("moviebox", "123", 1, 1, &unix_path);
        assert!(opts.contains("moviebox-state_file=/home/user/.local/share/moviebox-tui/playback/moviebox_123_1_1.json"));
    }

    #[test]
    fn vlc_command_preserves_supported_playback_options() {
        let command = vlc_command(
            "https://example.test/video.m3u8",
            Some("/tmp/subtitle.srt"),
            &[
                ("Referer".into(), "https://example.test/".into()),
                ("User-Agent".into(), "MovieBox-Test".into()),
                ("Cookie".into(), "ignored=by-vlc-filter".into()),
            ],
            Some((1280, 720)),
            Some(42),
            None,
        );
        let args = command
            .get_args()
            .map(|arg| arg.to_string_lossy().into_owned())
            .collect::<Vec<_>>();

        assert!(args.contains(&"--width=1280".into()));
        assert!(args.contains(&"--height=720".into()));
        assert!(!args.contains(&"--play-and-exit".into()));
        assert!(args.contains(&"--network-caching=3000".into()));
        assert!(args.contains(&"--file-caching=3000".into()));
        assert!(args.contains(&"--http-reconnect".into()));
        assert!(args.contains(&"--adaptive-logic=predictive".into()));
        assert!(args.contains(&"--start-time=42".into()));
        assert!(args.contains(&"--http-referrer=https://example.test/".into()));
        assert!(args.contains(&"--http-user-agent=MovieBox-Test".into()));
        assert!(args.contains(&"--sub-file=/tmp/subtitle.srt".into()));
        assert!(!args.iter().any(|arg| arg.starts_with("--http-cookie")));
        assert_eq!(
            args.last().map(String::as_str),
            Some("https://example.test/video.m3u8")
        );
    }

    #[test]
    fn vlc_command_preserves_windows_native_subtitle_separators() {
        for input in [
            r"C:\Users\User\AppData\Local\MovieBox-Tui\subs\sub.srt",
            "C:/Users/User/AppData/Local/MovieBox-Tui/subs/sub.srt",
        ] {
            let command = vlc_command(
                "https://example.test/video.mp4",
                Some(input),
                &[],
                None,
                None,
                None,
            );
            let args = command
                .get_args()
                .map(|arg| arg.to_string_lossy().into_owned())
                .collect::<Vec<_>>();
            assert!(args.contains(
                &r"--sub-file=C:\Users\User\AppData\Local\MovieBox-Tui\subs\sub.srt".into()
            ));
        }
    }
    #[test]
    fn vlc_command_preserves_unc_subtitle_paths() {
        let command = vlc_command(
            "https://example.test/video.mp4",
            Some(r"\\server\share\subs\sub.srt"),
            &[],
            None,
            None,
            None,
        );
        let args = command
            .get_args()
            .map(|arg| arg.to_string_lossy().into_owned())
            .collect::<Vec<_>>();
        assert!(args.contains(&r"--sub-file=\\server\share\subs\sub.srt".into()));
    }
    #[test]
    fn mpv_command_passes_multiple_header_fields_individually() {
        let headers = vec![
            ("Cookie".to_string(), "session=abc, token=123".to_string()),
            ("Accept".to_string(), "text/html, */*".to_string()),
            ("User-Agent".to_string(), "CustomUA".to_string()),
            ("Referer".to_string(), "https://example.com/".to_string()),
        ];
        let cmd = mpv_command(
            "https://example.com/video.mp4",
            None,
            &headers,
            false,
            None,
            None,
            None,
            None,
        );

        let args = cmd
            .get_args()
            .map(|arg| arg.to_string_lossy().into_owned())
            .collect::<Vec<_>>();
        assert!(args.contains(&"--user-agent=CustomUA".to_string()));
        assert!(args.contains(&"--referrer=https://example.com/".to_string()));
        assert!(args.contains(&"--http-header-fields=Cookie: session=abc, token=123".to_string()));
        assert!(args.contains(&"--http-header-fields=Accept: text/html, */*".to_string()));
    }
    static ENV_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());

    #[test]
    fn test_android_intent_commands_fallback_order() {
        let _lock = ENV_MUTEX.lock().unwrap();
        let temp_dir =
            std::env::temp_dir().join(format!("termux_fallback_test_{}", std::process::id()));
        let bin_dir = temp_dir.join("bin");
        std::fs::create_dir_all(&bin_dir).unwrap();
        let termux_am = bin_dir.join("termux-am");
        let termux_open = bin_dir.join("termux-open");
        std::fs::write(&termux_am, "#!/bin/sh\nexit 0").unwrap();
        std::fs::write(&termux_open, "#!/bin/sh\nexit 0").unwrap();

        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
            std::env::set_var("PREFIX", temp_dir.to_str().unwrap());
        }
        let commands = android_intent_commands("https://example.test/stream.m3u8", None, &[]);
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
            std::env::remove_var("PREFIX");
        }
        let _ = std::fs::remove_dir_all(&temp_dir);

        assert!(commands.len() >= 2);
        assert!(matches!(commands[0].0, AndroidOpener::TermuxAm(_)));
        assert!(matches!(commands[1].0, AndroidOpener::TermuxOpen(_)));
    }

    #[test]
    fn header_support_allows_android_cookies_and_vlc_proxy() {
        let headers = vec![("Cookie".into(), "session=secret".into())];
        assert!(supports_headers(PlayerKind::AndroidIntent, &headers));
        assert!(supports_headers(PlayerKind::Vlc, &headers));
        assert!(supports_headers(
            PlayerKind::Vlc,
            &[("referer".into(), "https://example.test/".into())]
        ));
        assert!(supports_headers(PlayerKind::AndroidIntent, &[]));
        assert!(supports_headers(
            PlayerKind::AndroidIntent,
            &[
                ("referer".into(), "https://example.test/".into()),
                ("user-agent".into(), "TestAgent/1.0".into())
            ]
        ));
        assert!(supports_headers(PlayerKind::Vlc, &[]));
        assert!(supports_headers(PlayerKind::Mpv, &headers));
    }

    #[test]
    fn test_android_intent_command_structure() {
        let cmd = android_intent_command("https://example.test/video.mp4", None, &[]);
        let args = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect::<Vec<_>>();
        assert!(args.contains(&"https://example.test/video.mp4".to_string()));
    }
    #[test]
    fn test_mpv_command_headers_no_broken_ytdl_raw_options() {
        let ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
        let headers = vec![
            ("User-Agent".into(), ua.into()),
            ("Referer".into(), "https://4khdhub.one".into()),
            ("Cookie".into(), "auth=token123".into()),
        ];
        let cmd = mpv_command(
            "https://example.test/stream.m3u8",
            None,
            &headers,
            false,
            None,
            None,
            None,
            None,
        );
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(args.iter().any(|a| a == &format!("--user-agent={ua}")));
        assert!(args.iter().any(|a| a == "--referrer=https://4khdhub.one"));
        assert!(
            args.iter()
                .any(|a| a == "--http-header-fields=Cookie: auth=token123")
        );
        assert!(
            args.iter()
                .any(|a| a == "--ytdl-raw-options-append=add-header=Cookie:auth=token123")
        );
        assert!(!args.iter().any(|a| a.starts_with("--ytdl-raw-options=")));
    }

    #[test]
    fn test_detect_prioritizes_android_intent_on_termux() {
        let temp_dir = std::env::temp_dir().join(format!("termux_test_{}", std::process::id()));
        let bin_dir = temp_dir.join("bin");
        std::fs::create_dir_all(&bin_dir).unwrap();
        let termux_am = bin_dir.join("termux-am");
        std::fs::write(&termux_am, "#!/bin/sh\nexit 0").unwrap();
        let _lock = ENV_MUTEX.lock().unwrap();
        unsafe {
            std::env::set_var("TERMUX_VERSION", "0.118.0");
            std::env::set_var("PREFIX", temp_dir.to_str().unwrap());
        }
        let detected = detect();
        unsafe {
            std::env::remove_var("TERMUX_VERSION");
            std::env::remove_var("PREFIX");
        }
        let _ = std::fs::remove_dir_all(&temp_dir);

        assert!(!detected.is_empty());
        assert_eq!(detected[0], PlayerKind::AndroidIntent);
    }

    #[test]
    fn test_windows_mpv_candidate_paths_comprehensive() {
        let home = PathBuf::from(r"C:\Users\TestUser");
        let candidates = windows_mpv_candidate_paths(
            Some(r"C:\Users\TestUser\AppData\Local"),
            Some(r"C:\Users\TestUser\AppData\Roaming"),
            Some(&home),
        );

        assert!(
            candidates
                .iter()
                .any(|c| c.contains("WinGet") && c.contains("mpv.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("WinGet") && c.contains("mpv.com"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("mpv.net") && c.contains("mpvnet.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Downloads") && c.contains("mpv.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Desktop") && c.contains("mpv.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("scoop") && c.contains("mpv.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Program Files") && c.contains("mpv.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Program Files") && c.contains("mpvnet.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("C:") && c.contains("mpv.exe"))
        );
    }

    #[test]
    fn test_windows_vlc_candidate_paths_comprehensive() {
        let home = PathBuf::from(r"C:\Users\TestUser");
        let candidates = windows_vlc_candidate_paths(
            Some(r"C:\Users\TestUser\AppData\Local"),
            Some(r"C:\Users\TestUser\AppData\Roaming"),
            Some(&home),
        );

        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Program Files") && c.contains("vlc.exe"))
        );
        assert!(!candidates.iter().any(|c| c.contains("WindowsApps")));
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("WinGet") && c.contains("vlc.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Downloads") && c.contains("vlc.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("Desktop") && c.contains("vlc.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("scoop") && c.contains("vlc.exe"))
        );
        assert!(
            candidates
                .iter()
                .any(|c| c.contains("C:") && c.contains("vlc.exe"))
        );
    }
    #[test]
    fn test_create_no_window_constant() {
        assert_eq!(CREATE_NO_WINDOW, 0x0800_0000);
    }
    #[test]
    fn test_configured_executable_fallback_to_config() {
        clear_cached_player_executables();
        let _cfg = crate::config::Config {
            vlc_path: Some("/nonexistent/vlc.exe".to_string()),
            ..Default::default()
        };
        assert!(configured_executable("MOVIEBOX_VLC_PATH").is_none());
    }

    #[test]
    fn test_mpv_command_headers_and_arguments_assembly() {
        let _lock = ENV_MUTEX.lock().unwrap();
        let headers = vec![
            ("User-Agent".to_string(), "MovieBox-Tui/0.1.23".to_string()),
            ("Referer".to_string(), "https://upstream.cdn/".to_string()),
            ("Origin".to_string(), "https://upstream.cdn".to_string()),
        ];
        let cmd = mpv_command(
            "https://upstream.cdn/stream.m3u8",
            Some("/tmp/test.srt"),
            &headers,
            false,
            Some((1920, 1080)),
            Some(120),
            None,
            None,
        );
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();

        assert!(args.contains(&"--sub-file=/tmp/test.srt".to_string()));
        assert!(args.contains(&"--start=120".to_string()));
        assert!(args.contains(&"--autofit=1920x1080".to_string()));
        assert!(args.contains(&"--hwdec=auto-safe".to_string()));
        assert!(args.contains(&"--cache=yes".to_string()));
        assert!(args.contains(&"--cache-secs=120".to_string()));
        assert!(args.contains(&"--cache-pause=yes".to_string()));
        assert!(args.contains(&"--cache-pause-wait=3".to_string()));
        assert!(args.contains(&"--cache-pause-initial=no".to_string()));
        assert!(args.contains(&"--demuxer-max-bytes=256M".to_string()));
        assert!(args.contains(&"--demuxer-readahead-secs=120".to_string()));
        assert!(args.contains(&"--demuxer-lavf-buffersize=1048576".to_string()));
        assert!(args.contains(&"--stream-buffer-size=4M".to_string()));
        assert!(args.contains(&"--ytdl=no".to_string()));
        assert!(args.contains(
            &"--stream-lavf-o=reconnect=1,reconnect_streamed=1,reconnect_delay_max=5".to_string()
        ));
        assert!(
            args.iter().any(|a| a.starts_with("--http-header-fields="))
                || args
                    .iter()
                    .any(|a| a.starts_with("--ytdl-raw-options-append="))
        );
        assert_eq!(
            args.last().map(String::as_str),
            Some("https://upstream.cdn/stream.m3u8")
        );
    }

    #[test]
    fn test_vlc_command_cookie_header_filtering() {
        let headers = vec![
            ("User-Agent".to_string(), "VLC-Agent".to_string()),
            ("Referer".to_string(), "https://cdn.example.com".to_string()),
            ("Cookie".to_string(), "CloudFront-Signature=abc".to_string()),
        ];
        let cmd = vlc_command(
            "http://127.0.0.1:4567/proxy/manifest.mpd",
            None,
            &headers,
            None,
            None,
            None,
        );
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();

        assert!(args.contains(&"--network-caching=3000".to_string()));
        assert!(args.contains(&"--file-caching=3000".to_string()));
        assert!(args.contains(&"--http-reconnect".to_string()));
        assert!(args.contains(&"--adaptive-logic=predictive".to_string()));
        assert!(args.contains(&"--http-user-agent=VLC-Agent".to_string()));
        assert!(args.contains(&"--http-referrer=https://cdn.example.com".to_string()));
        assert!(!args.iter().any(|a| a.contains("CloudFront-Signature")));
        assert_eq!(
            args.last().map(String::as_str),
            Some("http://127.0.0.1:4567/proxy/manifest.mpd")
        );
    }

    #[test]
    fn test_has_graphical_display_detection() {
        let _lock = ENV_MUTEX.lock().unwrap();
        let orig_display = std::env::var("DISPLAY").ok();
        let orig_wayland = std::env::var("WAYLAND_DISPLAY").ok();

        unsafe {
            std::env::set_var("DISPLAY", ":0");
            std::env::remove_var("WAYLAND_DISPLAY");
        }
        assert!(has_graphical_display());

        unsafe {
            std::env::remove_var("DISPLAY");
            std::env::set_var("WAYLAND_DISPLAY", "wayland-1");
        }
        assert!(has_graphical_display());

        unsafe {
            std::env::set_var("DISPLAY", "   ");
            std::env::remove_var("WAYLAND_DISPLAY");
        }
        assert!(!has_graphical_display());

        unsafe {
            if let Some(val) = orig_display {
                std::env::set_var("DISPLAY", val);
            } else {
                std::env::remove_var("DISPLAY");
            }
            if let Some(val) = orig_wayland {
                std::env::set_var("WAYLAND_DISPLAY", val);
            } else {
                std::env::remove_var("WAYLAND_DISPLAY");
            }
        }
    }

    #[cfg(unix)]
    #[test]
    fn test_configure_detached_process_survives_sighup() {
        let mut cmd = std::process::Command::new("sh");
        cmd.args(["-c", "sleep 0.2"]);
        cmd.stdin(std::process::Stdio::null());
        cmd.stdout(std::process::Stdio::null());
        cmd.stderr(std::process::Stdio::null());
        super::configure_detached_process(&mut cmd);
        let mut child = cmd.spawn().expect("spawn detached sh");
        let pid = child.id() as libc::pid_t;
        std::thread::sleep(std::time::Duration::from_millis(40));
        unsafe {
            libc::kill(pid, libc::SIGHUP);
            libc::kill(-pid, libc::SIGHUP);
        }
        let status = child.wait().expect("wait detached sh");
        assert!(status.success());
    }

    #[test]
    fn test_iina_command_dash_vs_direct_and_script_filtering() {
        let direct_cmd = command(
            PlayerKind::Iina,
            "https://cdn.example.com/movie.mkv",
            Some("/tmp/sub.srt"),
            &[("Referer".to_string(), "https://example.com".to_string())],
            Some((1280, 720)),
            Some(120),
            Some(("moviebox", "subj_1", 1, 1)),
            Some(1080),
        );
        let direct_args: Vec<String> = direct_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(direct_args.iter().any(|a| a.ends_with("hwdec=auto-safe")));
        assert!(direct_args.contains(&"--mpv-sub-files=/tmp/sub.srt".to_string()));
        assert!(
            direct_args
                .iter()
                .any(|a| a.ends_with("stream-buffer-size=4M"))
        );
        assert!(direct_args.iter().any(|a| a.ends_with("ytdl=no")));
        assert!(!direct_args.iter().any(|a| a.contains("force-seekable=yes")));
        #[cfg(target_os = "macos")]
        assert!(!direct_args.iter().any(|a| a.starts_with("--mpv-script=")));

        let dash_cmd = command(
            PlayerKind::Iina,
            "http://127.0.0.1:9000/https/cdn.example.com/dash/index.mpd",
            None,
            &[],
            None,
            None,
            None,
            Some(720),
        );
        let dash_args: Vec<String> = dash_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(dash_args.iter().any(|a| a.ends_with("force-seekable=yes")));
        assert!(!dash_args.iter().any(|a| a.ends_with("ytdl=no")));
    }

    #[test]
    fn test_flatpak_process_command_preserves_flags_and_mounts() {
        let cmd = build_player_process_command("flatpak run --user org.videolan.VLC");
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert_eq!(
            args,
            vec![
                "run",
                "--file-forwarding",
                "--filesystem=xdg-cache/moviebox-tui:ro",
                "--filesystem=xdg-data/moviebox-tui",
                "--filesystem=/tmp:ro",
                "--user",
                "org.videolan.VLC",
            ]
        );

        let export_cmd = build_player_process_command("/var/lib/flatpak/exports/bin/io.mpv.Mpv");
        let export_args: Vec<String> = export_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert_eq!(export_args.last().map(String::as_str), Some("io.mpv.Mpv"));
        assert!(export_args.contains(&"--filesystem=xdg-data/moviebox-tui".to_string()));
    }
    #[test]
    fn test_vlc_command_adaptive_maxheight_cap() {
        let cmd = vlc_command(
            "https://example.com/video.mpd",
            None,
            &[],
            None,
            None,
            Some(1080),
        );
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(args.contains(&"--adaptive-maxheight=1080".to_string()));
        assert!(!args.contains(&"--play-and-exit".to_string()));
    }

    #[test]
    fn test_vlc_command_omits_adaptive_maxheight_when_none_or_zero() {
        let cmd_none = vlc_command("https://example.com/video.mpd", None, &[], None, None, None);
        let args_none: Vec<String> = cmd_none
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(
            !args_none
                .iter()
                .any(|a| a.starts_with("--adaptive-maxheight="))
        );
        assert!(!args_none.contains(&"--play-and-exit".to_string()));

        let cmd_zero = vlc_command(
            "https://example.com/video.mpd",
            None,
            &[],
            None,
            None,
            Some(0),
        );
        let args_zero: Vec<String> = cmd_zero
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(
            !args_zero
                .iter()
                .any(|a| a.starts_with("--adaptive-maxheight="))
        );
    }

    #[test]
    fn test_vlc_command_no_one_instance_cross_platform() {
        let cmd = vlc_command("https://example.com/video.mp4", None, &[], None, None, None);
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        #[cfg(target_os = "macos")]
        assert!(!args.contains(&"--no-one-instance".to_string()));
        #[cfg(not(target_os = "macos"))]
        assert!(args.contains(&"--no-one-instance".to_string()));
        assert!(!args.contains(&"--play-and-exit".to_string()));
    }

    #[test]
    fn test_mpv_command_keeps_open_invariants() {
        let _lock = ENV_MUTEX.lock().unwrap();
        let cmd = mpv_command(
            "https://example.com/video.mkv",
            None,
            &[],
            false,
            None,
            None,
            None,
            None,
        );
        let args: Vec<String> = cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(args.contains(&"--idle=no".to_string()));
        assert!(args.contains(&"--keep-open=no".to_string()));
        assert!(args.contains(&"--hwdec=auto-safe".to_string()));
        assert!(args.contains(&"--demuxer-max-bytes=256M".to_string()));
        assert!(args.contains(&"--stream-buffer-size=4M".to_string()));
        assert!(!args.contains(&"--play-and-exit".to_string()));
    }

    #[test]
    fn test_mpv_command_dash_vs_direct_stream_ytdl_behavior() {
        let dash_cmd = mpv_command(
            "https://cdn.example.com/dash/index.mpd",
            None,
            &[],
            false,
            None,
            None,
            None,
            Some(720),
        );
        let dash_args: Vec<String> = dash_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(dash_args.contains(&"--force-seekable=yes".to_string()));
        assert!(!dash_args.contains(&"--ytdl=no".to_string()));

        let direct_cmd = mpv_command(
            "https://cdn.example.com/movie.mkv",
            None,
            &[],
            false,
            None,
            None,
            None,
            None,
        );
        let direct_args: Vec<String> = direct_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(direct_args.contains(&"--ytdl=no".to_string()));
        assert!(!direct_args.contains(&"--force-seekable=yes".to_string()));
    }

    #[test]
    fn test_android_intent_command_action_and_type_invariants() {
        let url = "https://example.com/stream.m3u8";
        let am_opener =
            AndroidOpener::TermuxAm("/data/data/com.termux/files/usr/bin/termux-am".to_string());
        let am_cmd = android_intent_command_for_opener(&am_opener, url, None, &[]);
        let am_args: Vec<String> = am_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(am_args.contains(&"start".to_string()));
        assert!(am_args.contains(&"-a".to_string()));
        assert!(am_args.contains(&"android.intent.action.VIEW".to_string()));
        assert!(am_args.contains(&"-t".to_string()));
        assert!(am_args.contains(&"video/*".to_string()));
        assert!(am_args.contains(&url.to_string()));

        let open_opener = AndroidOpener::TermuxOpen(
            "/data/data/com.termux/files/usr/bin/termux-open".to_string(),
        );
        let open_cmd = android_intent_command_for_opener(&open_opener, url, None, &[]);
        let open_args: Vec<String> = open_cmd
            .get_args()
            .map(|a| a.to_string_lossy().into_owned())
            .collect();
        assert!(open_args.contains(&"--chooser".to_string()));
        assert!(open_args.contains(&"--content-type".to_string()));
        assert!(open_args.contains(&"video/*".to_string()));
        assert!(open_args.contains(&url.to_string()));
    }

    #[test]
    fn test_player_supports_headers_full_cross_platform_matrix() {
        let empty_headers: Vec<(String, String)> = Vec::new();
        let standard_headers = vec![
            ("User-Agent".to_string(), "MovieBox-UA".to_string()),
            ("Referer".to_string(), "https://example.com/".to_string()),
        ];
        let cookie_headers = vec![("Cookie".to_string(), "auth_session=123".to_string())];

        assert!(supports_headers(PlayerKind::Mpv, &empty_headers));
        assert!(supports_headers(PlayerKind::Mpv, &standard_headers));
        assert!(supports_headers(PlayerKind::Mpv, &cookie_headers));

        assert!(supports_headers(PlayerKind::Vlc, &empty_headers));
        assert!(supports_headers(PlayerKind::Vlc, &standard_headers));
        assert!(supports_headers(PlayerKind::Vlc, &cookie_headers));

        assert!(supports_headers(PlayerKind::AndroidIntent, &empty_headers));
        assert!(supports_headers(
            PlayerKind::AndroidIntent,
            &standard_headers
        ));
        assert!(supports_headers(PlayerKind::AndroidIntent, &cookie_headers));

        assert!(supports_headers(PlayerKind::Iina, &empty_headers));
        assert!(supports_headers(PlayerKind::Iina, &standard_headers));
    }
}