Skip to content

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

64.1 KB
Raw Blame
use super::App;
use crate::providers::models::ProviderKind;
use crate::tui::{
    action::Action,
    event::EventHandler,
    state::{InputMode, Screen},
};
use ratatui::{Frame, layout::Rect};
use std::time::Duration;

enum ForcedProtocol {
    None,
    Type(ratatui_image::picker::ProtocolType),
}

impl App {
    pub async fn run<B: ratatui::backend::Backend>(
        &mut self,
        terminal: &mut ratatui::Terminal<B>,
    ) -> std::io::Result<()>
    where
        std::io::Error: From<<B as ratatui::backend::Backend>::Error>,
    {
        let should_probe = self.state.image_supported;
        if self.state.image_picker.is_none() && should_probe {
            self.probe_terminal().await;
        }

        let mut events = EventHandler::new(Duration::from_millis(100));

        if self.state.active_provider == ProviderKind::MovieBox {
            let client = self.service.client.clone();
            tokio::spawn(async move {
                let _ = client.init().await;
            });
        }

        if !self.state.bdix_probed {
            self.action_sender.send(Action::CheckBdixNetwork).ok();
        }

        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        if self.state.auto_update && now.saturating_sub(self.state.last_update_check) > 3600 {
            self.state.manual_update_check = false;
            self.action_sender.send(Action::CheckForUpdates).ok();
        }
        self.state.active_screen = Screen::Home;

        self.state.available_players = crate::tui::player::detect();
        if crate::player::has_graphical_display()
            && std::env::var(crate::player::ENV_MOVIEBOX_PLAYER).is_err()
            && self.state.default_player.as_deref().is_some_and(|p| {
                p.eq_ignore_ascii_case("android")
                    || p.eq_ignore_ascii_case("androidintent")
                    || p.eq_ignore_ascii_case("android-intent")
            })
            && self
                .state
                .available_players
                .iter()
                .any(|&p| p != crate::tui::state::PlayerKind::AndroidIntent)
        {
            self.state.default_player = None;
            self.persist_config();
        }
        let preferred = std::env::var(crate::player::ENV_MOVIEBOX_PLAYER)
            .ok()
            .and_then(|value| crate::tui::state::PlayerKind::parse(&value))
            .or_else(|| {
                self.state
                    .default_player
                    .as_deref()
                    .filter(|p| !p.eq_ignore_ascii_case("auto"))
                    .and_then(crate::tui::state::PlayerKind::parse)
            });
        if let Some(preferred) = preferred
            && let Some(index) = self
                .state
                .available_players
                .iter()
                .position(|&k| k == preferred)
        {
            let kind = self.state.available_players.remove(index);
            self.state.available_players.insert(0, kind);
        }
        let mut last_window_title = String::new();

        loop {
            let want_beam =
                self.state.input_mode == InputMode::Editing && !self.state.basic_terminal;
            if want_beam != self.state.cursor_beam {
                use crossterm::cursor::SetCursorStyle;
                let style = if want_beam {
                    SetCursorStyle::SteadyBar
                } else {
                    SetCursorStyle::DefaultUserShape
                };
                let _ = crossterm::execute!(std::io::stdout(), style);
                self.state.cursor_beam = want_beam;
            }
            if self.state.dirty || last_window_title.is_empty() {
                let title = self.contextual_title();
                if title != last_window_title {
                    let _ = crate::tui::terminal::set_window_title(&title);
                    last_window_title = title;
                }
            }
            self.state.normalize_result_view();
            if self.state.clear_terminal_before_draw {
                if let Err(err) = terminal.clear() {
                    log::debug!("terminal clear warning: {err}");
                    let _ = terminal.backend_mut().clear();
                }
                self.state.clear_poster_protocols();
                self.state.clear_terminal_before_draw = false;
                self.state.dirty = true;
            }
            if self.state.dirty {
                if let Err(err) = terminal.draw(|frame| self.draw(frame)) {
                    log::warn!("transient draw warning: {err}");
                }
                self.state.dirty = false;
            }

            tokio::select! {
                Some(action) = events.next() => {
                    if let Some(quit) = self.handle_action(action).await {
                        return Ok(quit);
                    }
                    while let Ok(action) = events.try_recv() {
                        if let Some(quit) = self.handle_action(action).await {
                            return Ok(quit);
                        }
                    }
                }
                Some(action) = self.action_receiver.recv() => {
                    if let Some(quit) = self.handle_action(action).await {
                        return Ok(quit);
                    }
                    while let Ok(action) = self.action_receiver.try_recv() {
                        if let Some(quit) = self.handle_action(action).await {
                            return Ok(quit);
                        }
                    }
                }
            }
        }
    }

    pub(super) async fn probe_terminal(&mut self) {
        use ratatui_image::picker::{Capability, ProtocolType};

        match Self::forced_protocol() {
            Some(ForcedProtocol::None) => {
                self.state.image_supported = false;
                self.state.image_picker = None;
                return;
            }
            Some(ForcedProtocol::Type(ProtocolType::Halfblocks)) => {
                self.state.image_supported = false;
                self.state.image_picker = None;
                return;
            }
            Some(ForcedProtocol::Type(protocol)) => {
                let picker =
                    Self::create_picker_with_font_size(Self::cell_size_override(), protocol);
                self.accept_picker(picker);
                return;
            }
            None => {}
        }
        let picker = self.query_picker().await;

        if self.state.theme_is_auto
            && let Some(background) = picker.as_ref().and_then(|p| {
                p.capabilities()
                    .iter()
                    .find_map(|capability| match capability {
                        Capability::Background(red, green, blue) => Some((*red, *green, *blue)),
                        _ => None,
                    })
            })
        {
            let luminance = 0.2126 * f32::from(background.0)
                + 0.7152 * f32::from(background.1)
                + 0.0722 * f32::from(background.2);
            let is_light = luminance > 128.0;
            self.theme = crate::tui::theme::Theme::detect_with_light(Some(is_light));
            self.state.active_theme_kind = if is_light { "Latte" } else { "Mocha" }.to_string();
        }

        let mut picker = match (picker, Self::cell_size_override()) {
            (Some(picker), None) => picker,
            (probed, cell_size) => {
                let target_protocol = Self::forced_protocol()
                    .and_then(|p| match p {
                        ForcedProtocol::Type(proto) => Some(proto),
                        _ => None,
                    })
                    .or_else(|| probed.as_ref().map(|p| p.protocol_type()))
                    .unwrap_or(ProtocolType::Halfblocks);
                Self::create_picker_with_font_size(cell_size, target_protocol)
            }
        };

        let capabilities_empty = picker.capabilities().is_empty();
        if matches!(picker.protocol_type(), ProtocolType::Halfblocks) && !capabilities_empty {
            let caps = picker.capabilities();
            let salvaged = if caps.iter().any(|c| matches!(c, Capability::Kitty)) {
                Some(ProtocolType::Kitty)
            } else if caps.iter().any(|c| matches!(c, Capability::Sixel)) {
                Some(ProtocolType::Sixel)
            } else {
                None
            };
            if let Some(protocol) = salvaged {
                log::info!(
                    "salvaging graphics-capable terminal that answered as halfblocks: {:?}",
                    protocol
                );
                picker.set_protocol_type(protocol);
            }
        }

        if matches!(picker.protocol_type(), ProtocolType::Halfblocks) {
            self.state.image_supported = false;
            self.state.image_picker = None;
            return;
        }
        self.accept_picker(picker);
    }

