Skip to content

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

29.4 KB
Raw Blame
use super::App;
use crate::models::CatalogItem;
use crate::providers::models::{ProviderKind, RequestContext};
use crate::tui::{
    action::Action,
    overlay::NotificationKind,
    state::{InputMode, Screen, SearchResult},
};

fn compare_browse_values(
    left: Option<f64>,
    right: Option<f64>,
    descending: bool,
) -> std::cmp::Ordering {
    match (left, right) {
        (Some(left), Some(right)) => {
            let order = left
                .partial_cmp(&right)
                .unwrap_or(std::cmp::Ordering::Equal);
            if descending { order.reverse() } else { order }
        }
        (Some(_), None) => std::cmp::Ordering::Less,
        (None, Some(_)) => std::cmp::Ordering::Greater,
        (None, None) => std::cmp::Ordering::Equal,
    }
}

impl App {
    pub(super) fn apply_tv_search_results(&mut self, query: &str, lower_query: &str) {
        self.state.search_results = self
            .state
            .tv_channels
            .iter()
            .filter(|channel| {
                lower_query == "/list"
                    || channel.name.to_lowercase().contains(lower_query)
                    || channel.group.to_lowercase().contains(lower_query)
            })
            .map(|channel| SearchResult {
                id: channel.stream_url.clone(),
                title: channel.name.clone(),
                stype: 3,
                release_year: channel.group.clone(),
                cover_url: Some(channel.logo.clone()),
                season: 1,
                episode: 1,
                provider: ProviderKind::MovieBox,
            })
            .collect();
        self.state.is_loading = false;
        self.state.has_search_settled = true;
        self.state
            .search_list_state
            .select(if self.state.search_results.is_empty() {
                None
            } else {
                Some(0)
            });
        if !self.state.search_results.is_empty() {
            self.prefetch_visible_posters();
        }
        self.state
            .set_status_default(if self.state.search_results.is_empty() {
                format!("No matches for '{}'.", query)
            } else {
                format!("Found {} channels.", self.state.search_results.len())
            });
    }

