Skip to content

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

78.1 KB
Raw Blame
use super::App;
use crate::tui::{
    action::Action,
    state::{InputMode, Screen},
};
use crossterm::event::KeyEvent;

impl App {
    pub(super) async fn handle_key(&mut self, key: KeyEvent) -> Option<()> {
        use crossterm::event::{KeyCode, KeyModifiers};

        if self.state.is_updating {
            return None;
        }
        if self.state.show_help {
            match key.code {
                KeyCode::Up => {
                    self.state.help_scroll = self.state.help_scroll.saturating_sub(1);
                }
                KeyCode::Down => {
                    self.state.help_scroll = self.state.help_scroll.saturating_add(1);
                }
                KeyCode::PageUp => {
                    let rows = crossterm::terminal::size().map(|(_, r)| r).unwrap_or(24);
                    let page_size = rows.saturating_sub(6).max(4) as usize;
                    self.state.help_scroll = self.state.help_scroll.saturating_sub(page_size);
                }
                KeyCode::PageDown => {
                    let rows = crossterm::terminal::size().map(|(_, r)| r).unwrap_or(24);
                    let page_size = rows.saturating_sub(6).max(4) as usize;
                    self.state.help_scroll = self.state.help_scroll.saturating_add(page_size);
                }
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('?') => {
                    self.state.show_help = false;
                    self.state.help_scroll = 0;
                }
                _ => {}
            }
            return None;
        }

        if key.modifiers.contains(KeyModifiers::CONTROL) {
            if let KeyCode::Char('c') = key.code {
                self.action_sender.send(Action::Quit).ok();
                return None;
            }
            if !self.state.has_active_modal() {
                if let KeyCode::Char('t') = key.code {
                    if !self.state.tv_enabled {
                        self.state
                            .set_status_short("TV Mode is disabled. Use /settings to enable.");
                    } else if self.state.is_tv_mode {
                        self.state.set_status_short("Already in TV Mode.");
                    } else {
                        self.action_sender.send(Action::SwitchToTvMode).ok();
                        self.state.set_status_short("Switched to TV Mode.");
                    }
                    return None;
                }
                if let KeyCode::Char('s') = key.code {
                    if !self.state.streaming_enabled {
                        self.state.set_status_short(
                            "Streaming Mode is disabled. Use /settings to enable.",
                        );
                    } else if !self.state.is_tv_mode
                        && self.state.active_provider
                            != crate::providers::models::ProviderKind::Addons
                    {
                        self.state.set_status_short("Already in Streaming Mode.");
                    } else {
                        self.action_sender.send(Action::SwitchToStreamingMode).ok();
                        self.state.set_status_short("Switched to Streaming Mode.");
                    }
                    return None;
                }
                if let KeyCode::Char('p') = key.code {
                    if !self.state.is_tv_mode {
                        self.cycle_provider();
                    }
                    return None;
                }
            }
        }

        if let KeyCode::Char('x') | KeyCode::Char('X') = key.code
            && self.state.download_progress.is_some()
            && self.state.input_mode != InputMode::Editing
            && !self.state.tv_input_active
            && !self.state.addon_input_active
            && !self.state.has_active_modal()
        {
            self.action_sender.send(Action::CancelDownload).ok();
            return None;
        }

        if self.state.input_mode != InputMode::Editing {
            if let Some((version, _)) = &self.state.update_available {
                let env = std::env::current_exe()
                    .as_deref()
                    .map(crate::updater::apply::detect_environment)
                    .unwrap_or(crate::updater::apply::InstallationEnvironment::DirectReplace);

                match key.code {
                    KeyCode::Char('u') | KeyCode::Char('U')
                        if matches!(
                            env,
                            crate::updater::apply::InstallationEnvironment::DirectReplace
                                | crate::updater::apply::InstallationEnvironment::WindowsHelper
                        ) =>
                    {
                        self.action_sender.send(Action::StartSelfUpdate).ok();
                        return None;
                    }
                    KeyCode::Char('b') | KeyCode::Char('B')
                        if env == crate::updater::apply::InstallationEnvironment::Homebrew =>
                    {
                        self.state.notify(
                            crate::tui::overlay::NotificationKind::Info,
                            "Homebrew Update",
                            "Installed via Homebrew.",
                        );
                        self.state.update_available = None;
                        return None;
                    }
                    KeyCode::Char('s') | KeyCode::Char('S')
                        if env == crate::updater::apply::InstallationEnvironment::Scoop =>
                    {
                        self.state.notify(
                            crate::tui::overlay::NotificationKind::Info,
                            "Scoop Update",
                            "Installed via Scoop.",
                        );
                        self.state.update_available = None;
                        return None;
                    }
                    KeyCode::Char('o') | KeyCode::Char('O') => {
                        let url = crate::updater::check::release_tag_url(version);
                        let _ = crate::net::open_external_url(&url);
                        self.state.update_available = None;
                        return None;
                    }
                    KeyCode::Esc => {
                        self.state.update_available = None;
                        return None;
                    }
                    _ => {}
                }
                return None;
            }
        }
        if self.state.show_provider_popup {
            let available = self.state.available_providers();
            let total_count = available.len();

            match key.code {
                KeyCode::Char('p') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                    self.state.show_provider_popup = false;
                    self.state.provider_list_state.select(None);
                    self.cycle_provider();
                }
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.state.show_provider_popup = false;
                    self.state.provider_list_state.select(None);
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.provider_list_state,
                        total_count,
                        false,
                    );
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.provider_list_state,
                        total_count,
                        true,
                    );
                }
                KeyCode::PageUp => {
                    let current = self.state.provider_list_state.selected().unwrap_or(0);
                    let next = if total_count == 0 {
                        0
                    } else if current < 5 {
                        total_count.saturating_sub(1)
                    } else {
                        current - 5
                    };
                    self.state.provider_list_state.select(Some(next));
                }
                KeyCode::PageDown => {
                    let current = self.state.provider_list_state.selected().unwrap_or(0);
                    let next = if total_count == 0 || current + 5 >= total_count {
                        0
                    } else {
                        current + 5
                    };
                    self.state.provider_list_state.select(Some(next));
                }
                KeyCode::Home => {
                    if total_count > 0 {
                        self.state.provider_list_state.select(Some(0));
                    }
                }
                KeyCode::End => {
                    if total_count > 0 {
                        self.state.provider_list_state.select(Some(total_count - 1));
                    }
                }
                KeyCode::Enter | KeyCode::Char(' ') => {
                    let index = self.state.provider_list_state.selected().unwrap_or(0);
                    if let Some(&provider) = available.get(index) {
                        self.switch_provider(provider);
                    }
                    self.state.show_provider_popup = false;
                    self.state.provider_list_state.select(None);
                }
                _ => {}
            }
            return None;
        }

        if self.state.show_browse_popup {
            let is_addon =
                self.state.active_provider == crate::providers::models::ProviderKind::Addons;
            let total_count = if is_addon {
                crate::providers::addons::models::curated_catalog_presets(
                    &self.state.installed_addons,
                )
                .len()
            } else {
                crate::tui::state::BrowsePreset::ALL.len()
            };

            match key.code {
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.state.show_browse_popup = false;
                    self.state.browse_list_state.select(None);
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.browse_list_state,
                        total_count,
                        false,
                    );
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.browse_list_state,
                        total_count,
                        true,
                    );
                }
                KeyCode::Home => {
                    if total_count > 0 {
                        self.state.browse_list_state.select(Some(0));
                    }
                }
                KeyCode::End => {
                    if total_count > 0 {
                        self.state.browse_list_state.select(Some(total_count - 1));
                    }
                }
                KeyCode::PageUp => {
                    crate::tui::state::step_list_selection(
                        &mut self.state.browse_list_state,
                        total_count,
                        -5,
                    );
                }
                KeyCode::PageDown => {
                    crate::tui::state::step_list_selection(
                        &mut self.state.browse_list_state,
                        total_count,
                        5,
                    );
                }
                KeyCode::Enter => {
                    let index = self.state.browse_list_state.selected().unwrap_or(0);
                    if is_addon {
                        let targets = crate::providers::addons::models::curated_catalog_presets(
                            &self.state.installed_addons,
                        );
                        if let Some(target) = targets.get(index).cloned() {
                            self.action_sender
                                .send(Action::SelectAddonCatalog(target))
                                .ok();
                        }
                    } else if let Some(preset) =
                        crate::tui::state::BrowsePreset::ALL.get(index).copied()
                    {
                        self.action_sender.send(Action::SelectBrowse(preset)).ok();
                    }
                }
                _ => {}
            }
            return None;
        }
        if self.state.player_picker_popup {
            match key.code {
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.action_sender.send(Action::GoBack).ok();
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    self.action_sender.send(Action::MoveUp).ok();
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    self.action_sender.send(Action::MoveDown).ok();
                }
                KeyCode::Home => {
                    if !self.state.available_players.is_empty() {
                        self.state.player_picker_state.select(Some(0));
                    }
                }
                KeyCode::End => {
                    if !self.state.available_players.is_empty() {
                        let last = self.state.available_players.len().saturating_sub(1);
                        self.state.player_picker_state.select(Some(last));
                    }
                }
                KeyCode::PageUp => {
                    let len = self.state.available_players.len();
                    if len > 0 {
                        let current = self.state.player_picker_state.selected().unwrap_or(0);
                        let next = if current < 5 {
                            len.saturating_sub(1)
                        } else {
                            current - 5
                        };
                        self.state.player_picker_state.select(Some(next));
                    }
                }
                KeyCode::PageDown => {
                    let len = self.state.available_players.len();
                    if len > 0 {
                        let current = self.state.player_picker_state.selected().unwrap_or(0);
                        let next = if current + 5 >= len { 0 } else { current + 5 };
                        self.state.player_picker_state.select(Some(next));
                    }
                }
                KeyCode::Enter | KeyCode::Char(' ') => {
                    self.action_sender.send(Action::Submit).ok();
                }
                _ => {}
            }
            return None;
        }

        if self.state.show_sources_popup {
            match key.code {
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.state.show_sources_popup = false;
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.sources_list_state,
                        crate::providers::models::ProviderKind::ENABLED.len(),
                        false,
                    );
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.sources_list_state,
                        crate::providers::models::ProviderKind::ENABLED.len(),
                        true,
                    );
                }
                KeyCode::Enter | KeyCode::Char(' ') => {
                    let idx = self.state.sources_list_state.selected().unwrap_or(0);
                    if let Some(&provider) =
                        crate::providers::models::ProviderKind::ENABLED.get(idx)
                    {
                        self.action_sender
                            .send(Action::ToggleProvider(provider))
                            .ok();
                    }
                }
                _ => {}
            }
            return None;
        }

        if self.state.show_theme_popup {
            let total = crate::tui::theme::AVAILABLE_THEMES.len();
            let mut changed = false;
            match key.code {
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.state.show_theme_popup = false;
                    if let Some(orig) = self.state.original_theme_kind.take() {
                        self.action_sender.send(Action::SelectTheme(orig)).ok();
                    }
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.theme_list_state,
                        total,
                        false,
                    );
                    changed = true;
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    crate::tui::state::cycle_list_selection(
                        &mut self.state.theme_list_state,
                        total,
                        true,
                    );
                    changed = true;
                }
                KeyCode::Home => {
                    if total > 0 {
                        self.state.theme_list_state.select(Some(0));
                        changed = true;
                    }
                }
                KeyCode::End => {
                    if total > 0 {
                        self.state.theme_list_state.select(Some(total - 1));
                        changed = true;
                    }
                }
                KeyCode::PageUp => {
                    crate::tui::state::step_list_selection(
                        &mut self.state.theme_list_state,
                        total,
                        -5,
                    );
                    changed = true;
                }
                KeyCode::PageDown => {
                    crate::tui::state::step_list_selection(
                        &mut self.state.theme_list_state,
                        total,
                        5,
                    );
                    changed = true;
                }
                KeyCode::Enter => {
                    self.state.show_theme_popup = false;
                    self.state.original_theme_kind = None;
                    self.persist_config();
                }
                _ => {}
            }
            if changed {
                if let Some(i) = self.state.theme_list_state.selected() {
                    let selected_theme = crate::tui::theme::AVAILABLE_THEMES[i].to_string();
                    self.action_sender
                        .send(Action::SelectTheme(selected_theme))
                        .ok();
                }
            }
            return None;
        }
        if self.state.show_settings_popup {
            if let Some(input) = &mut self.state.settings_download_dir_input {
                match key.code {
                    KeyCode::Esc => {
                        self.state.settings_download_dir_input = None;
                    }
                    KeyCode::Enter => {
                        self.action_sender.send(Action::SettingsActivateRow).ok();
                    }
                    _ => {
                        input.handle_key(key);
                    }
                }
                return None;
            }

            match key.code {
                KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                    self.state.show_settings_popup = false;
                    self.state.settings_download_dir_input = None;
                    self.persist_config();
                }
                KeyCode::Tab => {
                    self.state.settings_next_category();
                }
                KeyCode::BackTab => {
                    self.state.settings_previous_category();
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    self.state.settings_row_up();
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    self.state.settings_row_down();
                }
                KeyCode::Left | KeyCode::Char('h') => {
                    self.action_sender
                        .send(Action::SettingsAdjustValue(false))
                        .ok();
                }
                KeyCode::Right | KeyCode::Char('l') => {
                    self.action_sender
                        .send(Action::SettingsAdjustValue(true))
                        .ok();
                }
                KeyCode::Char(' ') | KeyCode::Enter => {
                    self.action_sender.send(Action::SettingsActivateRow).ok();
                }
                KeyCode::Char('d') | KeyCode::Char('D')
                    if self.state.settings_category
                        == crate::tui::state::SettingsCategory::General
                        && self.state.settings_selected_row == 2 =>
                {
                    self.action_sender
                        .send(Action::SettingsResetDownloadDir)
                        .ok();
                }
                _ => {}
            }
            return None;
        }

        if self.state.input_mode == InputMode::Normal
            && self.state.active_screen == Screen::Home
            && key.code == KeyCode::Backspace
            && !self.state.addon_manager_popup
            && !self.state.tv_config_popup
        {
            self.state.input_mode = InputMode::Editing;
            self.state.favorites_focus = false;
            self.state.favorites_landing_state.select(None);
            self.state.search_suggestions.clear();
            self.state.suggest_index = None;
            self.state.set_status_default("");
            self.state.last_search_edit = std::time::Instant::now();
            return None;
        }

        match self.state.input_mode {
            InputMode::Editing => {
                if key.modifiers.contains(KeyModifiers::CONTROL) {
                    if let KeyCode::Char('u') = key.code {
                        let had_search = !self.state.search_query.trim().is_empty()
                            || !self.state.search_results.is_empty();
                        self.state.clear_search_state();
                        self.state.input_mode = InputMode::Normal;
                        if had_search {
                            self.state.set_status_default("Search cleared.");
                        }
                        return None;
                    }
                    if let KeyCode::Char('w') = key.code {
                        self.state.search_query.delete_word_backwards();
                        self.state.suggest_index = None;
                        self.state.search_suggestions.clear();
                        self.state.last_search_edit = std::time::Instant::now();
                        return None;
                    }
                }
                match key.code {
                    KeyCode::Esc => {
                        self.state.input_mode = InputMode::Normal;
                        self.state.suggest_index = None;
                        self.state.search_suggestions.clear();
                        self.state.clear_search_state();
                        self.state.status_message.clear();
                        self.state.status_timer = 0;
                    }
                    KeyCode::Enter => {
                        let selected_opt = self
                            .state
                            .suggest_index
                            .and_then(|idx| self.state.search_suggestions.get(idx).cloned());

                        let mut query = if let Some(sug) = selected_opt {
                            sug
                        } else {
                            self.state.search_query.trim().to_string()
                        };

                        if query.starts_with('/') {
                            let suggestions =
                                crate::tui::commands::SlashCommand::suggest(&self.state, &query);
                            if suggestions.len() == 1 {
                                query = suggestions[0].clone();
                            }
                        }

                        if !query.is_empty() {
                            if query.trim().eq_ignore_ascii_case("/history") {
                                self.state.search_query.set_content("/history");
                            } else if query.starts_with('/') {
                                self.state.search_query.clear();
                            } else {
                                self.state.search_query.set_content(&query);
                            }
                            self.state.input_mode = InputMode::Normal;
                            if !query.starts_with('/') {
                                self.state.is_loading = true;
                                self.state.has_search_settled = false;
                                self.state.search_error = None;
                            }
                            self.state.search_suggestions.clear();
                            self.state.suggest_index = None;
                            self.state.search_list_state.select(None);
                            self.state.last_search_edit = std::time::Instant::now();
                            self.action_sender
                                .send(Action::Search {
                                    query,
                                    force_refresh: false,
                                })
                                .ok();
                        } else {
                            self.state.input_mode = InputMode::Normal;
                            self.state.search_suggestions.clear();
                            self.state.suggest_index = None;
                        }
                    }
                    KeyCode::Tab => {
                        let trimmed = self.state.search_query.trim();
                        let selected_or_first = if trimmed.starts_with('/') {
                            self.state
                                .suggest_index
                                .and_then(|idx| self.state.search_suggestions.get(idx).cloned())
                                .or_else(|| {
                                    let suggestions = crate::tui::commands::SlashCommand::suggest(
                                        &self.state,
                                        trimmed,
                                    );
                                    suggestions.first().cloned()
                                })
                        } else {
                            self.state
                                .suggest_index
                                .and_then(|idx| self.state.search_suggestions.get(idx).cloned())
                                .or_else(|| self.state.search_suggestions.first().cloned())
                        };
                        if let Some(sug) = selected_or_first {
                            self.state.search_query.set_content(&sug);
                            self.state.last_search_edit = std::time::Instant::now();
                        }
                    }
                    KeyCode::Left => {
                        self.state.search_query.move_left();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Right => {
                        self.state.search_query.move_right();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Home => {
                        self.state.search_query.move_home();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::End => {
                        self.state.search_query.move_end();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Backspace => {
                        self.state.search_query.delete_backwards();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Delete => {
                        self.state.search_query.delete_forwards();
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Char(c) => {
                        self.state.search_query.insert(c);
                        self.state.suggest_index = None;
                        self.state.last_search_edit = std::time::Instant::now();
                    }
                    KeyCode::Up if !self.state.search_suggestions.is_empty() => {
                        let max_idx = self.state.search_suggestions.len() - 1;
                        let next_idx = match self.state.suggest_index {
                            Some(0) | None => max_idx,
                            Some(i) => i - 1,
                        };
                        self.state.suggest_index = Some(next_idx);
                    }
                    KeyCode::Down if !self.state.search_suggestions.is_empty() => {
                        let max_idx = self.state.search_suggestions.len() - 1;
                        let next_idx = match self.state.suggest_index {
                            None => 0,
                            Some(i) if i == max_idx => 0,
                            Some(i) => i + 1,
                        };
                        self.state.suggest_index = Some(next_idx);
                    }
                    _ => {}
                }
            }
            InputMode::Normal => match self.state.active_screen {
                Screen::Home => {
                    if self.state.addon_manager_popup {
                        if self.state.addon_input_active {
                            match key.code {
                                KeyCode::Esc => {
                                    self.state.addon_input_active = false;
                                    self.state.addon_input_buffer.clear();
                                }
                                KeyCode::Enter => {
                                    let buffer =
                                        self.state.addon_input_buffer.as_str().trim().to_string();
                                    self.state.addon_input_active = false;
                                    self.state.addon_input_buffer.clear();
                                    if !buffer.is_empty() {
                                        self.action_sender
                                            .send(Action::AddonAddManifest(buffer))
                                            .ok();
                                    }
                                }
                                _ => {
                                    self.state.addon_input_buffer.handle_key(key);
                                }
                            }
                            return None;
                        }
                        match key.code {
                            KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                                self.reset_transient_overlays();
                                self.state.addon_manager_popup = false;
                            }
                            KeyCode::Up | KeyCode::Char('k') => {
                                self.state.step_addon_manager_selected(-1);
                            }
                            KeyCode::Down | KeyCode::Char('j') => {
                                self.state.step_addon_manager_selected(1);
                            }
                            KeyCode::Home => {
                                self.state.first_addon_manager_selected();
                            }
                            KeyCode::End => {
                                self.state.last_addon_manager_selected();
                            }
                            KeyCode::PageUp => {
                                self.state.step_addon_manager_selected(-5);
                            }
                            KeyCode::PageDown => {
                                self.state.step_addon_manager_selected(5);
                            }
                            KeyCode::Char('d') | KeyCode::Delete => {
                                use crate::tui::state::AddonManagerRow;
                                if let Some(AddonManagerRow::Addon(index)) = self
                                    .state
                                    .addon_manager_rows()
                                    .get(self.state.addon_manager_selected)
                                    .copied()
                                {
                                    self.action_sender.send(Action::AddonRemove(index)).ok();
                                }
                            }
                            KeyCode::Enter | KeyCode::Char(' ') => {
                                self.addon_manager_activate();
                            }
                            _ => {}
                        }
                        return None;
                    }

                    if self.state.tv_config_popup {
                        if self.state.tv_input_active {
                            match key.code {
                                KeyCode::Esc => {
                                    self.state.tv_input_active = false;
                                    self.state.tv_input_buffer.clear();
                                }
                                KeyCode::Enter => {
                                    let buffer =
                                        self.state.tv_input_buffer.as_str().trim().to_string();
                                    self.state.tv_input_active = false;
                                    self.state.tv_input_buffer.clear();
                                    if !buffer.is_empty() {
                                        self.action_sender.send(Action::TvPlaylistAdd(buffer)).ok();
                                    }
                                }
                                _ => {
                                    self.state.tv_input_buffer.handle_key(key);
                                }
                            }
                            return None;
                        }
                        match key.code {
                            KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                                self.reset_transient_overlays();
                                self.state.tv_config_popup = false;
                            }
                            KeyCode::Up | KeyCode::Char('k') => {
                                self.state.step_tv_manager_selected(-1);
                            }
                            KeyCode::Down | KeyCode::Char('j') => {
                                self.state.step_tv_manager_selected(1);
                            }
                            KeyCode::Home => {
                                self.state.first_tv_manager_selected();
                            }
                            KeyCode::End => {
                                self.state.last_tv_manager_selected();
                            }
                            KeyCode::PageUp => {
                                self.state.step_tv_manager_selected(-5);
                            }
                            KeyCode::PageDown => {
                                self.state.step_tv_manager_selected(5);
                            }
                            KeyCode::Char('r') => {
                                self.action_sender.send(Action::TvReloadPlaylists).ok();
                            }
                            KeyCode::Char('d') | KeyCode::Delete => {
                                use crate::tui::state::TvManagerRow;
                                if let Some(TvManagerRow::Playlist(index)) = self
                                    .state
                                    .tv_manager_rows()
                                    .get(self.state.tv_manager_selected)
                                    .copied()
                                {
                                    self.action_sender
                                        .send(Action::TvPlaylistRemove(index))
                                        .ok();
                                }
                            }
                            KeyCode::Enter | KeyCode::Char(' ') => {
                                self.tv_manager_activate();
                            }
                            _ => {}
                        }
                        return None;
                    }
                    match key.code {
                        KeyCode::Esc => {
                            self.action_sender.send(Action::GoBack).ok();
                        }
                        KeyCode::Up => {
                            self.action_sender.send(Action::MoveUp).ok();
                        }
                        KeyCode::Down => {
                            self.action_sender.send(Action::MoveDown).ok();
                        }
                        KeyCode::Left => {
                            self.action_sender.send(Action::MoveLeft).ok();
                        }
                        KeyCode::Right => {
                            self.action_sender.send(Action::MoveRight).ok();
                        }
                        KeyCode::Tab | KeyCode::BackTab => {
                            if self.state.landing_deck_visible() {
                                self.state.cycle_home_deck_tab();
                            }
                        }
                        KeyCode::Home | KeyCode::Char('g') => {
                            if self.state.favorites_focus {
                                self.state.favorites_landing_state.select(Some(0));
                            } else if !self.state.search_results.is_empty() {
                                self.state.search_list_state.select(Some(0));
                                if let Some(res) = self.state.search_results.first() {
                                    self.action_sender
                                        .send(Action::FetchPreview(res.id.clone()))
                                        .ok();
                                }
                                self.prefetch_visible_posters();
                                self.state.normalize_result_view();
                            }
                        }
                        KeyCode::End | KeyCode::Char('G') => {
                            if self.state.favorites_focus {
                                let total = self.state.landing_deck_items_count();
                                if total > 0 {
                                    self.state.favorites_landing_state.select(Some(total - 1));
                                }
                            } else if !self.state.search_results.is_empty() {
                                let last = self.state.search_results.len().saturating_sub(1);
                                self.state.search_list_state.select(Some(last));
                                if let Some(res) = self.state.search_results.get(last) {
                                    self.action_sender
                                        .send(Action::FetchPreview(res.id.clone()))
                                        .ok();
                                }
                                self.prefetch_visible_posters();
                                self.state.normalize_result_view();
                                self.trigger_next_page_if_needed();
                            }
                        }
                        KeyCode::PageDown => {
                            if self.state.favorites_focus {
                                let total = self.state.landing_deck_items_count();
                                crate::tui::state::step_list_selection(
                                    &mut self.state.favorites_landing_state,
                                    total,
                                    5,
                                );
                            } else if !self.state.search_results.is_empty() {
                                let step = self
                                    .state
                                    .last_result_metrics
                                    .map(|m| m.visible_items)
                                    .unwrap_or(8);
                                let cur = self.state.search_list_state.selected().unwrap_or(0);
                                let target = (cur + step)
                                    .min(self.state.search_results.len().saturating_sub(1));
                                self.state.search_list_state.select(Some(target));
                                if let Some(res) = self.state.search_results.get(target) {
                                    self.action_sender
                                        .send(Action::FetchPreview(res.id.clone()))
                                        .ok();
                                }
                                self.prefetch_visible_posters();
                                self.state.normalize_result_view();
                                self.trigger_next_page_if_needed();
                            }
                        }
                        KeyCode::PageUp => {
                            if self.state.favorites_focus {
                                let total = self.state.landing_deck_items_count();
                                crate::tui::state::step_list_selection(
                                    &mut self.state.favorites_landing_state,
                                    total,
                                    -5,
                                );
                            } else if !self.state.search_results.is_empty() {
                                let step = self
                                    .state
                                    .last_result_metrics
                                    .map(|m| m.visible_items)
                                    .unwrap_or(8);
                                let cur = self.state.search_list_state.selected().unwrap_or(0);
                                let target = cur.saturating_sub(step);
                                self.state.search_list_state.select(Some(target));
                                if let Some(res) = self.state.search_results.get(target) {
                                    self.action_sender
                                        .send(Action::FetchPreview(res.id.clone()))
                                        .ok();
                                }
                                self.prefetch_visible_posters();
                                self.state.normalize_result_view();
                            }
                        }
                        KeyCode::Enter => {
                            if self.state.search_results.is_empty()
                                && !self.state.search_query.trim().is_empty()
                            {
                                self.state.is_loading = true;
                                self.state.has_search_settled = false;
                                self.action_sender
                                    .send(Action::Search {
                                        query: self.state.search_query.trim().to_string(),
                                        force_refresh: true,
                                    })
                                    .ok();
                            } else {
                                self.action_sender.send(Action::Submit).ok();
                            }
                        }
                        KeyCode::Char('?') => {
                            self.action_sender.send(Action::ToggleHelp).ok();
                        }
                        KeyCode::Char('q') => {
                            self.action_sender.send(Action::Quit).ok();
                        }
                        KeyCode::Char('r') => {
                            if self.state.is_tv_mode {
                                self.action_sender.send(Action::TvReloadPlaylists).ok();
                            } else {
                                self.action_sender.send(Action::Refresh).ok();
                            }
                        }
                        KeyCode::Char('c') | KeyCode::Char('C')
                            if self.state.download_progress.is_none() =>
                        {
                            let had_search = !self.state.search_query.trim().is_empty()
                                || !self.state.search_results.is_empty();
                            self.state.clear_search_state();
                            self.state.input_mode = InputMode::Normal;
                            if had_search {
                                self.state.set_status_default("Search cleared.");
                            }
                        }
                        KeyCode::Char('f') | KeyCode::Char('F')
                            if self.state.favorites_available()
                                && (!self.state.search_results.is_empty()
                                    || self.state.favorites_focus) =>
                        {
                            self.action_sender.send(Action::ToggleFavorite).ok();
                        }
                        KeyCode::Char('d') | KeyCode::Char('D') | KeyCode::Delete
                            if (self
                                .state
                                .search_query
                                .trim()
                                .eq_ignore_ascii_case("/history")
                                && !self.state.search_results.is_empty())
                                || (self.state.favorites_focus
                                    && self.state.effective_home_deck_tab()
                                        == crate::tui::state::HomeDeckTab::ContinueWatching) =>
                        {
                            if self.state.favorites_focus {
                                if let Some(idx) = self.state.favorites_landing_state.selected() {
                                    let target =
                                        self.state.continue_watching_items().get(idx).map(|item| {
                                            (
                                                item.title.clone(),
                                                item.provider.clone(),
                                                item.subject_id.clone(),
                                                item.season,
                                                item.episode,
                                            )
                                        });
                                    if let Some((title, provider, subject_id, season, episode)) =
                                        target
                                    {
                                        self.state.history.remove(
                                            &provider,
                                            &subject_id,
                                            season,
                                            episode,
                                        );
                                        self.state.homepage_cache.clear();
                                        let total = self.state.landing_deck_items_count();
                                        if total == 0 {
                                            self.state.favorites_focus = false;
                                            self.state.favorites_landing_state.select(None);
                                        } else if idx >= total {
                                            self.state
                                                .favorites_landing_state
                                                .select(Some(total.saturating_sub(1)));
                                        }
                                        self.state.notify(
                                            crate::tui::overlay::NotificationKind::Info,
                                            "History",
                                            format!("Removed: {title}"),
                                        );
                                    }
                                }
                            } else if let Some(idx) = self.state.search_list_state.selected() {
                                if idx < self.state.search_results.len() {
                                    let res = self.state.search_results.remove(idx);
                                    let provider_key = res.provider.cache_key();
                                    self.state.history.remove(
                                        provider_key,
                                        &res.id,
                                        res.season,
                                        res.episode,
                                    );
                                    self.state.history.recent.retain(|i| {
                                        !(i.subject_id == res.id
                                            && (crate::providers::models::ProviderKind::parse(
                                                &i.provider,
                                            ) == Some(res.provider)
                                                || i.provider.eq_ignore_ascii_case(provider_key)))
                                    });
                                    self.state.history.save();
                                    self.state.homepage_cache.clear();
                                    let total = self.state.search_results.len();
                                    if total == 0 {
                                        self.state.search_list_state.select(None);
                                    } else if idx >= total {
                                        self.state
                                            .search_list_state
                                            .select(Some(total.saturating_sub(1)));
                                    }
                                    self.state.notify(
                                        crate::tui::overlay::NotificationKind::Info,
                                        "History",
                                        format!("Removed: {}", res.title),
                                    );
                                }
                            }
                        }
                        KeyCode::Char(' ') | KeyCode::Char('p') | KeyCode::Char('P')
                            if (self
                                .state
                                .search_query
                                .trim()
                                .eq_ignore_ascii_case("/history")
                                && !self.state.search_results.is_empty())
                                || (self.state.favorites_focus
                                    && self.state.effective_home_deck_tab()
                                        == crate::tui::state::HomeDeckTab::ContinueWatching) =>
                        {
                            if self.state.favorites_focus {
                                if let Some(idx) = self.state.favorites_landing_state.selected() {
                                    self.action_sender
                                        .send(Action::OpenContinueWatching(idx))
                                        .ok();
                                }
                            } else {
                                self.resume_history_playback();
                            }
                        }
                        KeyCode::Char(c)
                            if (key.modifiers.is_empty()
                                || key.modifiers == KeyModifiers::SHIFT) =>
                        {
                            self.state.input_mode = InputMode::Editing;
                            self.state.favorites_focus = false;
                            self.state.favorites_landing_state.select(None);
                            if c == '/' {
                                self.state.search_query.clear();
                            }
                            self.state.search_query.insert(c);

                            self.state.search_suggestions.clear();
                            self.state.suggest_index = None;
                            self.state.set_status_default("");
                            self.state.last_search_edit = std::time::Instant::now();
                        }
                        _ => {}
                    }
                }
                Screen::Details => {
                    if self.state.show_overview_modal {
                        match key.code {
                            KeyCode::Esc
                            | KeyCode::Char('q')
                            | KeyCode::Char('Q')
                            | KeyCode::Char('i')
                            | KeyCode::Char('I')
                            | KeyCode::Enter => {
                                self.state.close_overview_modal();
                            }
                            KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('K') => {
                                self.state.overview_modal_scroll =
                                    self.state.overview_modal_scroll.saturating_sub(1);
                            }
                            KeyCode::Down | KeyCode::Char('j') | KeyCode::Char('J') => {
                                self.state.overview_modal_scroll =
                                    self.state.overview_modal_scroll.saturating_add(1);
                            }
                            KeyCode::PageUp => {
                                self.state.overview_modal_scroll =
                                    self.state.overview_modal_scroll.saturating_sub(5);
                            }
                            KeyCode::PageDown => {
                                self.state.overview_modal_scroll =
                                    self.state.overview_modal_scroll.saturating_add(5);
                            }
                            _ => {}
                        }
                        return None;
                    }
                    match key.code {
                        KeyCode::Tab => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::TabPane).ok();
                            }
                        }
                        KeyCode::BackTab => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::BackTabPane).ok();
                            }
                        }
                        KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                            self.action_sender.send(Action::GoBack).ok();
                        }
                        KeyCode::Char(' ') | KeyCode::Char('p') | KeyCode::Char('P') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                match self.state.details_pane {
                                    crate::tui::state::DetailsPane::Streams => {
                                        self.action_sender.send(Action::PlayStream).ok();
                                    }
                                    crate::tui::state::DetailsPane::Seasons => {
                                        self.trigger_episode_fetch();
                                    }
                                    crate::tui::state::DetailsPane::Episodes => {
                                        self.trigger_episode_fetch();
                                    }
                                    crate::tui::state::DetailsPane::Languages => {
                                        let idx =
                                            self.state.language_list_state.selected().unwrap_or(0);
                                        self.action_sender.send(Action::SelectLanguage(idx)).ok();
                                    }
                                }
                            }
                        }
                        KeyCode::Char('d') | KeyCode::Char('D') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                if let crate::tui::state::DetailsPane::Seasons =
                                    self.state.details_pane
                                {
                                    if !self.state.available_seasons.is_empty() {
                                        self.action_sender.send(Action::DownloadSeason).ok();
                                    }
                                } else {
                                    self.action_sender.send(Action::DownloadEpisode).ok();
                                }
                            }
                        }
                        KeyCode::Char('i') | KeyCode::Char('I') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                if let Some((title, content)) = self.state.active_overview() {
                                    self.state.open_overview_modal(title, content);
                                }
                            }
                        }
                        KeyCode::Char('r') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::Refresh).ok();
                            }
                        }
                        KeyCode::Char('?') => {
                            self.action_sender.send(Action::ToggleHelp).ok();
                        }
                        KeyCode::Char('f') | KeyCode::Char('F') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                                && self.state.favorites_available()
                            {
                                self.action_sender.send(Action::ToggleFavorite).ok();
                            }
                        }

                        KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('K') => {
                            self.action_sender.send(Action::MoveUp).ok();
                        }
                        KeyCode::Down | KeyCode::Char('j') | KeyCode::Char('J') => {
                            self.action_sender.send(Action::MoveDown).ok();
                        }
                        KeyCode::Left | KeyCode::Char('h') | KeyCode::Char('H') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::BackTabPane).ok();
                            }
                        }
                        KeyCode::Right | KeyCode::Char('l') | KeyCode::Char('L') => {
                            if !self.state.subtitle_popup
                                && !self.state.player_picker_popup
                                && !self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::TabPane).ok();
                            }
                        }
                        KeyCode::Enter => {
                            if self.state.subtitle_popup
                                || self.state.player_picker_popup
                                || self.state.is_download_subtitle_popup
                            {
                                self.action_sender.send(Action::Submit).ok();
                            } else {
                                match self.state.details_pane {
                                    crate::tui::state::DetailsPane::Streams => {
                                        self.action_sender.send(Action::PlayStream).ok();
                                    }
                                    crate::tui::state::DetailsPane::Seasons => {
                                        self.trigger_episode_fetch();
                                    }
                                    crate::tui::state::DetailsPane::Episodes => {
                                        self.trigger_episode_fetch();
                                    }
                                    crate::tui::state::DetailsPane::Languages => {
                                        let idx =
                                            self.state.language_list_state.selected().unwrap_or(0);

                                        self.action_sender.send(Action::SelectLanguage(idx)).ok();
                                    }
                                }
                            }
                        }
                        _ => {}
                    }
                }
            },
        }
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

    #[tokio::test]
    async fn test_normal_mode_jump_navigation() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.search_results = vec![
            crate::models::SearchResult {
                id: "1".to_string(),
                title: "Movie 1".to_string(),
                stype: 1,
                release_year: "2020".to_string(),
                provider: crate::models::ProviderKind::MovieBox,
                cover_url: None,
                season: 0,
                episode: 0,
            },
            crate::models::SearchResult {
                id: "2".to_string(),
                title: "Movie 2".to_string(),
                stype: 1,
                release_year: "2021".to_string(),
                provider: crate::models::ProviderKind::MovieBox,
                cover_url: None,
                season: 0,
                episode: 0,
            },
            crate::models::SearchResult {
                id: "3".to_string(),
                title: "Movie 3".to_string(),
                stype: 1,
                release_year: "2022".to_string(),
                provider: crate::models::ProviderKind::MovieBox,
                cover_url: None,
                season: 0,
                episode: 0,
            },
        ];
        app.state.search_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::End, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(2));

        app.handle_key(KeyEvent::new(KeyCode::Home, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(0));

        app.handle_key(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(2));
        app.handle_key(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(0));
    }

    #[tokio::test]
    async fn test_delete_history_item_with_key() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.search_query.set_content("/history");
        app.state.history.recent.clear();
        let item = crate::history::WatchHistoryItem {
            provider: "moviebox".to_string(),
            subject_id: "hist-1".to_string(),
            title: "History Movie".to_string(),
            cover_url: None,
            stype: 1,
            release_year: "2024".to_string(),
            season: 0,
            episode: 0,
            progress_seconds: 50,
            duration_seconds: Some(500),
            completed: false,
            timestamp: 1000,
            stream_filename: None,
        };
        app.state.history.record_start(&item, 50);
        app.state.search_results.push(item.to_search_result());
        app.state.search_list_state.select(Some(0));
        assert_eq!(app.state.search_results.len(), 1);
        assert_eq!(app.state.history.recent.len(), 1);

        app.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::empty()))
            .await;

        assert!(app.state.search_results.is_empty());
        assert!(app.state.history.recent.is_empty());
        let notif = app
            .state
            .notifications
            .back()
            .expect("notification emitted");
        assert_eq!(notif.title, "History");
        assert_eq!(notif.message, "Removed: History Movie");
    }

    #[tokio::test]
    async fn test_update_modal_keystroke_isolation() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.update_available = Some(("2.0.0".to_string(), "Notes".to_string()));
        app.state.search_results = vec![
            crate::models::SearchResult {
                id: "1".to_string(),
                title: "Movie 1".to_string(),
                stype: 1,
                release_year: "2020".to_string(),
                provider: crate::models::ProviderKind::MovieBox,
                cover_url: None,
                season: 0,
                episode: 0,
            },
            crate::models::SearchResult {
                id: "2".to_string(),
                title: "Movie 2".to_string(),
                stype: 1,
                release_year: "2021".to_string(),
                provider: crate::models::ProviderKind::MovieBox,
                cover_url: None,
                season: 0,
                episode: 0,
            },
        ];
        app.state.search_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::End, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(0));
        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        assert!(app.state.update_available.is_none());
        app.handle_key(KeyEvent::new(KeyCode::End, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.search_list_state.selected(), Some(1));
    }
    #[tokio::test]
    async fn test_normal_mode_c_clears_search_and_results() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.search_query.set_content("Inception");
        app.state.search_results = vec![crate::models::SearchResult {
            id: "1".to_string(),
            title: "Inception".to_string(),
            stype: 1,
            release_year: "2010".to_string(),
            provider: crate::models::ProviderKind::MovieBox,
            cover_url: None,
            season: 0,
            episode: 0,
        }];
        app.state.search_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::empty()))
            .await;

        assert!(app.state.search_query.is_empty());
        assert!(app.state.search_results.is_empty());
        assert_eq!(app.state.search_list_state.selected(), None);
    }

    #[tokio::test]
    async fn test_search_results_multiple_esc_returns_to_homepage() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.search_query.set_content("Deewaniyat");
        app.state.search_results = vec![crate::models::SearchResult {
            id: "1".to_string(),
            title: "Deewaniyat".to_string(),
            stype: 1,
            release_year: "2024".to_string(),
            provider: crate::models::ProviderKind::MovieBox,
            cover_url: None,
            season: 0,
            episode: 0,
        }];
        app.state.search_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        while let Ok(action) = app.action_receiver.try_recv() {
            app.handle_action(action).await;
        }
        assert_eq!(app.state.input_mode, InputMode::Editing);
        assert_eq!(app.state.search_query.as_str(), "Deewaniyat");
        assert!(!app.state.search_results.is_empty());

        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        while let Ok(action) = app.action_receiver.try_recv() {
            app.handle_action(action).await;
        }
        assert_eq!(app.state.input_mode, InputMode::Normal);
        assert!(app.state.search_query.is_empty());
        assert!(app.state.search_results.is_empty());
        assert_eq!(app.state.search_list_state.selected(), None);
    }

    #[tokio::test]
    async fn test_browse_esc_returns_to_homepage() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.active_browse_preset = Some(crate::models::BrowsePreset::Trending);
        app.state.search_results = vec![crate::models::SearchResult {
            id: "1".to_string(),
            title: "Awarapan 2".to_string(),
            stype: 1,
            release_year: "2026".to_string(),
            provider: crate::models::ProviderKind::MovieBox,
            cover_url: None,
            season: 0,
            episode: 0,
        }];
        app.state.search_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        while let Ok(action) = app.action_receiver.try_recv() {
            app.handle_action(action).await;
        }

        assert!(app.state.active_browse_preset.is_none());
        assert!(app.state.search_results.is_empty());
        assert_eq!(app.state.search_list_state.selected(), None);
        assert_eq!(app.state.input_mode, InputMode::Normal);
    }
    #[tokio::test]
    async fn test_provider_popup_keyboard_navigation() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.is_tv_mode = false;
        app.state.active_provider = crate::models::ProviderKind::MovieBox;
        app.state.show_provider_popup = true;
        app.state.provider_list_state.select(Some(0));

        app.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.provider_list_state.selected(), Some(1));

        app.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_provider_popup);
        let expected = app.state.available_providers()[1];
        assert_eq!(app.state.active_provider, expected);

        app.state.show_provider_popup = true;
        app.state.provider_list_state.select(Some(0));
        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_provider_popup);
        assert_eq!(app.state.provider_list_state.selected(), None);

        app.state.show_provider_popup = true;
        app.state.provider_list_state.select(Some(0));
        let before_provider = app.state.active_provider;
        app.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::CONTROL))
            .await;
        assert!(!app.state.show_provider_popup);
        assert_ne!(app.state.active_provider, before_provider);
    }

    #[tokio::test]
    async fn test_empty_search_clear_does_not_set_status() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Home;
        app.state.input_mode = InputMode::Normal;
        app.state.search_query.clear();
        app.state.search_results.clear();

        app.handle_key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.status_message, "");

        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        while let Ok(action) = app.action_receiver.try_recv() {
            app.handle_action(action).await;
        }
        assert_eq!(app.state.status_message, "");

        app.state.input_mode = InputMode::Editing;
        app.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.input_mode, InputMode::Normal);
        assert_eq!(app.state.status_message, "");

        app.state.search_query.set_content("inception");
        app.handle_key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.status_message, "Search cleared.");
    }

    #[tokio::test]
    async fn test_details_overview_modal_keyboard_toggle_and_scroll() {
        let mut app = App::new();
        app.state.active_screen = crate::tui::state::Screen::Details;
        app.state.input_mode = InputMode::Normal;
        app.state.selected_details = Some(crate::providers::models::MediaDetails {
            id: crate::providers::models::ProviderMediaId {
                provider: crate::providers::models::ProviderKind::MovieBox,
                value: "movie_1".to_string(),
            },
            title: "Interstellar".to_string(),
            media_type: crate::providers::models::MediaType::Movie,
            year: Some("2014".to_string()),
            description: Some("Space exploration epic.".to_string()),
            tagline: None,
            imdb_rating: None,
            director: None,
            stars: None,
            prints: None,
            audios: None,
            poster_url: None,
            duration: None,
            genres: vec![],
            seasons: vec![],
            dubs: vec![],
        });

        assert!(!app.state.show_overview_modal);

        app.handle_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::empty()))
            .await;
        assert!(app.state.show_overview_modal);
        assert_eq!(app.state.overview_modal_title, "Interstellar · Synopsis");
        assert_eq!(app.state.overview_modal_content, "Space exploration epic.");
        assert_eq!(app.state.overview_modal_scroll, 0);

        app.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.overview_modal_scroll, 1);

        app.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.overview_modal_scroll, 6);

        app.handle_key(KeyEvent::new(KeyCode::Up, KeyModifiers::empty()))
            .await;
        assert_eq!(app.state.overview_modal_scroll, 5);

        app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_overview_modal);

        app.handle_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::empty()))
            .await;
        assert!(app.state.show_overview_modal);

        app.handle_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_overview_modal);
    }

    #[tokio::test]
    async fn test_details_download_key_triggers_download_directly() {
        let mut app = App::new();
        app.state.active_screen = Screen::Details;
        app.state.details_pane = crate::tui::state::DetailsPane::Streams;
        app.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::empty()))
            .await;
        assert!(matches!(
            app.action_receiver.try_recv().ok(),
            Some(Action::DownloadEpisode)
        ));

        app.state.details_pane = crate::tui::state::DetailsPane::Seasons;
        app.state.available_seasons = vec![crate::providers::models::Season {
            number: 1,
            episodes: vec![],
        }];
        app.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::empty()))
            .await;
        assert!(matches!(
            app.action_receiver.try_recv().ok(),
            Some(Action::DownloadSeason)
        ));
    }
    #[tokio::test]
    async fn test_details_q_triggers_go_back() {
        let mut app = App::new();
        app.state.active_screen = Screen::Details;
        app.state.details_pane = crate::tui::state::DetailsPane::Streams;
        app.handle_key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()))
            .await;
        assert!(matches!(
            app.action_receiver.try_recv().ok(),
            Some(Action::GoBack)
        ));
    }

    #[tokio::test]
    async fn test_popups_dismiss_on_q() {
        let mut app = App::new();
        app.state.show_provider_popup = true;
        app.state.provider_list_state.select(Some(0));
        app.handle_key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_provider_popup);
        assert_eq!(app.state.provider_list_state.selected(), None);

        app.state.show_settings_popup = true;
        app.handle_key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()))
            .await;
        assert!(!app.state.show_settings_popup);
    }
}