    fn accept_picker(&mut self, picker: ratatui_image::picker::Picker) {
        let cell_h = picker.font_size().height;
        if cell_h > 0 {
            self.state.poster_rows = (96_u16.div_ceil(cell_h)).max(3);
        }

        self.state.image_picker = Some(picker);
        self.state.image_supported = true;
    }

    async fn query_picker(&self) -> Option<ratatui_image::picker::Picker> {
        if !crate::tui::terminal::should_query_images() {
            return None;
        }
        tokio::task::spawn_blocking(|| {
            let options = ratatui_image::picker::cap_parser::QueryStdioOptions {
                timeout: Duration::from_millis(400),
                terminal_background_color_osc: true,
                ..Default::default()
            };
            ratatui_image::picker::Picker::from_query_stdio_with_options(options).ok()
        })
        .await
        .unwrap_or_default()
    }

    fn forced_protocol() -> Option<ForcedProtocol> {
        match std::env::var("MOVIEBOX_IMAGE_PROTOCOL")
            .unwrap_or_default()
            .to_ascii_lowercase()
            .as_str()
        {
            "none" | "off" | "false" => Some(ForcedProtocol::None),

            "sixel" => Some(ForcedProtocol::Type(
                ratatui_image::picker::ProtocolType::Sixel,
            )),
            "kitty" => Some(ForcedProtocol::Type(
                ratatui_image::picker::ProtocolType::Kitty,
            )),
            "iterm2" => Some(ForcedProtocol::Type(
                ratatui_image::picker::ProtocolType::Iterm2,
            )),
            _ => None,
        }
    }

    fn cell_size_override() -> Option<ratatui_image::FontSize> {
        let raw = std::env::var("MOVIEBOX_CELL_SIZE").ok()?;
        let raw = raw.trim().to_ascii_lowercase();
        let (width, height) = raw.split_once(['x', '*'])?;
        let width: u16 = width.trim().parse().ok()?;
        let height: u16 = height.trim().parse().ok()?;
        if width == 0 || height == 0 {
            return None;
        }
        Some(ratatui_image::FontSize { width, height })
    }

    fn create_picker_with_font_size(
        font_size: Option<ratatui_image::FontSize>,
        protocol: ratatui_image::picker::ProtocolType,
    ) -> ratatui_image::picker::Picker {
        let mut picker = match font_size {
            Some(size) =>
            {
                #[allow(deprecated)]
                ratatui_image::picker::Picker::from_fontsize(size)
            }
            None => ratatui_image::picker::Picker::halfblocks(),
        };
        picker.set_protocol_type(protocol);
        picker
    }
    pub fn contextual_title(&self) -> String {
        match self.state.active_screen {
            Screen::Home => match self.state.mode() {
                crate::tui::state::AppMode::Streaming => {
                    if self.state.active_provider == crate::providers::models::ProviderKind::Addons
                    {
                        "MovieBox-Tui — Addons".to_string()
                    } else {
                        "MovieBox-Tui — Streaming".to_string()
                    }
                }
                crate::tui::state::AppMode::Tv => "MovieBox-Tui — Live TV".to_string(),
            },
            Screen::Details => {
                if let Some(details) = &self.state.selected_details {
                    let clean = crate::providers::moviebox::clean_moviebox_title(&details.title);
                    if !clean.is_empty() {
                        return format!("MovieBox-Tui — {clean}");
                    }
                }
                "MovieBox-Tui — Details".to_string()
            }
        }
    }