    pub(super) fn handle_search_command(&mut self, query: &str, lower_query: &str) -> Option<bool> {
        let trimmed = query.trim();
        if !trimmed.starts_with('/') {
            return None;
        }

        if trimmed == "/" {
            self.state.search_query.clear();
            self.state.input_mode = InputMode::Normal;
            return Some(true);
        }

        let parsed = match crate::tui::commands::SlashCommand::parse(trimmed) {
            Some(p) => p,
            None => {
                let cmd_name = trimmed.split_whitespace().next().unwrap_or(trimmed);
                self.state.search_query.clear();
                self.state.input_mode = InputMode::Normal;
                self.state.notify(
                    NotificationKind::Warning,
                    "Unknown Command",
                    format!("Unknown command '{cmd_name}'. Type '/' for list."),
                );
                return Some(true);
            }
        };

        let current_mode = self.state.mode();
        let ctrl_s = crate::tui::text::CTRL_S_STR;
        let ctrl_t = crate::tui::text::CTRL_T_STR;

        let will_handle = !matches!(
            &parsed,
            crate::tui::commands::SlashCommand::History if current_mode != crate::tui::state::AppMode::Tv
        ) && !matches!(
            &parsed,
            crate::tui::commands::SlashCommand::Favorites if current_mode != crate::tui::state::AppMode::Tv
        ) && !matches!(
            &parsed,
            crate::tui::commands::SlashCommand::List if current_mode == crate::tui::state::AppMode::Tv
        );

        if will_handle {
            self.state.search_query.clear();
            self.state.input_mode = InputMode::Normal;
        }

        match parsed {
            crate::tui::commands::SlashCommand::Exit => {
                self.action_sender.send(Action::Quit).ok();
                Some(true)
            }
            crate::tui::commands::SlashCommand::Settings => {
                self.action_sender.send(Action::ToggleSettingsPopup).ok();
                Some(true)
            }
            crate::tui::commands::SlashCommand::Config => {
                if self.state.is_tv_mode {
                    self.action_sender.send(Action::ShowTvConfig).ok();
                } else if self.state.active_provider
                    == crate::providers::models::ProviderKind::Addons
                {
                    self.action_sender.send(Action::ShowAddonManager).ok();
                } else {
                    self.state.notify(
                        NotificationKind::Info,
                        "Config",
                        "Use /settings for preferences, or switch provider.",
                    );
                }
                Some(true)
            }
            crate::tui::commands::SlashCommand::Clear => {
                self.state.clear_search_state();
                self.state.set_status_default("Search cleared.");
                Some(true)
            }
            crate::tui::commands::SlashCommand::Help => {
                self.action_sender.send(Action::ToggleHelp).ok();
                Some(true)
            }
            crate::tui::commands::SlashCommand::Browse => {
                if current_mode == crate::tui::state::AppMode::Tv {
                    self.state.notify(
                        NotificationKind::Info,
                        "TV Mode",
                        format!("Available in Streaming Mode ({ctrl_s})."),
                    );
                } else {
                    self.action_sender.send(Action::ShowBrowseMenu).ok();
                }
                Some(true)
            }
            crate::tui::commands::SlashCommand::History => {
                if current_mode == crate::tui::state::AppMode::Tv {
                    self.state.notify(
                        NotificationKind::Info,
                        "TV Mode",
                        format!("Available in Streaming Mode ({ctrl_s})."),
                    );
                    Some(true)
                } else {
                    None
                }
            }
            crate::tui::commands::SlashCommand::Favorites => {
                if current_mode == crate::tui::state::AppMode::Tv {
                    self.state.notify(
                        NotificationKind::Info,
                        "TV Mode",
                        format!("Available in Streaming Mode ({ctrl_s})."),
                    );
                    Some(true)
                } else {
                    None
                }
            }
            crate::tui::commands::SlashCommand::List => {
                if current_mode == crate::tui::state::AppMode::Tv {
                    self.apply_tv_search_results(query, lower_query);
                } else {
                    self.state.notify(
                        NotificationKind::Info,
                        "TV Mode",
                        format!("Available in TV Mode ({ctrl_t})."),
                    );
                }
                Some(true)
            }
        }
    }

    pub(super) fn prepare_search_request(&mut self, query: &str) -> RequestContext {
        self.state.active_search_request = self.state.active_search_request.wrapping_add(1);
        self.state.active_preview_request = self.state.active_preview_request.wrapping_add(1);
        self.state.is_homepage_mode = false;
        self.state.active_browse_preset = None;
        self.state.active_addon_catalog = None;
        self.state.browse_metrics.clear();
        self.state.current_page = 1;
        self.state.search_exhausted = false;
        self.state.active_screen = Screen::Home;
        self.state.active_subject_id = None;
        self.state.selected_details = None;
        self.state.selected_resources.clear();
        self.state.is_loading = true;
        self.state.has_search_settled = false;
        self.state.search_error = None;
        self.state.search_list_state.select(Some(0));
        self.state.search_suggestions.clear();
        self.state.suggest_index = None;
        self.state.search_preview = None;
        self.state.preview_loading = false;
        self.state.poster_image = None;
        self.state.poster_protocol = None;
        self.state
            .set_status_default(format!("Searching for '{}'...", query));
        self.request_context()
    }