    pub async fn handle_action(&mut self, action: Action) -> Option<()> {
        if self.state.last_resize_time.is_some()
            || !matches!(action, Action::Tick | Action::UpdateDownload(..))
        {
            self.state.dirty = true;
        }
        match action {
            Action::Quit => {
                self.request_tasks.cancel_all();
                self.state
                    .cancel_download
                    .store(true, std::sync::atomic::Ordering::SeqCst);
                self.state
                    .fetch_cancel
                    .store(true, std::sync::atomic::Ordering::SeqCst);
                return Some(());
            }

            Action::Key(key) => {
                self.handle_key(key).await;
            }

            Action::MouseClick(col, row) => {
                self.handle_mouse(col, row);
            }

            Action::WheelScroll { up } => {
                if self.state.show_help {
                    let delta = 3 * if up { -1i32 } else { 1 };
                    self.state.help_scroll =
                        (self.state.help_scroll as i32 + delta).max(0) as usize;
                    return None;
                }
                let steps = if self.state.active_screen == Screen::Home
                    && !self.state.favorites_focus
                    && !self.state.search_results.is_empty()
                    && self.state.input_mode != InputMode::Editing
                {
                    self.state.effective_row_height().min(8)
                } else {
                    2
                };
                let step = if up { Action::MoveUp } else { Action::MoveDown };
                for _ in 0..steps {
                    let action = step.clone();
                    if let Some(quit) = self.handle_navigation(action).await {
                        return Some(quit);
                    }
                }
            }

            Action::Tick
            | Action::FocusChange
            | Action::Resize(..)
            | Action::SwitchProvider(..)
            | Action::ToggleHelp
            | Action::Refresh
            | Action::ClearCache
            | Action::CacheCleared(..)
            | Action::ToggleThemePopup
            | Action::SelectTheme(..)
            | Action::ShowBrowseMenu
            | Action::SetStatus(..)
            | Action::CheckForUpdates
            | Action::UpdateAvailable(..)
            | Action::StartSelfUpdate
            | Action::SelfUpdateProgress(..)
            | Action::SelfUpdateComplete(..)
            | Action::ToggleSettingsPopup
            | Action::SelectSettingsCategory(..)
            | Action::SettingsAdjustValue(..)
            | Action::SettingsActivateRow
            | Action::SettingsResetDownloadDir
            | Action::ToggleProvider(..)
            | Action::CheckBdixNetwork
            | Action::BdixProbeResult { .. } => {
                self.handle_system(action).await;
            }

            Action::SwitchToTvMode
            | Action::ShowTvConfig
            | Action::TvPlaylistAdd(..)
            | Action::TvPlaylistRemove(..)
            | Action::TvReloadPlaylists
            | Action::TvInputToggle(..)
            | Action::TvChannelsLoaded(..) => {
                self.handle_tv(action).await;
            }

            Action::SwitchToStreamingMode
            | Action::ShowAddonManager
            | Action::AddonAddManifest(..)
            | Action::AddonToggleEnabled(..)
            | Action::AddonRemove(..)
            | Action::AddonInputToggle(..) => {
                self.handle_addons(action).await;
            }

            Action::MoveUp
            | Action::MoveDown
            | Action::MoveLeft
            | Action::MoveRight
            | Action::Submit
            | Action::GoBack
            | Action::TabPane
            | Action::BackTabPane
            | Action::SelectLanguage(..) => {
                self.handle_navigation(action).await;
            }

            Action::Suggest(..)
            | Action::SuggestSuccess(..)
            | Action::SelectSuggestion { .. }
            | Action::Search { .. }
            | Action::FetchHomepage { .. }
            | Action::SelectBrowse(..)
            | Action::SelectAddonCatalog(..)
            | Action::SearchSuccess { .. }
            | Action::SearchFailure(..)
            | Action::HomepageSuccess { .. }
            | Action::HomepageFailure(..)
            | Action::FetchDetails(..)
            | Action::DetailsSuccess(..)
            | Action::DetailsFailure(..)
            | Action::FetchPreview(..)
            | Action::PreviewSuccess(..)
            | Action::PreviewFailure(..)
            | Action::FetchEpisodeStreams { .. }
            | Action::EpisodeStreamsReady(..)
            | Action::EpisodeStreamsFailed(..)
            | Action::InitStreamPool(..)
            | Action::StreamPoolInitialized(..)
            | Action::PosterSuccess(..)
            | Action::SearchPosterLoaded(..) => {
                self.handle_requests(action).await;
            }

            Action::PlayStream
            | Action::ShowSubtitlePopup(..)
            | Action::ShowDownloadSubtitlePopup(..)
            | Action::LaunchPlayback(..)
            | Action::DispatchPlayback(..)
            | Action::MarkWatched(..)
            | Action::UpdateProgress { .. }
            | Action::ReconcileHistory
            | Action::PlayerCrashed(..)
            | Action::PlayerExited => {
                self.handle_playback(action).await;
            }

            Action::ToggleFavorite
            | Action::ShowFavorites
            | Action::OpenFavorite(..)
            | Action::OpenContinueWatching(..) => {
                self.handle_favorites(action).await;
            }

            Action::DownloadStream(..)
            | Action::StartDownload(..)
            | Action::DownloadEpisode
            | Action::DownloadSeason
            | Action::ProcessDownloadQueue
            | Action::UpdateDownload(..)
            | Action::DownloadCompleted(..)
            | Action::DownloadFailed(..)
            | Action::DownloadPaused(..)
            | Action::ClearDownload
            | Action::CancelDownload => {
                self.handle_download(action).await;
            }
        }
        None
    }

    pub fn draw(&mut self, frame: &mut Frame) {
        let area = frame.area();

        if self.draw_resize_badge(frame, area) {
            return;
        }

        if self.draw_too_small_gate(frame, area) {
            return;
        }

        let mut main_area = frame.area();
        let mut download_area = None;

        if self.state.download_progress.is_some() {
            let [m, d] = Self::split_main_and_download(main_area);
            main_area = m;
            download_area = Some(d);
        }

        match self.state.active_screen {
            Screen::Home => {
                crate::tui::screens::home::draw(frame, main_area, &mut self.state, &self.theme);
            }
            Screen::Details => {
                crate::tui::screens::details::draw(frame, main_area, &mut self.state, &self.theme);
            }
        }

        if self.state.show_help {
            crate::tui::screens::help::draw(frame, main_area, &self.state, &self.theme);
        }

        self.draw_download_gauge(frame, download_area);

        self.draw_settings_modal(frame, area);
        self.draw_sources_picker(frame, area);
        self.draw_theme_picker(frame, area);
        self.draw_player_picker(frame, area);
        self.draw_subtitle_picker(frame, area);
        self.draw_update_modal(frame, area);
        self.draw_updating_modal(frame, area);
        crate::tui::overlay::notifications(
            frame,
            area,
            &self.state.notifications,
            &self.theme,
            self.state.basic_terminal,
            self.state.download_progress.is_some(),
        );
    }

    pub fn split_main_and_download(area: ratatui::layout::Rect) -> [ratatui::layout::Rect; 2] {
        use ratatui::layout::{Constraint, Direction, Layout};
        let chunks = Layout::default()
            .direction(Direction::Vertical)
            .constraints([Constraint::Min(0), Constraint::Length(3)])
            .split(area);
        [chunks[0], chunks[1]]
    }

    fn draw_resize_badge(&self, frame: &mut Frame, area: Rect) -> bool {
        if let Some((_, w, h)) = self.state.last_resize_time {
            let sep = if self.state.basic_terminal { "x" } else { "×" };
            let label = format!("{} {} {}", w, sep, h);
            let label_len = label.chars().count() as u16 + 4;
            let badge_w = label_len.min(area.width);
            let badge_h = 1_u16;
            let badge_x = area.x + (area.width.saturating_sub(badge_w)) / 2;
            let badge_y = area.y + (area.height.saturating_sub(badge_h)) / 2;
            let badge_area = ratatui::layout::Rect {
                x: badge_x,
                y: badge_y,
                width: badge_w,
                height: badge_h,
            };
            let line = ratatui::text::Line::from(vec![ratatui::text::Span::styled(
                label,
                self.theme.title,
            )]);
            frame.render_widget(
                ratatui::widgets::Paragraph::new(line)
                    .alignment(ratatui::layout::Alignment::Center),
                badge_area,
            );
            true
        } else {
            false
        }
    }

    fn draw_too_small_gate(&self, frame: &mut Frame, area: Rect) -> bool {
        if area.width < 50 || area.height < 14 {
            use ratatui::layout::Alignment;
            use ratatui::text::Line;
            use ratatui::widgets::{Block, Borders, Paragraph};

            if area.width < 4 || area.height < 2 {
                return true;
            }

            if area.width < 25 || area.height < 5 {
                let p = Paragraph::new(format!("{}×{} (min 50×14)", area.width, area.height))
                    .style(self.theme.lavender)
                    .alignment(Alignment::Center);
                frame.render_widget(p, area);
                return true;
            }

            let msg_lines = vec![
                Line::from(format!(
                    "Terminal too small ({}×{}).",
                    area.width, area.height
                )),
                Line::from("Minimum required size: 50×14"),
                Line::from("Enlarge terminal window."),
            ];

            let padding_top = area.height.saturating_sub(2).saturating_sub(3) / 2;
            let mut msg = Vec::new();
            for _ in 0..padding_top {
                msg.push(Line::from(""));
            }
            msg.extend(msg_lines);

            let p = Paragraph::new(msg)
                .block(
                    Block::default()
                        .borders(Borders::ALL)
                        .border_style(self.theme.border),
                )
                .alignment(Alignment::Center);

            frame.render_widget(p, area);
            true
        } else {
            false
        }
    }

    fn draw_download_gauge(&self, frame: &mut Frame, download_area: Option<Rect>) {
        let Some(prog) = self.state.download_progress else {
            return;
        };
        let Some(dl_area) = download_area else {
            return;
        };
        if dl_area.width < 16 || dl_area.height < 3 {
            return;
        }

        use ratatui::layout::Alignment;
        use ratatui::style::Modifier;
        use ratatui::text::{Line, Span};
        use ratatui::widgets::{Block, Borders, Paragraph};

        let is_compact = dl_area.width < 60;
        let basic = self.state.basic_terminal;
        let modal_active = self.state.has_active_modal();
        let cancel_label = if is_compact { "[x]" } else { "[x] Cancel" };

        let mut left_title_spans = Vec::new();
        let prefix_style = if modal_active {
            self.theme.muted
        } else {
            self.theme.teal.add_modifier(Modifier::BOLD)
        };
        if basic {
            left_title_spans.push(Span::styled(" [DL] ", prefix_style));
        } else {
            left_title_spans.push(Span::styled(" ⬇ Downloading ", prefix_style));
        }

        if self.state.download_queue_total > 0 {
            let total = self.state.download_queue_total;
            let remaining = self.state.download_queue.len();
            let current = total.saturating_sub(remaining);
            let queue_str = format!(
                "S{:02}E{:02} ({}/{}): ",
                self.state.selected_season, self.state.selected_episode, current, total
            );
            left_title_spans.push(Span::styled(
                queue_str,
                if modal_active {
                    self.theme.muted
                } else {
                    self.theme.sapphire
                },
            ));
        }

        let left_title = Line::from(left_title_spans);
        let right_title = Line::from(vec![Span::styled(
            format!(" {cancel_label} "),
            if modal_active {
                self.theme.muted
            } else {
                self.theme.error.add_modifier(Modifier::BOLD)
            },
        )])
        .alignment(Alignment::Right);

        let block = Block::default()
            .borders(Borders::ALL)
            .title(left_title)
            .title(right_title)
            .border_style(if modal_active {
                self.theme.muted
            } else {
                self.theme.lavender
            })
            .border_type(crate::tui::overlay::border_type(basic));
        let inner_area =
            crate::tui::overlay::render_modal_frame(frame, dl_area, block, &self.theme);

        if inner_area.height == 0 || inner_area.width < 10 {
            return;
        }

        let status_str = self
            .state
            .download_status
            .as_deref()
            .unwrap_or("Downloading...");

        let pct_val = prog.clamp(0.0, 100.0);
        let pct_badge = format!(" {:>5.1}% ", pct_val);
        let pct_width = 8usize;

        let available_for_rest = (inner_area.width as usize).saturating_sub(pct_width + 1);

        let bar_width = if available_for_rest < 20 {
            10usize.min(available_for_rest)
        } else {
            (available_for_rest / 2).clamp(12, 38)
        };

        let track_cells = bar_width.saturating_sub(2);
        let ratio = (pct_val / 100.0).clamp(0.0, 1.0);
        let filled_cells = ((track_cells as f64) * ratio).round() as usize;
        let unfilled_cells = track_cells.saturating_sub(filled_cells);

        let mut row_spans = Vec::new();
        row_spans.push(Span::styled(
            pct_badge,
            if modal_active {
                self.theme.muted
            } else {
                self.theme.sapphire.add_modifier(Modifier::BOLD)
            },
        ));

        row_spans.push(Span::styled(
            "[",
            if modal_active {
                self.theme.muted
            } else {
                self.theme.surface1
            },
        ));
        if basic {
            if filled_cells > 0 && unfilled_cells > 0 {
                row_spans.push(Span::styled(
                    "=".repeat(filled_cells.saturating_sub(1)),
                    if modal_active {
                        self.theme.muted
                    } else {
                        self.theme.accent.add_modifier(Modifier::BOLD)
                    },
                ));
                row_spans.push(Span::styled(
                    ">",
                    if modal_active {
                        self.theme.muted
                    } else {
                        self.theme.accent.add_modifier(Modifier::BOLD)
                    },
                ));
            } else {
                row_spans.push(Span::styled(
                    "=".repeat(filled_cells),
                    if modal_active {
                        self.theme.muted
                    } else {
                        self.theme.accent.add_modifier(Modifier::BOLD)
                    },
                ));
            }
            row_spans.push(Span::styled(
                "-".repeat(unfilled_cells),
                if modal_active {
                    self.theme.muted
                } else {
                    self.theme.surface1
                },
            ));
        } else {
            row_spans.push(Span::styled(
                "━".repeat(filled_cells),
                if modal_active {
                    self.theme.muted
                } else {
                    self.theme.teal.add_modifier(Modifier::BOLD)
                },
            ));
            row_spans.push(Span::styled(
                "─".repeat(unfilled_cells),
                if modal_active {
                    self.theme.muted
                } else {
                    self.theme.surface1
                },
            ));
        }
        row_spans.push(Span::styled(
            "]  ",
            if modal_active {
                self.theme.muted
            } else {
                self.theme.surface1
            },
        ));

        let status_budget = available_for_rest.saturating_sub(bar_width + 2);
        if status_budget >= 6 {
            let truncated_status = crate::tui::text::truncate_width(status_str, status_budget);
            if truncated_status.contains(" | ") {
                let parts: Vec<&str> = truncated_status.split(" | ").collect();
                let mut size_part = None;
                let mut speed_part = None;
                let mut eta_part = None;
                let mut extra_parts = Vec::new();

                for part in parts {
                    let p = part.trim();
                    if p.starts_with("ETA") {
                        eta_part = Some(p);
                    } else if p.contains("/s") {
                        speed_part = Some(p);
                    } else if p.ends_with("B")
                        || p.ends_with("MB")
                        || p.ends_with("GB")
                        || p.ends_with("MiB")
                        || p.ends_with("GiB")
                        || p.ends_with("KB")
                        || p.ends_with("KiB")
                    {
                        if size_part.is_none() {
                            size_part = Some(p);
                        } else {
                            extra_parts.push(p);
                        }
                    } else {
                        extra_parts.push(p);
                    }
                }

                if let Some(size) = size_part {
                    row_spans.push(Span::styled(
                        size.to_string(),
                        if modal_active {
                            self.theme.muted
                        } else {
                            self.theme.text
                        },
                    ));
                }

                if speed_part.is_some() || eta_part.is_some() {
                    if size_part.is_some() {
                        row_spans.push(Span::raw("    "));
                    }
                    if let Some(speed) = speed_part {
                        row_spans.push(Span::styled(
                            speed.to_string(),
                            if modal_active {
                                self.theme.muted
                            } else {
                                self.theme.teal.add_modifier(Modifier::BOLD)
                            },
                        ));
                    }
                    if let Some(eta) = eta_part {
                        if speed_part.is_some() {
                            row_spans.push(Span::styled(
                                " ~ ",
                                if modal_active {
                                    self.theme.muted
                                } else {
                                    self.theme.surface1
                                },
                            ));
                        }
                        let eta_clean = eta.strip_prefix("ETA").unwrap_or(eta).trim();
                        let eta_display =
                            if eta_clean.ends_with("left") || eta_clean.ends_with("remaining") {
                                eta_clean.to_string()
                            } else {
                                format!("{eta_clean} left")
                            };
                        row_spans.push(Span::styled(
                            eta_display,
                            if modal_active {
                                self.theme.muted
                            } else {
                                self.theme.rating
                            },
                        ));
                    }
                }

                for extra in extra_parts {
                    row_spans.push(Span::raw("   "));
                    row_spans.push(Span::styled(
                        extra.to_string(),
                        if modal_active {
                            self.theme.muted
                        } else {
                            self.theme.subtext1
                        },
                    ));
                }
            } else {
                row_spans.push(Span::styled(
                    truncated_status,
                    if modal_active {
                        self.theme.muted
                    } else {
                        self.theme.subtext1
                    },
                ));
            }
        }
        frame.render_widget(Paragraph::new(Line::from(row_spans)), inner_area);
    }