    pub(super) fn prepare_addon_catalog_request(
        &mut self,
        target: &crate::providers::addons::models::AddonCatalogTarget,
    ) -> RequestContext {
        self.state.active_search_request = self.state.active_search_request.wrapping_add(1);
        self.state.active_preview_request = self.state.active_preview_request.wrapping_add(1);
        self.state.is_homepage_mode = false;
        self.state.active_browse_preset = None;
        self.state.active_addon_catalog = Some(target.clone());
        self.state.browse_metrics.clear();
        self.state.current_page = 1;
        self.state.active_screen = Screen::Home;
        self.state.active_subject_id = None;
        self.state.selected_details = None;
        self.state.selected_resources.clear();
        self.state.is_loading = true;
        self.state.has_search_settled = false;
        self.state.search_error = None;
        self.state.search_list_state.select(Some(0));
        self.state.search_suggestions.clear();
        self.state.suggest_index = None;
        self.state.search_preview = None;
        self.state.preview_loading = false;
        self.state.poster_image = None;
        self.state.poster_protocol = None;
        self.state.failed_posters.clear();
        self.state.in_flight_posters.clear();
        self.state.search_results.clear();
        self.state.search_query.clear();
        self.request_context()
    }

    pub(super) fn run_search_request(
        &mut self,
        query: String,
        force_refresh: bool,
        context: RequestContext,
    ) {
        self.request_tasks.cancel_search();
        let request_id = self.state.active_search_request;
        let page = 1;
        let sender = self.action_sender.clone();
        let service = self.service.clone();
        self.request_tasks.search = Some(tokio::spawn(async move {
            if !force_refresh {
                let q = query.clone();
                let provider = context.provider;
                if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {
                    crate::cache::get_provider_search_cache_typed(provider, &q, page)
                })
                .await
                {
                    sender
                        .send(Action::SearchSuccess {
                            context,
                            request_id,
                            query: query.clone(),
                            page,
                            items: cached,
                        })
                        .ok();
                    return;
                }
            }

            let result = service.search_typed(context.provider, &query, page).await;
            match result {
                Ok(items) => {
                    let q = query.clone();
                    let provider = context.provider;
                    let cached = items.clone();
                    tokio::task::spawn_blocking(move || {
                        crate::cache::set_provider_search_cache_typed(provider, &q, page, &cached);
                    });
                    sender
                        .send(Action::SearchSuccess {
                            context,
                            request_id,
                            query,
                            page,
                            items,
                        })
                        .ok();
                }
                Err(error) => {
                    sender
                        .send(Action::SearchFailure(
                            context,
                            request_id,
                            page,
                            error.user_message(context.provider),
                        ))
                        .ok();
                }
            }
        }));
    }

    pub(super) fn prepare_homepage_request(&mut self, tab_id: &str, page: usize) {
        self.state.active_homepage_request = self.state.active_homepage_request.wrapping_add(1);
        self.state.is_homepage_mode = true;
        self.state.current_tab_id = tab_id.to_string();
        self.state.current_page = page;
        self.state.active_screen = Screen::Home;
        self.state.is_loading = true;
        self.state.has_search_settled = false;
        self.state.search_error = None;
        if page == 1 {
            self.state.active_preview_request = self.state.active_preview_request.wrapping_add(1);
            self.state.active_subject_id = None;
            self.state.selected_details = None;
            self.state.selected_resources.clear();
            self.state.search_results.clear();
            self.state.browse_metrics.clear();
            self.state.search_list_state.select(Some(0));
            self.state.search_suggestions.clear();
            self.state.suggest_index = None;
            self.state.search_preview = None;
            self.state.preview_loading = false;
            self.state.poster_image = None;
            self.state.poster_protocol = None;
            self.state.set_status_default("Loading discover tab...");
        }
    }

    pub(super) fn prepare_details_request(&mut self, id: &str) -> RequestContext {
        self.state.active_subject_id = Some(id.to_string());
        self.state.poster_protocol = None;
        self.state.is_loading = true;
        self.state.details_error = None;
        self.state.active_details_request = self.state.active_details_request.wrapping_add(1);
        self.state
            .fetch_cancel
            .store(false, std::sync::atomic::Ordering::Relaxed);
        self.state.set_status_default("Fetching details...");
        self.state.stream_pool.clear();

        let provider = self.provider_for_subject(id);
        let mut context = self.request_context();
        context.provider = provider;
        context
    }

    pub(super) fn run_details_request(
        &mut self,
        id: String,
        force_refresh: bool,
        context: RequestContext,
    ) {
        self.request_tasks.cancel_details();
        let request_id = self.state.active_details_request;
        if !force_refresh {
            if let Some(cached) = self.state.preview_cache.get(&id).cloned() {
                self.action_sender
                    .send(Action::DetailsSuccess(
                        context,
                        request_id,
                        id,
                        Box::new(cached),
                    ))
                    .ok();
                return;
            }
        }
        let service = self.service.clone();
        let sender = self.action_sender.clone();
        self.request_tasks.details = Some(tokio::spawn(async move {
            if !force_refresh {
                let id_for_cache = id.clone();
                if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {
                    crate::cache::get_provider_details_cache_typed(context.provider, &id_for_cache)
                })
                .await
                {
                    sender
                        .send(Action::DetailsSuccess(
                            context,
                            request_id,
                            id.clone(),
                            Box::new(cached),
                        ))
                        .ok();
                    return;
                }
            }

            let result = service.details_typed(context.provider, &id).await;
            match result {
                Ok(details) => {
                    let id_for_cache = id.clone();
                    let details_for_cache = details.clone();
                    let _ = tokio::task::spawn_blocking(move || {
                        crate::cache::set_provider_details_cache_typed(
                            context.provider,
                            &id_for_cache,
                            &details_for_cache,
                        )
                    })
                    .await;
                    sender
                        .send(Action::DetailsSuccess(
                            context,
                            request_id,
                            id,
                            Box::new(details),
                        ))
                        .ok();
                }
                Err(error) => {
                    sender
                        .send(Action::DetailsFailure(
                            context,
                            request_id,
                            error.user_message(context.provider),
                        ))
                        .ok();
                }
            }
        }));
    }

    pub(super) fn run_homepage_request(&mut self, tab_id: String, page: usize) {
        self.request_tasks.cancel_homepage();
        let request_id = self.state.active_homepage_request;
        if let Some((items, metrics)) = self
            .state
            .homepage_cache
            .get(&(tab_id.clone(), page))
            .cloned()
        {
            self.action_sender
                .send(Action::HomepageSuccess {
                    request_id,
                    tab_id,
                    page,
                    items,
                    metrics,
                })
                .ok();
            return;
        }
        let service = self.service.clone();
        let sender = self.action_sender.clone();
        self.request_tasks.homepage = Some(tokio::spawn(async move {
            let t_clone = tab_id.clone();
            if let Ok(Some((items, metrics))) = tokio::task::spawn_blocking(move || {
                crate::cache::get_homepage_cache_typed(&t_clone, page)
            })
            .await
            {
                sender
                    .send(Action::HomepageSuccess {
                        request_id,
                        tab_id: tab_id.clone(),
                        page,
                        items,
                        metrics,
                    })
                    .ok();
                return;
            }

            match service.homepage(&tab_id, page).await {
                Ok((items, metrics)) => {
                    let items_clone = items.clone();
                    let metrics_clone = metrics.clone();
                    let t_clone = tab_id.clone();
                    tokio::task::spawn_blocking(move || {
                        crate::cache::set_homepage_cache_typed(
                            &t_clone,
                            page,
                            &(items_clone, metrics_clone),
                        );
                    });
                    sender
                        .send(Action::HomepageSuccess {
                            request_id,
                            tab_id,
                            page,
                            items,
                            metrics,
                        })
                        .ok();
                }
                Err(error) => {
                    sender.send(Action::HomepageFailure(request_id, error)).ok();
                }
            }
        }));
    }

    pub(super) fn append_homepage_items(
        &mut self,
        items: Vec<CatalogItem>,
        metrics_map: std::collections::HashMap<String, crate::models::BrowseMetrics>,
    ) -> usize {
        let mut count = 0;
        for item in items {
            let id = item.id.value.clone();
            let clean_title = crate::providers::moviebox::clean_moviebox_title(&item.title);
            let stype = if item.media_type == crate::models::MediaType::Series {
                2
            } else {
                1
            };
            let release_year = item.year.clone().unwrap_or_default();
            let cover_url = item.poster_url.clone();
            let metrics = metrics_map.get(&id).copied().unwrap_or_default();

            if let Some(existing) = self.state.search_results.iter_mut().find(|r| r.id == id) {
                let stored_metrics = self.state.browse_metrics.entry(id.clone()).or_default();
                stored_metrics.trending = stored_metrics.trending.or(metrics.trending);
                stored_metrics.rating = stored_metrics.rating.or(metrics.rating);
                stored_metrics.recent_rating =
                    stored_metrics.recent_rating.or(metrics.recent_rating);
                stored_metrics.popularity = stored_metrics.popularity.or(metrics.popularity);
                if existing.title.is_empty() {
                    existing.title = clean_title.to_string();
                    existing.stype = stype;
                    existing.release_year = release_year;
                    existing.cover_url = cover_url;
                }
                continue;
            }

            let raw_lower = item.title.to_lowercase();
            let is_dub = raw_lower.contains("[hindi]")
                || raw_lower.contains("[tamil]")
                || raw_lower.contains("[telugu]")
                || raw_lower.contains("[english]");

            if is_dub
                && self
                    .state
                    .search_results
                    .iter()
                    .any(|r| r.title == clean_title && r.stype == stype)
            {
                continue;
            }

            if self.state.search_results.iter().any(|r| {
                r.title == clean_title && r.release_year == release_year && r.stype == stype
            }) {
                continue;
            }

            if !id.is_empty() {
                self.state.browse_metrics.insert(id.clone(), metrics);
                self.state.search_results.push(SearchResult {
                    id,
                    title: clean_title.to_string(),
                    stype,
                    release_year,
                    cover_url,
                    season: 0,
                    episode: 1,
                    provider: item.id.provider,
                });
                count += 1;
            }
        }
        count
    }

    pub(super) fn sort_browse_results(&mut self) {
        let Some(preset) = self.state.active_browse_preset else {
            return;
        };
        let metric = preset.metric();
        let descending = preset.descending();
        let state = &mut self.state;
        let metrics = &state.browse_metrics;
        state.search_results.sort_by(|left, right| {
            let left_value = metrics
                .get(&left.id)
                .and_then(|values| values.value(metric));
            let right_value = metrics
                .get(&right.id)
                .and_then(|values| values.value(metric));
            let metric_order = compare_browse_values(left_value, right_value, descending);
            if left_value.is_none() && right_value.is_none() {
                metric_order
            } else {
                metric_order
                    .then_with(|| left.title.to_lowercase().cmp(&right.title.to_lowercase()))
            }
        });
    }

    pub(super) fn prefetch_visible_posters(&mut self) {
        if !self.state.image_supported || self.state.search_results.is_empty() {
            return;
        }
        let total = self.state.search_results.len();
        let selected = self.state.search_list_state.selected().unwrap_or(0);
        let offset = self.state.result_scroll;
        let visible = self.state.effective_visible_items().max(6);

        let base_start = offset.min(selected);
        let start = base_start.saturating_sub(2);
        let end = (offset + visible + 4).min(total);

        if start < end {
            let slice: Vec<(String, Option<String>, ProviderKind)> = self.state.search_results
                [start..end]
                .iter()
                .map(|r| (r.id.clone(), r.cover_url.clone(), r.provider))
                .collect();
            self.spawn_search_posters(slice);
        }
    }

    pub(super) fn spawn_search_posters(
        &mut self,
        results: Vec<(String, Option<String>, ProviderKind)>,
    ) {
        if !self.state.image_supported {
            return;
        }

        let mut to_fetch = Vec::new();
        for (id, cover_url, provider) in results {
            if self.state.search_posters.contains(&id) || self.state.failed_poster_recently(&id) {
                continue;
            }
            if !self.state.in_flight_posters.insert(id.clone()) {
                continue;
            }
            to_fetch.push((id, cover_url, provider));
        }

        if to_fetch.is_empty() {
            return;
        }

        let sender = self.action_sender.clone();
        let service = self.service.clone();
        let semaphore = self.state.poster_fetch_semaphore.clone();
        let cancel_token = self.state.fetch_cancel.clone();

        tokio::spawn(async move {
            let sem = semaphore;
            for (id, cover_url, provider) in to_fetch {
                let permit = sem.clone().acquire_owned().await.ok();
                let tx = sender.clone();
                let service = service.clone();
                let cancel = cancel_token.clone();

                tokio::spawn(async move {
                    let _permit = permit;
                    if cancel.load(std::sync::atomic::Ordering::Relaxed) {
                        return;
                    }
                    let id_clone = id.clone();
                    if let Ok(Some(bytes)) = tokio::task::spawn_blocking({
                        let id_c = id_clone.clone();
                        move || crate::cache::get_namespaced_image_cache("posters", &id_c)
                    })
                    .await
                    {
                        if let Some(img) = crate::service::decode_poster(bytes).await {
                            tx.send(Action::SearchPosterLoaded(id_clone, Some(img)))
                                .ok();
                            return;
                        }
                    }

                    let mut resolved_url = cover_url;
                    if resolved_url.is_none() {
                        if let Ok(details) = service.details_typed(provider, &id).await {
                            resolved_url = details.cover_url().map(|s| s.to_string());
                        }
                    }

                    if let Some(url) = resolved_url {
                        if !url.is_empty() {
                            if let Some(bytes) = service.fetch_poster_bytes(&url).await {
                                if cancel.load(std::sync::atomic::Ordering::Relaxed) {
                                    return;
                                }
                                let bytes_clone = bytes.clone();
                                let id_c = id.clone();
                                let _ = tokio::task::spawn_blocking(move || {
                                    crate::cache::set_namespaced_image_cache(
                                        "posters",
                                        &id_c,
                                        &bytes_clone,
                                    );
                                })
                                .await;

                                if cancel.load(std::sync::atomic::Ordering::Relaxed) {
                                    return;
                                }

                                if let Some(img) = crate::service::decode_poster(bytes).await {
                                    tx.send(Action::SearchPosterLoaded(id, Some(img))).ok();
                                    return;
                                }
                            }
                        }
                    }

                    tx.send(Action::SearchPosterLoaded(id, None)).ok();
                });
            }
        });
    }
}

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

    #[tokio::test]
    async fn test_handle_search_command_config_in_streaming_mode_shows_guidance() {
        let mut app = App::new();
        app.state.active_provider = ProviderKind::MovieBox;
        app.state.is_tv_mode = false;

        let handled = app.handle_search_command("/config", "/config");
        assert_eq!(handled, Some(true));
        assert!(!app.state.show_settings_popup);
        assert!(!app.state.addon_manager_popup);
        assert!(!app.state.tv_config_popup);
        assert_eq!(app.state.notifications.len(), 1);
        assert_eq!(app.state.notifications[0].title, "Config");
        assert!(app.state.notifications[0].message.contains("/settings"));
    }

    #[tokio::test]
    async fn test_handle_search_command_config_in_addons_mode_opens_addon_manager() {
        let mut app = App::new();
        app.state.active_provider = ProviderKind::Addons;
        app.state.is_tv_mode = false;

        let handled = app.handle_search_command("/config", "/config");
        assert_eq!(handled, Some(true));
        assert!(!app.state.show_settings_popup);
        assert!(app.state.notifications.is_empty());
    }

    #[tokio::test]
    async fn test_handle_search_command_config_in_tv_mode_opens_tv_config() {
        let mut app = App::new();
        app.state.is_tv_mode = true;

        let handled = app.handle_search_command("/config", "/config");
        assert_eq!(handled, Some(true));
        assert!(!app.state.show_settings_popup);
        assert!(app.state.notifications.is_empty());
    }
}