    fn draw_theme_picker(&mut self, frame: &mut Frame, area: Rect) {
        if self.state.show_theme_popup {
            use ratatui::text::{Line, Span};

            let theme_names = crate::tui::theme::AVAILABLE_THEMES;
            let longest_name = theme_names
                .iter()
                .map(|name| crate::tui::text::width(name))
                .max()
                .unwrap_or(10);
            let raw_items: Vec<String> = theme_names
                .iter()
                .map(|name| {
                    if self.state.basic_terminal {
                        format!("  {name:<pad$}   * * *  ", pad = longest_name)
                    } else {
                        format!("  {name:<pad$}   ■ ■ ■  ", pad = longest_name)
                    }
                })
                .collect();

            let lines: Vec<Line<'static>> = theme_names
                .iter()
                .map(|name| {
                    let mut spans = vec![
                        Span::raw("  "),
                        Span::styled(format!("{name:<pad$}", pad = longest_name), self.theme.text),
                        Span::raw("   "),
                    ];
                    spans.extend(crate::tui::theme::Theme::palette_swatch_spans(
                        name,
                        self.state.basic_terminal,
                    ));
                    spans.push(Span::raw("  "));
                    Line::from(spans)
                })
                .collect();

            let popup = if self.state.show_settings_popup {
                crate::tui::overlay::settings_picker_layout(
                    area,
                    self.state.settings_category,
                    &raw_items,
                    16,
                )
            } else {
                crate::tui::overlay::picker_layout(area, &raw_items, "Apply", 16)
            };

            crate::tui::overlay::picker_with_lines_at(
                frame,
                area,
                popup,
                &lines,
                &raw_items,
                &mut self.state.theme_list_state,
                crate::tui::overlay::PickerSpec {
                    title: "",
                    confirm_label: "Apply",
                    minimum_width: 16,
                    show_counter: false,
                },
                &self.theme,
                self.state.basic_terminal,
            );
        }
    }
    fn draw_settings_modal(&mut self, frame: &mut Frame, area: Rect) {
        if self.state.show_settings_popup {
            crate::tui::widgets::settings::draw(frame, area, &mut self.state, &self.theme);
        }
    }
    fn draw_sources_picker(&mut self, frame: &mut Frame, area: Rect) {
        if self.state.show_sources_popup {
            let providers = crate::providers::models::ProviderKind::ENABLED;
            let raw_items: Vec<String> = providers
                .iter()
                .map(|p| format!("  [✓] {}  ", p.label()))
                .collect();
            let lines: Vec<ratatui::text::Line<'static>> = providers
                .iter()
                .map(|p| {
                    let is_enabled = self.state.provider_enabled(*p);
                    let (check, check_style) = if is_enabled {
                        if self.state.basic_terminal {
                            (
                                "[X] ",
                                self.theme
                                    .success
                                    .add_modifier(ratatui::style::Modifier::BOLD),
                            )
                        } else {
                            (
                                "[✓] ",
                                self.theme
                                    .success
                                    .add_modifier(ratatui::style::Modifier::BOLD),
                            )
                        }
                    } else {
                        ("[ ] ", self.theme.text_dim)
                    };
                    let label_style = if is_enabled {
                        self.theme.text
                    } else {
                        self.theme.text_dim
                    };
                    ratatui::text::Line::from(vec![
                        ratatui::text::Span::raw("  "),
                        ratatui::text::Span::styled(check, check_style),
                        ratatui::text::Span::styled(p.label(), label_style),
                        ratatui::text::Span::raw("  "),
                    ])
                })
                .collect();

            let popup = crate::tui::overlay::settings_picker_layout(
                area,
                self.state.settings_category,
                &raw_items,
                20,
            );
            crate::tui::overlay::picker_with_lines_at(
                frame,
                area,
                popup,
                &lines,
                &raw_items,
                &mut self.state.sources_list_state,
                crate::tui::overlay::PickerSpec {
                    title: "",
                    confirm_label: "Toggle",
                    minimum_width: 20,
                    show_counter: false,
                },
                &self.theme,
                self.state.basic_terminal,
            );
        }
    }
    fn draw_player_picker(&mut self, frame: &mut Frame, area: Rect) {
        if self.state.player_picker_popup {
            let raw_items = self
                .state
                .available_players
                .iter()
                .map(|k| k.label().to_string())
                .collect::<Vec<_>>();
            let confirm_label = if self.state.settings_player_picker {
                "Select"
            } else {
                "Play"
            };
            let popup = if self.state.settings_player_picker {
                crate::tui::overlay::settings_picker_layout(
                    area,
                    self.state.settings_category,
                    &raw_items,
                    10,
                )
            } else {
                crate::tui::overlay::picker_layout(area, &raw_items, confirm_label, 10)
            };
            crate::tui::overlay::picker_at(
                frame,
                area,
                popup,
                &raw_items,
                &mut self.state.player_picker_state,
                crate::tui::overlay::PickerSpec {
                    title: "",
                    confirm_label,
                    minimum_width: 10,
                    show_counter: false,
                },
                &self.theme,
                self.state.basic_terminal,
            );
        }
    }
    fn draw_subtitle_picker(&mut self, frame: &mut Frame, area: Rect) {
        if self.state.subtitle_popup || self.state.is_download_subtitle_popup {
            let items = self
                .state
                .subtitle_list
                .iter()
                .map(|(name, _)| crate::tui::text::format_subtitle_label(name))
                .collect::<Vec<_>>();
            let confirm_label = if self.state.is_download_subtitle_popup {
                "Download"
            } else {
                "Use"
            };
            crate::tui::overlay::picker(
                frame,
                area,
                &items,
                &mut self.state.subtitle_list_state,
                crate::tui::overlay::PickerSpec {
                    title: "Subtitles",
                    confirm_label,
                    minimum_width: 20,
                    show_counter: true,
                },
                &self.theme,
                self.state.basic_terminal,
            );
        }
    }

    fn draw_update_modal(&self, frame: &mut Frame, area: Rect) {
        if self.state.input_mode == crate::tui::state::InputMode::Editing {
            return;
        }

        if let Some((version, notes)) = &self.state.update_available {
            use ratatui::text::{Line, Span};
            use ratatui::widgets::Paragraph;

            let env = std::env::current_exe()
                .ok()
                .map(|p| crate::updater::apply::detect_environment(&p))
                .unwrap_or(crate::updater::apply::InstallationEnvironment::DirectReplace);

            let layout = crate::tui::overlay::update_modal_layout_with_env(
                area,
                notes,
                env.has_managed_notice(),
            );
            let popup_area = layout.popup_area;
            let display_count = layout.display_count;
            let _ = layout.has_more;

            let note_lines: Vec<&str> = notes
                .lines()
                .map(|l| l.trim())
                .filter(|l| !l.is_empty())
                .filter(|l| {
                    let lower = l.to_ascii_lowercase();
                    !lower.contains("read full changelog")
                        && !lower.contains("press [o]")
                        && !lower.contains("press o to")
                })
                .collect();

            let title_str = format!("Update Available: v{version}");
            let is_compact_modal = popup_area.width < 50;
            let buttons = match env {
                crate::updater::apply::InstallationEnvironment::Homebrew => {
                    if is_compact_modal {
                        vec![
                            Span::styled("[b]", self.theme.shortcut),
                            Span::styled(" Copy ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    } else {
                        vec![
                            Span::styled("[b]", self.theme.shortcut),
                            Span::styled(" Copy Command ──── ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    }
                }
                crate::updater::apply::InstallationEnvironment::Scoop => {
                    if is_compact_modal {
                        vec![
                            Span::styled("[s]", self.theme.shortcut),
                            Span::styled(" Copy ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    } else {
                        vec![
                            Span::styled("[s]", self.theme.shortcut),
                            Span::styled(" Copy Command ──── ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    }
                }
                crate::updater::apply::InstallationEnvironment::Termux
                | crate::updater::apply::InstallationEnvironment::Flatpak
                | crate::updater::apply::InstallationEnvironment::Snap
                | crate::updater::apply::InstallationEnvironment::ReadOnly => vec![
                    Span::styled("[o]", self.theme.shortcut),
                    Span::styled(" Open GitHub", self.theme.text),
                ],
                crate::updater::apply::InstallationEnvironment::DirectReplace
                | crate::updater::apply::InstallationEnvironment::WindowsHelper => {
                    if is_compact_modal {
                        vec![
                            Span::styled("[u]", self.theme.shortcut),
                            Span::styled(" Update ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    } else {
                        vec![
                            Span::styled("[u]", self.theme.shortcut),
                            Span::styled(" Update ──── ", self.theme.text),
                            Span::styled("[o]", self.theme.shortcut),
                            Span::styled(" GitHub", self.theme.text),
                        ]
                    }
                }
            };

            let inner_area = crate::tui::widgets::ModalFrame::new(
                &title_str,
                &self.theme,
                self.state.basic_terminal,
            )
            .title_bottom(Line::from(buttons))
            .render(frame, popup_area, area);

            let mut text = vec![Line::from("")];
            match env {
                crate::updater::apply::InstallationEnvironment::Homebrew => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled("Homebrew Managed • Run: ", self.theme.text_dim),
                        Span::styled(
                            "brew upgrade moviebox-tui",
                            self.theme
                                .shortcut
                                .add_modifier(ratatui::style::Modifier::BOLD),
                        ),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::Scoop => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled("Scoop Managed • Run: ", self.theme.text_dim),
                        Span::styled(
                            "scoop update moviebox-tui",
                            self.theme
                                .shortcut
                                .add_modifier(ratatui::style::Modifier::BOLD),
                        ),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::Termux => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled(
                            "Termux / Android • Re-run installer script to update",
                            self.theme.accent,
                        ),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::Flatpak => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled("Flatpak sandbox • Run: flatpak update", self.theme.accent),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::Snap => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled(
                            "Snap sandbox • Run: sudo snap refresh moviebox-tui",
                            self.theme.accent,
                        ),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::ReadOnly => {
                    text.push(Line::from(vec![
                        Span::raw("  "),
                        Span::styled(
                            "Binary is read-only • Update via package manager",
                            self.theme.accent,
                        ),
                    ]));
                    text.push(Line::from(""));
                }
                crate::updater::apply::InstallationEnvironment::DirectReplace
                | crate::updater::apply::InstallationEnvironment::WindowsHelper => {}
            }

            let mut current_category = "Added";
            let mut rendered_bullets = 0;

            for line in &note_lines {
                let trimmed = line.trim();
                if trimmed.starts_with("### ")
                    || trimmed.starts_with("## ")
                    || trimmed.starts_with("# ")
                {
                    let title = trimmed.trim_start_matches('#').trim();
                    if title.eq_ignore_ascii_case("Fixed") || title.eq_ignore_ascii_case("Fixes") {
                        current_category = "Fixed";
                    } else if title.eq_ignore_ascii_case("Added")
                        || title.eq_ignore_ascii_case("Features")
                        || title.eq_ignore_ascii_case("New Features")
                    {
                        current_category = "Added";
                    } else if title.eq_ignore_ascii_case("Changed") {
                        current_category = "Changed";
                    } else if title.eq_ignore_ascii_case("Performance")
                        || title.eq_ignore_ascii_case("Perf")
                    {
                        current_category = "Perf";
                    } else {
                        current_category = title;
                    }
                    continue;
                }

                if trimmed.starts_with("- ") || trimmed.starts_with("* ") {
                    if rendered_bullets >= display_count {
                        break;
                    }
                    rendered_bullets += 1;
                    let bullet = trimmed[2..].trim();
                    let mut spans = vec![Span::raw("  ")];

                    let (badge_style, badge_text) = match current_category {
                        "Fixed" => (
                            self.theme
                                .rating
                                .add_modifier(ratatui::style::Modifier::BOLD),
                            "[Fixed] ",
                        ),
                        "Changed" => (
                            self.theme
                                .sapphire
                                .add_modifier(ratatui::style::Modifier::BOLD),
                            "[Changed] ",
                        ),
                        "Perf" => (
                            self.theme
                                .accent
                                .add_modifier(ratatui::style::Modifier::BOLD),
                            "[Perf] ",
                        ),
                        _ => (
                            self.theme.teal.add_modifier(ratatui::style::Modifier::BOLD),
                            "[Added] ",
                        ),
                    };
                    spans.push(Span::styled(badge_text, badge_style));

                    if let Some(rest) = bullet.strip_prefix("**") {
                        if let Some(end) = rest.find("**") {
                            let title = &rest[..end];
                            let after = &rest[end + 2..];
                            let (colon, rest) = if let Some(stripped) = after.strip_prefix(':') {
                                (": ", stripped.trim())
                            } else {
                                ("", after.trim())
                            };
                            let clean_rest = rest.replace('`', "");
                            spans.push(Span::styled(
                                title,
                                self.theme.text.add_modifier(ratatui::style::Modifier::BOLD),
                            ));
                            if !colon.is_empty() {
                                spans.push(Span::styled(colon, self.theme.subtext1));
                            }
                            if !clean_rest.is_empty() {
                                let prefix_w = 2
                                    + badge_text.len()
                                    + crate::tui::text::width(title)
                                    + colon.len();
                                let budget =
                                    (inner_area.width as usize).saturating_sub(prefix_w + 2);
                                if budget > 0 {
                                    spans.push(Span::styled(
                                        crate::tui::text::truncate_width(&clean_rest, budget)
                                            .into_owned(),
                                        self.theme.text_dim,
                                    ));
                                }
                            }
                        } else {
                            let clean = bullet.replace('`', "");
                            let budget = (inner_area.width as usize)
                                .saturating_sub(2 + badge_text.len() + 2);
                            spans.push(Span::styled(
                                crate::tui::text::truncate_width(&clean, budget).into_owned(),
                                self.theme.text,
                            ));
                        }
                    } else {
                        let clean = bullet.replace('`', "");
                        let budget =
                            (inner_area.width as usize).saturating_sub(2 + badge_text.len() + 2);
                        spans.push(Span::styled(
                            crate::tui::text::truncate_width(&clean, budget).into_owned(),
                            self.theme.text,
                        ));
                    }
                    text.push(Line::from(spans));
                }
            }

            if rendered_bullets == 0 {
                text.push(Line::from(vec![
                    Span::raw("  "),
                    Span::styled("No release highlights provided.", self.theme.text_dim),
                ]));
            }
            text.push(Line::from(""));

            let popup = Paragraph::new(text);
            frame.render_widget(popup, inner_area);
        }
    }

    fn draw_updating_modal(&self, frame: &mut Frame, area: Rect) {
        if !self.state.is_updating {
            return;
        }

        use ratatui::layout::Alignment;
        use ratatui::text::{Line, Span};
        use ratatui::widgets::Paragraph;

        let width = 42.min(area.width.saturating_sub(4)).max(32);
        let height = 5.min(area.height.saturating_sub(2)).max(3);
        let x = area.x + area.width.saturating_sub(width) / 2;
        let search_y = crate::tui::overlay::home_search_y(area);
        let y = search_y.min(area.bottom().saturating_sub(height));
        let popup_area = ratatui::layout::Rect::new(x, y, width, height);

        let target_version = self
            .state
            .update_release
            .as_ref()
            .map(|r| r.version.as_str())
            .unwrap_or("latest");
        let title_str = format!("Updating: v{target_version}");

        let inner_area = crate::tui::widgets::ModalFrame::new(
            &title_str,
            &self.theme,
            self.state.basic_terminal,
        )
        .render(frame, popup_area, area);

        let spinner =
            crate::tui::widgets::loading_spinner(self.state.tick_count, self.state.basic_terminal);

        let progress_msg = self
            .state
            .update_progress_msg
            .as_deref()
            .unwrap_or("Applying update...");

        let action_text = if progress_msg.contains("SHA256") || progress_msg.contains("checksum") {
            "Verifying checksum"
        } else if progress_msg.contains("Extracting") || progress_msg.contains("Applying") {
            "Installing binary"
        } else {
            "Downloading release"
        };

        let text = vec![
            Line::from(""),
            Line::from(vec![
                Span::styled(
                    format!("{spinner} "),
                    self.theme
                        .accent
                        .add_modifier(ratatui::style::Modifier::BOLD),
                ),
                Span::styled(
                    action_text,
                    self.theme.text.add_modifier(ratatui::style::Modifier::BOLD),
                ),
            ])
            .alignment(Alignment::Center),
            Line::from(""),
        ];
        let popup = Paragraph::new(text);
        frame.render_widget(popup, inner_area);
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use ratatui::Terminal;
    use ratatui::backend::TestBackend;

    #[test]
    fn test_download_bar_rendering_modern_and_basic() {
        let backend = TestBackend::new(100, 24);
        let mut terminal = Terminal::new(backend).unwrap();
        let mut app = App::new();
        app.state.download_progress = Some(93.2);
        app.state.download_title = Some("Ek Deewane Ki Deewaniyat".to_string());
        app.state.download_status = Some("778.6 MB | 4.6 MB/s | ETA 00:12".to_string());
        app.state.basic_terminal = false;
        terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();

        let mut rendered = String::new();
        for y in 0..24 {
            for x in 0..100 {
                let cell = terminal.backend().buffer().cell((x, y)).unwrap();
                rendered.push_str(cell.symbol());
            }
            rendered.push('\n');
        }

        assert!(rendered.contains("Downloading"));
        assert!(!rendered.contains("Ek Deewane Ki Deewaniyat"));
        assert!(rendered.contains("[x] Cancel"));
        assert!(rendered.contains("93.2%"));
        assert!(rendered.contains("778.6 MB"));
        assert!(rendered.contains("4.6 MB/s"));
        assert!(rendered.contains("00:12 left"));

        app.state.basic_terminal = true;
        terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();

        let mut basic_rendered = String::new();
        for y in 0..24 {
            for x in 0..100 {
                let cell = terminal.backend().buffer().cell((x, y)).unwrap();
                basic_rendered.push_str(cell.symbol());
            }
            basic_rendered.push('\n');
        }

        assert!(basic_rendered.contains("[DL]"));
        assert!(basic_rendered.contains("===="));
        assert!(basic_rendered.contains("[x] Cancel"));

        let narrow_backend = TestBackend::new(45, 24);
        let mut narrow_terminal = Terminal::new(narrow_backend).unwrap();
        let res = narrow_terminal.draw(|f| {
            app.draw(f);
        });
        assert!(res.is_ok());
    }

    #[test]
    fn test_download_bar_dimmed_when_modal_active() {
        let backend = TestBackend::new(100, 24);
        let mut terminal = Terminal::new(backend).unwrap();
        let mut app = App::new();
        app.state.download_progress = Some(50.0);
        app.state.download_title = Some("Test Movie".to_string());
        app.state.show_settings_popup = true;

        let res = terminal.draw(|f| {
            app.draw(f);
        });
        assert!(res.is_ok());
    }

    #[test]
    fn test_update_modal_rendering_and_markdown_formatting() {
        let backend = TestBackend::new(100, 30);
        let mut terminal = Terminal::new(backend).unwrap();
        let mut app = App::new();
        let notes = "### Added\n- **Anchored Provider Selection Menu**: Replaced immediate mouse cycling\n- Added dedicated keyboard navigation\n### Fixed\n- **Stream Table Alignment**: Corrected column budget\n";
        app.state.update_available = Some(("0.1.18".to_string(), notes.to_string()));

        terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();

        let mut rendered = String::new();
        for y in 0..30 {
            for x in 0..100 {
                let cell = terminal.backend().buffer().cell((x, y)).unwrap();
                rendered.push_str(cell.symbol());
            }
            rendered.push('\n');
        }
        assert!(rendered.contains("Update Available: v0.1.18"));
        assert!(rendered.contains("v0.1.18"));
        assert!(!rendered.contains("▌"));
        assert!(rendered.contains("[Added]"));
        assert!(rendered.contains("[Fixed]"));
        assert!(rendered.contains("Anchored Provider Selection Menu:"));
        assert!(rendered.contains("Stream Table Alignment:"));
        assert!(!rendered.contains("**Anchored"));
        assert!(!rendered.contains("**Stream"));
        assert!(rendered.contains("[u]"));
        assert!(rendered.contains("[o]"));
    }

    #[test]
    fn test_updating_modal_pipeline_rendering_and_geometry() {
        let backend = TestBackend::new(100, 30);
        let mut terminal = Terminal::new(backend).unwrap();
        let mut app = App::new();
        app.state.is_updating = true;
        app.state.update_progress_msg =
            Some("Downloading MovieBox_macOS_Universal.tar.gz...".to_string());
        app.state.basic_terminal = false;

        terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();

        let mut rendered = String::new();
        for y in 0..30 {
            for x in 0..100 {
                let cell = terminal.backend().buffer().cell((x, y)).unwrap();
                rendered.push_str(cell.symbol());
            }
            rendered.push('\n');
        }

        assert!(rendered.contains("Updating: v"));
        assert!(rendered.contains("Downloading release"));
        assert!(!rendered.contains("⚠"));

        app.state.basic_terminal = true;
        app.state.update_progress_msg = Some("Applying update...".to_string());
        terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();

        let mut basic_rendered = String::new();
        for y in 0..30 {
            for x in 0..100 {
                let cell = terminal.backend().buffer().cell((x, y)).unwrap();
                basic_rendered.push_str(cell.symbol());
            }
            basic_rendered.push('\n');
        }
        assert!(basic_rendered.contains("Updating: v"));
        assert!(basic_rendered.contains("Installing binary"));
        assert!(!basic_rendered.contains("[!]"));

        let min_backend = TestBackend::new(50, 14);
        let mut min_terminal = Terminal::new(min_backend).unwrap();
        app.state.basic_terminal = false;
        app.state.update_progress_msg =
            Some("Downloading MovieBox_macOS_Universal.tar.gz...".to_string());
        min_terminal
            .draw(|f| {
                app.draw(f);
            })
            .unwrap();
        let mut min_rendered = String::new();
        for y in 0..14 {
            for x in 0..50 {
                let cell = min_terminal.backend().buffer().cell((x, y)).unwrap();
                min_rendered.push_str(cell.symbol());
            }
            min_rendered.push('\n');
        }
        assert!(min_rendered.contains("Updating: v"));
        assert!(min_rendered.contains("Downloading release"));
        assert!(!min_rendered.contains("Please wait"));
    }
}