Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use super::App;
use crate::models::{Episode, MediaType, ProviderKind, Season};
use crate::tui::{
action::Action,
state::{InputMode, Screen, SearchResult},
};
impl App {
pub(super) async fn handle_requests(&mut self, action: Action) -> Option<()> {
match action {
Action::Suggest(query) => {
self.state.active_suggest_request =
self.state.active_suggest_request.wrapping_add(1);
let request_id = self.state.active_suggest_request;
if query.starts_with('/') {
let matching_commands =
crate::tui::commands::SlashCommand::suggest(&self.state, &query);
if !matching_commands.is_empty() {
self.action_sender
.send(Action::SuggestSuccess(request_id, query, matching_commands))
.ok();
}
return None;
}
if self.state.is_tv_mode {
return None;
}
if self.state.active_provider != ProviderKind::MovieBox {
self.state.search_suggestions.clear();
return None;
}
if let Some(cached) = self.state.suggest_cache.get(&query).cloned() {
self.action_sender
.send(Action::SuggestSuccess(request_id, query, cached))
.ok();
return None;
}
let service = self.service.clone();
let sender = self.action_sender.clone();
let query_clone = query.clone();
self.request_tasks.spawn_suggest(async move {
if let Ok(res) = service.suggest(&query_clone).await {
sender
.send(Action::SuggestSuccess(request_id, query_clone, res))
.ok();
}
});
}
Action::SuggestSuccess(request_id, query, suggestions) => {
if request_id != self.state.active_suggest_request {
return None;
}
if !query.starts_with('/')
&& (self.state.is_tv_mode
|| self.state.active_provider != ProviderKind::MovieBox)
{
return None;
}
if self.state.suggest_index.is_some() {
return None;
}
let matches = query == self.state.search_query.trim();
if !matches {
return None;
}
if !query.starts_with('/') {
self.state
.suggest_cache
.put(query.clone(), suggestions.clone());
}
self.state.search_suggestions.clear();
let limit = if query.starts_with('/') { 20 } else { 10 };
for raw_title in suggestions.into_iter().take(limit) {
let clean_title = if query.starts_with('/') {
raw_title
} else {
crate::providers::moviebox::clean_moviebox_title(&raw_title).to_string()
};
if query.starts_with('/') {
if clean_title.starts_with(&query)
&& !self.state.search_suggestions.contains(&clean_title)
{
self.state.search_suggestions.push(clean_title);
}
continue;
}
let normalized_query = query
.to_lowercase()
.replace(|c: char| !c.is_alphanumeric(), "");
let normalized_title = clean_title
.to_lowercase()
.replace(|c: char| !c.is_alphanumeric(), "");
if !normalized_title.contains(&normalized_query) && !normalized_query.is_empty()
{
continue;
}
if !self.state.search_suggestions.contains(&clean_title) {
self.state.search_suggestions.push(clean_title);
}
}
}
Action::SelectSuggestion { query } => {
self.state.search_query.set_content(&query);
self.state.suggest_index = None;
self.state.search_suggestions.clear();
self.state.input_mode = InputMode::Normal;
self.state.is_loading = true;
self.state.has_search_settled = false;
self.action_sender
.send(Action::Search {
query,
force_refresh: false,
})
.ok();
}
Action::Search {
query,
force_refresh,
} => {
let lower_query = query.trim().to_lowercase();
if lower_query == "/history"
&& self.state.mode() == crate::tui::state::AppMode::Streaming
{
self.state.input_mode = InputMode::Normal;
self.state.is_loading = false;
self.state.has_search_settled = true;
self.state.is_homepage_mode = false;
self.state.active_browse_preset = None;
self.state.browse_metrics.clear();
self.state.active_screen = Screen::Home;
self.state.active_subject_id = None;
self.state.active_preview_request =
self.state.active_preview_request.wrapping_add(1);
self.state.search_results.clear();
self.state.search_error = 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_list_state.select(None);
self.state.search_suggestions.clear();
self.state.suggest_index = None;
self.state.search_query.set_content("/history");
let mut recent = self.state.history.recent.clone();
if recent.is_empty() {
self.state.notify(
crate::tui::overlay::NotificationKind::Info,
"History",
"No watch history found.",
);
} else {
recent.sort_by_key(|b| std::cmp::Reverse(b.timestamp));
for item in recent {
use crate::providers::models::ProviderKind;
let provider = ProviderKind::parse(&item.provider).unwrap_or_else(|| {
log::warn!(
"unknown watch-history provider '{}'; defaulting to MovieBox",
item.provider
);
ProviderKind::MovieBox
});
self.state.search_results.push(SearchResult {
id: item.subject_id.clone(),
title: item.title.clone(),
stype: item.stype,
release_year: item.release_year.clone(),
cover_url: item.cover_url.clone(),
season: item.season,
episode: item.episode,
provider,
});
}
self.state.search_list_state.select(Some(0));
self.prefetch_visible_posters();
}
return None;
}
if lower_query == "/favorites" && self.state.favorites_available() {
self.load_favorites_virtual_list();
return None;
}
if self.handle_search_command(&query, &lower_query).is_some() {
return None;
}
if query.trim().starts_with('/') {
return None;
}
if self.state.is_tv_mode {
self.apply_tv_search_results(&query, &lower_query);
return None;
}
let context = self.prepare_search_request(&query);
self.run_search_request(query.clone(), force_refresh, context);
}
Action::FetchHomepage { tab_id, page } => {
if self.state.is_tv_mode {
return None;
}
if self.state.active_provider != ProviderKind::MovieBox {
self.state.is_loading = false;
self.state.set_status_long(
"This provider exposes search, not a shared MovieBox homepage.",
);
return None;
}
self.prepare_homepage_request(&tab_id, page);
self.run_homepage_request(tab_id, page);
}
Action::SelectBrowse(preset) => {
if self.state.active_provider != ProviderKind::MovieBox {
self.state
.set_status_long("Browse is available only with the MovieBox provider.");
return None;
}
self.state.show_browse_popup = false;
self.state.active_browse_preset = Some(preset);
self.state.active_addon_catalog = None;
self.state.browse_list_state.select(None);
self.state.search_query.clear();
self.state.is_loading = true;
self.state.has_search_settled = false;
self.action_sender
.send(Action::FetchHomepage {
tab_id: "2".to_string(),
page: 1,
})
.ok();
}
Action::SelectAddonCatalog(target) => {
self.state.show_browse_popup = false;
self.state.browse_list_state.select(None);
let context = self.prepare_addon_catalog_request(&target);
let request_id = self.state.active_search_request;
let sender = self.action_sender.clone();
let service = self.service.clone();
let manifest_url = target.manifest_url.clone();
let r_type = target.r#type.clone();
let cat_id = target.catalog_id.clone();
self.request_tasks.spawn_search(async move {
let result = service
.fetch_addon_catalog(&manifest_url, &r_type, &cat_id)
.await;
match result {
Ok(items) => {
sender
.send(Action::SearchSuccess {
context,
request_id,
query: String::new(),
page: 1,
items,
})
.ok();
}
Err(error) => {
sender
.send(Action::SearchFailure(context, request_id, 1, error))
.ok();
}
}
});
}
Action::SearchSuccess {
context,
request_id,
query,
page,
items,
} => {
if request_id != self.state.active_search_request {
return None;
}
if !self.context_is_current(context) || query != self.state.search_query.trim() {
if self.state.search_query.trim().is_empty() {
self.state.is_loading = false;
}
return None;
}
self.state.current_page = page;
self.state.search_error = None;
self.state.is_loading = false;
self.state.has_search_settled = true;
let raw_count = items.len();
let mut new_results = Vec::new();
for item in items {
let id = item.id.value.clone();
let raw_title = item.title.clone();
let clean_title = crate::providers::moviebox::clean_moviebox_title(&raw_title);
let normalized_query = query
.to_lowercase()
.replace(|c: char| !c.is_alphanumeric(), "");
let normalized_title = raw_title
.to_lowercase()
.replace(|c: char| !c.is_alphanumeric(), "");
if !normalized_title.contains(&normalized_query) && !normalized_query.is_empty()
{
continue;
}
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();
if let Some(existing) =
self.state.search_results.iter_mut().find(|r| r.id == id)
{
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 = raw_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)
|| new_results
.iter()
.any(|r: &SearchResult| 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
}) || new_results.iter().any(|r: &SearchResult| {
r.title == clean_title && r.release_year == release_year && r.stype == stype
}) {
continue;
}
if !id.is_empty() {
new_results.push(SearchResult {
id,
title: clean_title.to_string(),
stype,
release_year,
cover_url,
season: 0,
episode: 1,
provider: context.provider,
});
}
}
if new_results.is_empty() || raw_count < 15 {
self.state.search_exhausted = true;
}
let sort_results = |results: &mut Vec<SearchResult>, q: &str| {
let query_lower = q.to_lowercase();
results.sort_by(|a, b| {
let a_title = a.title.to_lowercase();
let b_title = b.title.to_lowercase();
let a_exact = a_title == query_lower;
let b_exact = b_title == query_lower;
let a_starts = a_title.starts_with(&query_lower);
let b_starts = b_title.starts_with(&query_lower);
b_exact
.cmp(&a_exact)
.then_with(|| b_starts.cmp(&a_starts))
.then_with(|| b.stype.cmp(&a.stype))
.then_with(|| b.release_year.cmp(&a.release_year))
});
};
let previous_selected_id = if page > 1 {
self.state
.search_list_state
.selected()
.and_then(|idx| self.state.search_results.get(idx).map(|r| r.id.clone()))
} else {
None
};
if page <= 1 {
self.state.search_results = new_results;
sort_results(&mut self.state.search_results, &query);
} else {
sort_results(&mut new_results, &query);
self.state.search_results.extend(new_results);
}
if let Some(prev_id) = previous_selected_id {
if let Some(new_idx) = self
.state
.search_results
.iter()
.position(|r| r.id == prev_id)
{
self.state.search_list_state.select(Some(new_idx));
}
}
if !self.state.search_results.is_empty() {
self.prefetch_visible_posters();
}
if page <= 1 {
self.prepare_image_refresh();
}
self.state
.set_status_default(if self.state.search_results.is_empty() {
format!(
"No matches for '{}' on {}. Press Ctrl+P to try another provider.",
query,
context.provider.label()
)
} else {
format!(
"Found {} results on {}.",
self.state.search_results.len(),
context.provider.label()
)
});
if page <= 1 {
if let Some(res) = self.state.search_results.first() {
self.state.search_list_state.select(Some(0));
self.action_sender
.send(Action::FetchPreview(res.id.clone()))
.ok();
} else {
self.state.search_list_state.select(None);
}
}
}
Action::SearchFailure(context, request_id, page, err) => {
if request_id != self.state.active_search_request {
return None;
}
if !self.context_is_current(context) {
if self.state.search_query.trim().is_empty() {
self.state.is_loading = false;
}
return None;
}
if page > 1 && self.state.current_page >= page {
self.state.current_page = page - 1;
}
log::error!(
"search failed (provider {}): {err}",
context.provider.cache_key()
);
self.state.is_loading = false;
self.state.has_search_settled = true;
if page <= 1 {
self.state.search_results.clear();
self.state.search_list_state.select(None);
self.state.search_preview = None;
self.state.clear_poster_cache();
}
self.state.search_error = Some(err.clone());
self.state
.set_status_default(format!("Search failed: {}", err));
}
Action::HomepageSuccess {
request_id,
tab_id,
page,
items,
metrics,
} => {
if request_id != self.state.active_homepage_request {
return None;
}
if !self.state.is_homepage_mode || self.state.current_tab_id != tab_id {
return None;
}
self.state.is_loading = false;
self.state.has_search_settled = true;
if page == 1 {
self.state.search_results.clear();
self.state.search_error = None;
}
let previous_selected_id = if page > 1 {
self.state
.search_list_state
.selected()
.and_then(|idx| self.state.search_results.get(idx).map(|r| r.id.clone()))
} else {
None
};
self.state
.homepage_cache
.put((tab_id.clone(), page), (items.clone(), metrics.clone()));
let count = self.append_homepage_items(items, metrics);
self.sort_browse_results();
if let Some(prev_id) = previous_selected_id {
if let Some(new_idx) = self
.state
.search_results
.iter()
.position(|r| r.id == prev_id)
{
self.state.search_list_state.select(Some(new_idx));
}
} else if count > 0 && self.state.current_page <= 1 {
self.state.search_list_state.select(Some(0));
if let Some(first) = self.state.search_results.first() {
self.action_sender
.send(Action::FetchPreview(first.id.clone()))
.ok();
}
} else if count == 0 && self.state.current_page <= 1 {
self.state.search_list_state.select(None);
}
if count > 0 {
self.prefetch_visible_posters();
}
if self.state.current_page <= 1 {
self.prepare_image_refresh();
}
let status = self
.state
.active_browse_preset
.map(|preset| {
format!(
"{} · {} items",
preset.label(),
self.state.search_results.len()
)
})
.unwrap_or_else(|| {
format!("Found {} discover items", self.state.search_results.len())
});
self.state.set_status_default(status);
}
Action::HomepageFailure(request_id, err) => {
if request_id != self.state.active_homepage_request {
return None;
}
log::error!("discover failed: {err}");
self.state.is_loading = false;
self.state.has_search_settled = true;
self.state.search_error = Some(format!("Discover failed: {err}"));
self.state.search_results.clear();
self.state.search_list_state.select(None);
self.state.search_preview = None;
self.state.clear_poster_cache();
self.state
.set_status_default(format!("Discover failed: {}", err));
}
Action::FetchDetails(id, force_refresh) => {
let context = self.prepare_details_request(&id);
self.run_details_request(id, force_refresh, context);
}
Action::FetchPreview(id) => {
self.state.active_preview_request =
self.state.active_preview_request.wrapping_add(1);
let request_id = self.state.active_preview_request;
if self.state.is_tv_mode {
self.state.preview_loading = false;
if !self.state.image_cache.contains(&id) {
if let Some(channel) =
self.state.tv_channels.iter().find(|c| c.stream_url == id)
{
let cover_url = channel.logo.clone();
if !cover_url.is_empty() {
let tx = self.action_sender.clone();
let service = self.service.clone();
let id2 = id.clone();
tokio::spawn(async move {
if let Some(img) = service
.fetch_and_decode_cached_poster("iptv", &id2, &cover_url)
.await
{
tx.send(Action::SearchPosterLoaded(id2, Some(img))).ok();
}
});
}
}
}
return None;
}
let prov = self.provider_for_subject(&id);
if prov == ProviderKind::FourKHdHub
|| prov == ProviderKind::BdixCircleFtp
|| prov == ProviderKind::BdixDhakaFlix
{
self.state.preview_loading = false;
self.state.search_preview = None;
self.state.poster_image = None;
self.state.poster_protocol = None;
return None;
}
if let Some(cached) = self.state.preview_cache.get(&id).cloned() {
self.state.preview_loading = false;
self.state.search_preview = Some(cached.clone());
self.state.poster_image = None;
self.state.poster_protocol = None;
if let Some(img) = self.state.image_cache.get(&id) {
self.state.poster_image = Some(std::sync::Arc::clone(img));
} else if self.state.image_supported
&& let Some(url) = cached.cover_url()
{
let url = url.to_string();
let tx = self.action_sender.clone();
let id2 = id.clone();
let service = self.service.clone();
tokio::spawn(async move {
if let Some(img) = service
.fetch_and_decode_cached_poster(prov.cache_key(), &id2, &url)
.await
{
tx.send(Action::PosterSuccess(id2, img)).ok();
}
});
}
return None;
}
self.state.preview_loading = true;
let service = self.service.clone();
let sender = self.action_sender.clone();
let id_clone = id.clone();
tokio::spawn(async move {
if let Ok(Some(cached_disk)) = tokio::task::spawn_blocking({
let id_clone = id_clone.clone();
move || crate::cache::get_provider_details_cache_typed(prov, &id_clone)
})
.await
{
sender
.send(Action::PreviewSuccess(
request_id,
id_clone,
Box::new(cached_disk),
))
.ok();
return;
}
match service.details_typed(prov, &id_clone).await {
Ok(details) => {
let id_save = id_clone.clone();
let det_save = details.clone();
let _ = tokio::task::spawn_blocking(move || {
crate::cache::set_provider_details_cache_typed(
prov, &id_save, &det_save,
)
})
.await;
sender
.send(Action::PreviewSuccess(
request_id,
id_clone,
Box::new(details),
))
.ok();
}
Err(e) => {
sender
.send(Action::PreviewFailure(request_id, e.user_message(prov)))
.ok();
}
}
});
}
Action::PreviewSuccess(request_id, id, details) => {
if request_id != self.state.active_preview_request {
return None;
}
let current_id = if self.state.active_screen == Screen::Details {
self.state
.selected_details
.as_ref()
.map(|d| d.id.value.clone())
} else {
self.state
.search_list_state
.selected()
.and_then(|idx| self.state.search_results.get(idx))
.map(|res| res.id.clone())
};
self.state.preview_loading = false;
if current_id.as_deref() != Some(id.as_str()) {
return None;
}
self.state.preview_cache.put(id.clone(), (*details).clone());
self.state.search_preview = Some((*details).clone());
self.state.poster_image = None;
self.state.poster_protocol = None;
if let Some(cached_img) = self.state.image_cache.get(&id) {
self.state.poster_image = Some(std::sync::Arc::clone(cached_img));
} else if self.state.image_supported
&& let Some(url) = details.cover_url()
{
let url_clone = url.to_string();
let action_tx = self.action_sender.clone();
let id_clone = id.clone();
let service = self.service.clone();
tokio::spawn(async move {
if let Some(img) = service
.fetch_and_decode_cached_poster("posters", &id_clone, &url_clone)
.await
{
let _ = action_tx.send(Action::PosterSuccess(id_clone, img));
}
});
}
}
Action::PosterSuccess(id, img) => {
self.state.image_cache.put(id.clone(), img.clone());
self.state.search_posters.put(id.clone(), img.clone());
let current_id = if self.state.active_screen == Screen::Details {
self.state.active_subject_id.clone()
} else {
self.state
.search_list_state
.selected()
.and_then(|idx| self.state.search_results.get(idx))
.map(|res| res.id.clone())
};
if current_id.as_deref() == Some(id.as_str()) {
self.state.poster_image = Some(img);
self.state.poster_protocol = None;
}
}
Action::SearchPosterLoaded(id, img_opt) => {
self.state.in_flight_posters.remove(&id);
if let Some(img) = img_opt {
self.state
.image_cache
.put(id.clone(), std::sync::Arc::clone(&img));
self.state.search_posters.put(id, img);
} else {
self.state.failed_posters.put(id, std::time::Instant::now());
}
}
Action::PreviewFailure(request_id, err) => {
if request_id != self.state.active_preview_request {
return None;
}
self.state.preview_loading = false;
self.state
.set_status_default(format!("Preview failed: {}", err));
}
Action::DetailsSuccess(context, request_id, id, details) => {
let mut details = *details;
if request_id != self.state.active_details_request {
return None;
}
if !self.details_context_is_current(context, &id)
|| self.state.active_screen != Screen::Details
{
return None;
}
self.state.is_loading = false;
self.state.details_error = None;
if let Some(existing) = &self.state.selected_details {
let is_same_subject = existing.id.value == id
|| existing.dubs.iter().any(|d| d.subject_id == id)
|| details
.dubs
.iter()
.any(|d| d.subject_id == existing.id.value)
|| crate::providers::moviebox::clean_moviebox_title(&existing.title)
== crate::providers::moviebox::clean_moviebox_title(&details.title);
if is_same_subject && existing.id.provider == details.id.provider {
if details.title.trim().is_empty()
|| (!existing.title.trim().is_empty()
&& crate::providers::moviebox::clean_moviebox_title(&details.title)
== crate::providers::moviebox::clean_moviebox_title(
&existing.title,
))
{
details.title = existing.title.clone();
}
let is_placeholder_desc = |desc: &Option<String>| {
desc.as_ref().is_none_or(|d| {
let trimmed = d.trim();
trimmed.is_empty()
|| trimmed == "N/A"
|| crate::providers::moviebox::clean_moviebox_title(trimmed)
== crate::providers::moviebox::clean_moviebox_title(
&details.title,
)
})
};
if is_placeholder_desc(&details.description)
&& !is_placeholder_desc(&existing.description)
{
details.description = existing.description.clone();
}
if details.poster_url.is_none() {
details.poster_url = existing.poster_url.clone();
}
if details.year.is_none() || details.year.as_deref() == Some("N/A") {
details.year = existing.year.clone();
}
if details.duration.is_none()
|| details.duration.as_deref() == Some("N/A")
|| details.duration.as_deref() == Some("")
{
details.duration = existing.duration.clone();
}
if details.genres.is_empty() {
details.genres = existing.genres.clone();
}
if details.imdb_rating.is_none()
|| details.imdb_rating.as_deref() == Some("N/A")
{
details.imdb_rating = existing.imdb_rating.clone();
}
if details.director.is_none() || details.director.as_deref() == Some("N/A")
{
details.director = existing.director.clone();
}
if details.stars.is_none() || details.stars.as_deref() == Some("N/A") {
details.stars = existing.stars.clone();
}
if details.dubs.is_empty() {
details.dubs = existing.dubs.clone();
}
}
}
if let Some(res) = self.state.search_results.iter().find(|r| {
r.id == id
|| details.dubs.iter().any(|d| d.subject_id == r.id)
|| crate::providers::moviebox::clean_moviebox_title(&r.title)
== crate::providers::moviebox::clean_moviebox_title(&details.title)
}) {
if details.title.trim().is_empty() {
details.title = res.title.clone();
}
if details.year.is_none() || details.year.as_deref() == Some("N/A") {
details.year = Some(res.release_year.clone());
}
if details.poster_url.is_none() {
details.poster_url = res.cover_url.clone();
}
}
self.state.active_subject_id = Some(id.clone());
self.state.selected_details = Some(details.clone());
if self.state.poster_image.is_none() {
if let Some(cached_img) = self
.state
.image_cache
.get(&id)
.or_else(|| self.state.search_posters.get(&id))
{
self.state.poster_image = Some(std::sync::Arc::clone(cached_img));
} else if let Some(url) = details.cover_url() {
self.state.history.update_cover_url(&id, url);
if self.state.image_supported {
let url_clone = url.to_string();
let action_tx = self.action_sender.clone();
let id_clone = id.clone();
let service = self.service.clone();
tokio::spawn(async move {
if let Some(img) = service
.fetch_and_decode_cached_poster(
"posters", &id_clone, &url_clone,
)
.await
{
let _ = action_tx.send(Action::PosterSuccess(id_clone, img));
}
});
}
}
}
if !details.seasons.is_empty() {
self.state.available_seasons = details.seasons.clone();
} else if details.media_type == MediaType::Series {
self.state.available_seasons = vec![Season {
number: 1,
episodes: vec![Episode {
season: 1,
number: 1,
title: None,
overview: None,
}],
}];
} else {
self.state.available_seasons.clear();
}
self.state.available_episode_numbers.clear();
for season in &self.state.available_seasons {
let ep_numbers: Vec<usize> = if !season.episodes.is_empty() {
season.episodes.iter().map(|e| e.number).collect()
} else {
vec![1]
};
self.state.available_episode_numbers.push(ep_numbers);
}
let mut default_season = 1;
let mut default_episode = 1;
if let Some(history) = self.state.history.recent.iter().rev().find(|item| {
(ProviderKind::parse(&item.provider) == Some(context.provider)
|| item.provider == context.provider.label()
|| item.provider == context.provider.cache_key())
&& item.subject_id == id
&& item.season > 0
&& item.episode > 0
}) {
default_season = history.season;
if history.completed {
let current_season_eps = self
.state
.available_seasons
.iter()
.find(|s| s.number == history.season)
.map(|s| s.episodes.len())
.unwrap_or(0);
if current_season_eps > 0 && history.episode >= current_season_eps {
default_season = history.season.saturating_add(1);
default_episode = 1;
} else {
default_episode = history.episode.saturating_add(1);
}
} else {
default_episode = history.episode;
}
}
let (target_season, target_episode) = if self.state.language_chosen {
(
if self.state.selected_season > 0 {
self.state.selected_season
} else {
default_season
},
if self.state.selected_episode > 0 {
self.state.selected_episode
} else {
default_episode
},
)
} else {
(default_season, default_episode)
};
let season_idx = self
.state
.available_seasons
.iter()
.position(|s| s.number == target_season)
.unwrap_or(0);
self.state.season_list_state.select(Some(season_idx));
let ep_idx = self
.state
.available_episode_numbers
.get(season_idx)
.and_then(|eps| eps.iter().position(|&e| e == target_episode))
.unwrap_or(0);
self.state.episode_list_state.select(Some(ep_idx));
if !details.dubs.is_empty() {
let find_by_pattern = |patterns: &[&str]| {
details.dubs.iter().position(|dub| {
let lower =
format!("{} {}", dub.language, dub.label).to_ascii_lowercase();
patterns.iter().any(|pat| lower.contains(pat))
})
};
let preferred_idx = if self.state.language_chosen {
details
.dubs
.iter()
.position(|dub| dub.subject_id == id)
.unwrap_or(0)
} else {
find_by_pattern(&["original", "orig"])
.or_else(|| find_by_pattern(&["english", "eng"]))
.unwrap_or(0)
};
self.state.language_list_state.select(Some(preferred_idx));
} else {
self.state.language_list_state.select(Some(0));
}
self.state.selected_season = target_season;
self.state.selected_episode = target_episode;
let has_multiple_dubs = details.has_languages();
if has_multiple_dubs
&& !self.state.language_chosen
&& !self.state.auto_play_on_ready
{
self.state.details_pane = crate::tui::state::DetailsPane::Languages;
self.state.is_loading = false;
self.state.set_status_default("Select a language dubbing.");
} else {
if !self.state.language_chosen {
if details.is_series() && !self.state.available_seasons.is_empty() {
self.state.details_pane = crate::tui::state::DetailsPane::Seasons;
} else {
self.state.details_pane = crate::tui::state::DetailsPane::Streams;
}
}
self.state.is_loading = true;
self.state
.fetch_cancel
.store(false, std::sync::atomic::Ordering::Relaxed);
self.action_sender.send(Action::InitStreamPool(id)).ok();
}
}
Action::DetailsFailure(context, request_id, err) => {
if request_id != self.state.active_details_request {
return None;
}
self.state.auto_play_on_ready = false;
let current_id = self.state.active_subject_id.clone().unwrap_or_default();
if !self.details_context_is_current(context, ¤t_id) {
return None;
}
log::error!(
"details fetch failed (provider {}): {err}",
context.provider.cache_key()
);
self.state.is_loading = false;
self.state.is_resolving_playback = false;
self.state.is_waiting_for_download_stream = false;
if self.state.selected_details.is_none() {
self.state.details_pane = crate::tui::state::DetailsPane::default();
self.state.selected_season = 1;
self.state.selected_episode = 1;
}
self.state.is_fetching_streams = false;
self.state.stream_error = None;
self.state.details_error = Some(err.clone());
self.state
.set_status_default(format!("Details fetch failed: {}", err));
if self.state.active_screen == Screen::Details {
if let Some(id) = self.state.active_subject_id.clone().or_else(|| {
self.state
.selected_details
.as_ref()
.map(|d| d.id.value.clone())
}) {
self.state.active_subject_id = Some(id.clone());
if self.state.poster_image.is_none() {
if let Some(cached_img) = self
.state
.image_cache
.get(&id)
.or_else(|| self.state.search_posters.get(&id))
{
self.state.poster_image = Some(std::sync::Arc::clone(cached_img));
} else if self.state.image_supported
&& let Some(details) = &self.state.selected_details
{
if let Some(url) = details.cover_url() {
let url_clone = url.to_string();
let action_tx = self.action_sender.clone();
let id_clone = id.clone();
let service = self.service.clone();
tokio::spawn(async move {
if let Some(img) = service
.fetch_and_decode_cached_poster(
"posters", &id_clone, &url_clone,
)
.await
{
let _ = action_tx
.send(Action::PosterSuccess(id_clone, img));
}
});
}
}
}
self.action_sender.send(Action::InitStreamPool(id)).ok();
}
}
}
Action::InitStreamPool(subject_id) => {
self.state.is_loading = true;
self.state.is_fetching_streams = true;
self.state.has_streams_settled = false;
self.state.stream_error = None;
self.request_tasks.cancel_stream_pool_init();
self.action_sender
.send(Action::StreamPoolInitialized(subject_id, Vec::new()))
.ok();
}
Action::StreamPoolInitialized(subject_id, resolutions) => {
if Some(&subject_id) != self.state.active_subject_id.as_ref() {
return None;
}
let pool = crate::tui::state::SubjectStreamPool {
available_resolutions: resolutions,
..Default::default()
};
self.state.stream_pool.insert(subject_id.clone(), pool);
let is_series = self
.state
.selected_details
.as_ref()
.is_some_and(|d| d.is_series());
let (se, ep) = if is_series {
let se = if self.state.selected_season > 0 {
self.state.selected_season
} else {
1
};
let ep = if self.state.selected_episode > 0 {
self.state.selected_episode
} else {
1
};
(se, ep)
} else {
(0usize, 0usize)
};
self.state.selected_season = se;
self.state.selected_episode = ep;
let already_loaded = !self.state.selected_resources.is_empty();
if already_loaded {
if let Some(pool) = self.state.stream_pool.get_mut(&subject_id) {
pool.episode_index
.insert((se, ep), self.state.selected_resources.clone());
}
self.state.is_loading = false;
self.state.is_fetching_streams = false;
if self.state.auto_play_on_ready {
self.state.auto_play_on_ready = false;
self.action_sender.send(Action::PlayStream).ok();
}
return None;
}
self.action_sender
.send(Action::FetchEpisodeStreams {
subject_id,
season: se,
episode: ep,
force_refresh: false,
})
.ok();
}
Action::FetchEpisodeStreams {
subject_id,
season,
episode,
force_refresh,
} => {
self.state.active_resource_request =
self.state.active_resource_request.wrapping_add(1);
let request_id = self.state.active_resource_request;
self.state.is_loading = true;
self.state.is_fetching_streams = true;
self.state.has_streams_settled = false;
self.state.selected_resources.clear();
self.state.stream_error = None;
if force_refresh {
if let Some(pool) = self.state.stream_pool.get_mut(&subject_id) {
pool.episode_index.remove(&(season, episode));
}
}
let mut context = self.request_context();
context.provider = self.provider_for_subject(&subject_id);
if !force_refresh {
let id_clone = subject_id.clone();
let prov = context.provider;
let sender = self.action_sender.clone();
let req_id = request_id;
if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {
crate::cache::get_provider_stream_cache_typed(
prov, &id_clone, season, episode,
)
})
.await
{
tokio::spawn(async move {
sender
.send(Action::EpisodeStreamsReady(
context,
req_id,
subject_id.clone(),
season,
episode,
cached,
))
.ok();
});
return None;
}
}
if context.provider == ProviderKind::Addons {
let sender = self.action_sender.clone();
let client = self.service.addon_client.clone();
let addons = self.state.installed_addons.clone();
let id = subject_id.clone();
let is_series = self
.state
.selected_details
.as_ref()
.map(|d| d.is_series())
.unwrap_or_else(|| id.starts_with("series:") || season > 0 || episode > 0);
let has_stream_addons = addons.iter().any(|a| a.enabled && a.provides_stream);
self.request_tasks.spawn_streams(async move {
if !has_stream_addons {
sender
.send(Action::EpisodeStreamsFailed(
context,
request_id,
id,
season,
episode,
"No stream addons enabled. Install via /config.".into(),
))
.ok();
return;
}
let (releases, blocked_addons) =
crate::providers::addons::aggregate_streams(
&client, &addons, &id, season, episode, is_series,
)
.await;
if !blocked_addons.is_empty() {
sender
.send(Action::SetStatus(format!(
"Warning: Blocked {} torrent streams. HTTP only.",
blocked_addons.join(", ")
)))
.ok();
}
if !releases.is_empty() {
let id_clone = id.clone();
let releases_clone = releases.clone();
let provider = context.provider;
tokio::task::spawn_blocking(move || {
crate::cache::set_provider_stream_cache_typed(
provider,
&id_clone,
season,
episode,
&releases_clone,
);
});
sender
.send(Action::EpisodeStreamsReady(
context, request_id, id, season, episode, releases,
))
.ok();
} else {
sender
.send(Action::EpisodeStreamsFailed(
context,
request_id,
id,
season,
episode,
"No streams found. Press 'r' to retry.".into(),
))
.ok();
}
});
return None;
}
if context.provider == ProviderKind::FourKHdHub
|| context.provider == ProviderKind::Dramachi
|| context.provider.is_bdix()
{
let sender = self.action_sender.clone();
let fourk_client = self.service.fourk_client.clone();
let dramachi_client = self.service.dramachi_client.clone();
let circleftp_client = self.service.circleftp_client.clone();
let dhakaflix_client = self.service.dhakaflix_client.clone();
let id = subject_id.clone();
self.request_tasks.spawn_streams(async move {
let result = match context.provider {
ProviderKind::FourKHdHub => {
if let Some(client) = fourk_client.as_ref() {
crate::providers::ReleaseProvider::episode_streams(
client, &id, season, episode,
)
.await
} else {
Err(crate::providers::models::ProviderError::Unavailable(
"4KHDHub provider is unavailable".to_string(),
))
}
}
ProviderKind::Dramachi => {
crate::providers::ReleaseProvider::episode_streams(
&dramachi_client,
&id,
season,
episode,
)
.await
}
ProviderKind::BdixCircleFtp => {
crate::providers::ReleaseProvider::episode_streams(
&circleftp_client,
&id,
season,
episode,
)
.await
}
_ => {
crate::providers::ReleaseProvider::episode_streams(
&dhakaflix_client,
&id,
season,
episode,
)
.await
}
};
match result {
Ok(releases) if !releases.is_empty() => {
let id_clone = id.clone();
let releases_clone = releases.clone();
let provider = context.provider;
tokio::task::spawn_blocking(move || {
crate::cache::set_provider_stream_cache_typed(
provider,
&id_clone,
season,
episode,
&releases_clone,
);
});
sender
.send(Action::EpisodeStreamsReady(
context, request_id, id, season, episode, releases,
))
.ok();
}
Ok(_) => {
sender
.send(Action::EpisodeStreamsFailed(
context,
request_id,
id,
season,
episode,
"No exact release found".into(),
))
.ok();
}
Err(error) => {
sender
.send(Action::EpisodeStreamsFailed(
context,
request_id,
id,
season,
episode,
error.to_string(),
))
.ok();
}
}
});
return None;
}
let pool = self
.state
.stream_pool
.entry(subject_id.clone())
.or_default();
if !force_refresh {
if let Some(cached) = pool.episode_index.get(&(season, episode)) {
self.request_tasks.cancel_streams();
self.action_sender
.send(Action::EpisodeStreamsReady(
context,
request_id,
subject_id.clone(),
season,
episode,
cached.clone(),
))
.ok();
return None;
}
}
let client = self.service.client.clone();
let sender = self.action_sender.clone();
let id_clone = subject_id.clone();
self.request_tasks.spawn_streams(async move {
match crate::providers::ReleaseProvider::episode_streams(
&client, &id_clone, season, episode,
)
.await
{
Ok(streams) => {
sender
.send(Action::EpisodeStreamsReady(
context, request_id, id_clone, season, episode, streams,
))
.ok();
}
Err(err) => {
sender
.send(Action::EpisodeStreamsFailed(
context,
request_id,
id_clone,
season,
episode,
err.to_string(),
))
.ok();
}
}
});
}
Action::EpisodeStreamsReady(
context,
request_id,
subject_id,
target_se,
target_ep,
mut raw_list,
) => {
if request_id != self.state.active_resource_request {
return None;
}
if !self.details_context_is_current(context, &subject_id)
|| Some(&subject_id) != self.state.active_subject_id.as_ref()
{
return None;
}
if target_se != self.state.selected_season
|| target_ep != self.state.selected_episode
{
return None;
}
if let Some(subject_id) = &self.state.active_subject_id {
let id = subject_id.clone();
if let Some(pool) = self.state.stream_pool.get_mut(&id) {
let mut actual_resolutions = std::collections::HashSet::new();
for mut item in raw_list.clone() {
let r = item.resolution_u64();
if r > 0 {
actual_resolutions.insert(r as u32);
}
let mut se = item.season.unwrap_or(0);
let mut ep = item.episode.unwrap_or(0);
if target_se == 0 && target_ep == 0 {
se = 0;
ep = 0;
} else if se == 0 && ep == 0 {
se = target_se;
ep = target_ep;
}
item.season = Some(se);
item.episode = Some(ep);
let entry = pool.episode_index.entry((se, ep)).or_default();
let link = item.direct_url().unwrap_or("");
let mut exists = false;
for i in entry.iter_mut() {
let i_link = i.direct_url().unwrap_or("");
let same_url = if context.provider == ProviderKind::MovieBox {
let base_link = link.split('?').next().unwrap_or(link);
let i_base_link = i_link.split('?').next().unwrap_or(i_link);
!base_link.is_empty()
&& base_link == i_base_link
&& item.quality == i.quality
} else {
!link.is_empty() && link == i_link
};
let same_filename =
!item.filename.is_empty() && item.filename == i.filename;
if same_url || same_filename {
if !item.mirrors.is_empty() && i.mirrors.is_empty() {
i.mirrors = item.mirrors.clone();
}
exists = true;
break;
}
}
if !exists {
entry.push(item);
}
}
if !actual_resolutions.is_empty() {
let mut existing: std::collections::HashSet<u32> =
pool.available_resolutions.iter().cloned().collect();
existing.extend(actual_resolutions);
let mut res_vec: Vec<u32> = existing.into_iter().collect();
res_vec.sort_unstable_by(|a, b| b.cmp(a));
pool.available_resolutions = res_vec;
}
if let Some(target_streams) =
pool.episode_index.get(&(target_se, target_ep))
{
raw_list = target_streams.clone();
} else {
raw_list.clear();
}
}
}
let mut filtered = raw_list;
filtered.sort_by_key(|b| std::cmp::Reverse(b.resolution_u64()));
let count = filtered.len();
if count > 0 {
if let Some(subject_id) = &self.state.active_subject_id {
let id_clone = subject_id.clone();
let filtered_clone = filtered.clone();
tokio::task::spawn_blocking(move || {
crate::cache::set_provider_stream_cache_typed(
context.provider,
&id_clone,
target_se,
target_ep,
&filtered_clone,
);
});
}
}
self.state.selected_resources = filtered;
self.state.is_loading = false;
self.state.is_fetching_streams = false;
self.state.has_streams_settled = true;
self.state.stream_error = None;
let preferred_stream_idx = if count > 0 {
let saved_stream = self
.state
.active_subject_id
.as_deref()
.and_then(|sid| {
self.state.history.get_item(
context.provider.cache_key(),
sid,
target_se,
target_ep,
self.state
.selected_details
.as_ref()
.map(|d| d.title.as_str()),
)
})
.and_then(|item| item.stream_filename.as_deref());
if let Some(target_file) = saved_stream {
self.state
.selected_resources
.iter()
.position(|r| r.filename == target_file)
.or(Some(0))
} else {
Some(0)
}
} else {
None
};
self.state.resource_list_state.select(preferred_stream_idx);
self.state
.set_status_default(format!("{} streams available.", count));
if count > 0 {
if let Some(rid) = self
.state
.selected_resources
.first()
.and_then(|r| r.resource_id.clone())
{
let subject_id = self.state.active_subject_id.clone().unwrap_or_default();
let service = self.service.clone();
let sibling_ids: Vec<String> = self
.state
.selected_details
.as_ref()
.map(|d| d.sibling_ids())
.unwrap_or_default();
let season = self.state.selected_season;
let episode = self.state.selected_episode;
tokio::spawn(async move {
let _ = service
.get_ext_captions(&subject_id, &rid, &sibling_ids, season, episode)
.await;
});
}
}
if self.state.is_waiting_for_download_stream {
self.state.is_waiting_for_download_stream = false;
let is_season_queue = self.state.download_queue_total > 0;
if is_season_queue {
let subject_id = self.state.active_subject_id.clone().unwrap_or_default();
if let Some(rid) = self.get_selected_resource_id() {
let service = self.service.clone();
let sender = self.action_sender.clone();
let pref = self.state.season_subtitle_preference.clone();
let sibling_ids: Vec<String> = self
.state
.selected_details
.as_ref()
.map(|d| {
let mut ids = vec![d.id.value.clone()];
ids.extend(d.dubs.iter().map(|dub| dub.subject_id.clone()));
ids.retain(|s| !s.is_empty());
ids.sort();
ids.dedup();
ids
})
.unwrap_or_default();
let season = self.state.selected_season;
let episode = self.state.selected_episode;
self.request_tasks.spawn_playback_resolve(async move {
if let Ok(res) = service
.get_ext_captions(
&subject_id,
&rid,
&sibling_ids,
season,
episode,
)
.await
{
if pref.is_none() {
sender.send(Action::ShowDownloadSubtitlePopup(res)).ok();
} else if let Some(pref_lang) = pref.flatten() {
let sub_url = res
.into_iter()
.find(|s| s.name == pref_lang)
.map(|s| s.url);
sender.send(Action::DownloadStream(sub_url)).ok();
} else {
sender.send(Action::DownloadStream(None)).ok();
}
} else {
sender.send(Action::DownloadStream(None)).ok();
}
});
return None;
}
}
self.action_sender.send(Action::DownloadStream(None)).ok();
}
if self.state.auto_play_on_ready {
self.state.auto_play_on_ready = false;
self.action_sender.send(Action::PlayStream).ok();
}
}
Action::EpisodeStreamsFailed(
context,
request_id,
subject_id,
target_se,
target_ep,
err,
) => {
if request_id != self.state.active_resource_request {
return None;
}
if !self.details_context_is_current(context, &subject_id)
|| Some(&subject_id) != self.state.active_subject_id.as_ref()
{
return None;
}
if target_se != self.state.selected_season
|| target_ep != self.state.selected_episode
{
return None;
}
self.state.auto_play_on_ready = false;
self.state.is_waiting_for_download_stream = false;
self.state.download_queue.clear();
self.state.download_queue_total = 0;
self.state.season_subtitle_preference = None;
self.state.is_loading = false;
self.state.is_fetching_streams = false;
self.state.has_streams_settled = true;
self.state.selected_resources.clear();
self.state.resource_list_state.select(None);
log::error!(
"episode streams failed ({} s{}e{}): {err}",
context.provider.cache_key(),
target_se,
target_ep
);
let clean_err = if err.contains("No stream sources") {
format!("No streams available on {}.", context.provider.label())
} else if let Some(stripped) =
err.strip_prefix("Provider is temporarily unavailable: ")
{
stripped.to_string()
} else {
err
};
self.state.stream_error = Some(clean_err.clone());
self.state.notify(
crate::tui::overlay::NotificationKind::Error,
"Streams Failed",
clean_err,
);
}
_ => return None,
}
None
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::providers::models::{ProviderKind, Release, SourceMirror};
use std::collections::HashMap;
#[tokio::test]
async fn test_fourkhdhub_releases_not_collapsed_by_query_id() {
let mut app = App::new();
let subject_id = "/obsession-movie-7327/".to_string();
app.state.active_subject_id = Some(subject_id.clone());
app.state.active_provider = ProviderKind::FourKHdHub;
app.state.selected_season = 0;
app.state.selected_episode = 0;
app.state.stream_pool.insert(
subject_id.clone(),
crate::tui::state::SubjectStreamPool {
episode_index: HashMap::new(),
available_resolutions: Vec::new(),
..Default::default()
},
);
let raw_list = vec![
Release {
provider: ProviderKind::FourKHdHub,
filename: "Obsession (2025) 2160p UHD BluRay REMUX".into(),
quality: Some("2160p".into()),
codec: Some("HEVC".into()),
language: None,
size_bytes: Some(50_000_000_000),
season: None,
episode: None,
mirrors: vec![SourceMirror {
label: "Download HubCloud".into(),
resolver_url: "https://greenmotors.club/?id=id1".into(),
headers: vec![],
direct_file: false,
}],
resource_id: None,
},
Release {
provider: ProviderKind::FourKHdHub,
filename: "Obsession (2025) 1080p BluRay REMUX AVC".into(),
quality: Some("1080p".into()),
codec: Some("AVC".into()),
language: None,
size_bytes: Some(25_000_000_000),
season: None,
episode: None,
mirrors: vec![SourceMirror {
label: "Download HubCloud".into(),
resolver_url: "https://greenmotors.club/?id=id2".into(),
headers: vec![],
direct_file: false,
}],
resource_id: None,
},
];
let context = app.request_context();
app.handle_requests(Action::EpisodeStreamsReady(
context,
app.state.active_resource_request,
subject_id,
0,
0,
raw_list,
))
.await;
assert_eq!(app.state.selected_resources.len(), 2);
}
#[tokio::test]
async fn test_details_success_preserves_rich_metadata_across_dub_switch() {
use crate::providers::models::{
AudioTrackOption, MediaDetails, MediaType, ProviderMediaId,
};
let mut app = App::new();
app.state.active_screen = crate::tui::state::Screen::Details;
let original_id = "100".to_string();
let dub_id = "200".to_string();
app.state.selected_details = Some(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: original_id.clone(),
},
title: "Ek Deewane Ki Deewaniyat".to_string(),
media_type: MediaType::Movie,
year: Some("2025".to_string()),
description: Some(
"When a powerful politician falls for a strong-willed superstar...".to_string(),
),
tagline: None,
imdb_rating: Some("4.7".to_string()),
director: Some("Director Name".to_string()),
stars: Some("Actor One, Actor Two".to_string()),
prints: None,
audios: None,
poster_url: Some("https://example.com/poster.jpg".to_string()),
duration: Some("2h 20m".to_string()),
genres: vec!["Romance".to_string(), "Drama".to_string()],
seasons: vec![],
dubs: vec![
AudioTrackOption {
subject_id: original_id.clone(),
language: "Original".to_string(),
label: "Original".to_string(),
},
AudioTrackOption {
subject_id: dub_id.clone(),
language: "Hindi".to_string(),
label: "Hindi".to_string(),
},
],
});
let dub_details = Box::new(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: dub_id.clone(),
},
title: "Ek Deewane Ki Deewaniyat [Hindi]".to_string(),
media_type: MediaType::Movie,
year: Some("2025".to_string()),
description: Some("Ek Deewane Ki Deewaniyat".to_string()),
tagline: None,
imdb_rating: Some("4.7".to_string()),
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
});
let context = app.request_context();
let request_id = app.state.active_details_request;
app.handle_requests(Action::DetailsSuccess(
context,
request_id,
dub_id,
dub_details,
))
.await;
let details = app.state.selected_details.as_ref().unwrap();
assert_eq!(details.duration.as_deref(), Some("2h 20m"));
assert_eq!(
details.description.as_deref(),
Some("When a powerful politician falls for a strong-willed superstar...")
);
assert_eq!(details.title, "Ek Deewane Ki Deewaniyat");
assert_eq!(details.genres, vec!["Romance", "Drama"]);
assert_eq!(details.director.as_deref(), Some("Director Name"));
assert_eq!(details.stars.as_deref(), Some("Actor One, Actor Two"));
assert_eq!(details.dubs.len(), 2);
}
#[tokio::test]
async fn test_search_success_preserves_page_1_order_and_sets_exhausted() {
let mut app = App::new();
app.state.search_query.set_content("deewaniyat");
let context = app.request_context();
let request_id = app.state.active_search_request;
let page1_items = vec![
crate::providers::models::CatalogItem {
id: crate::providers::models::ProviderMediaId {
value: "1".into(),
provider: ProviderKind::MovieBox,
},
title: "Deewaniyat".into(),
media_type: crate::models::MediaType::Series,
year: Some("2024".into()),
poster_url: None,
season_count: None,
},
crate::providers::models::CatalogItem {
id: crate::providers::models::ProviderMediaId {
value: "2".into(),
provider: ProviderKind::MovieBox,
},
title: "Ek Deewane Ki Deewaniyat".into(),
media_type: crate::models::MediaType::Movie,
year: Some("2025".into()),
poster_url: None,
season_count: None,
},
];
app.handle_requests(Action::SearchSuccess {
context,
request_id,
query: "deewaniyat".into(),
page: 1,
items: page1_items,
})
.await;
assert_eq!(app.state.search_results.len(), 2);
assert_eq!(app.state.search_results[0].title, "Deewaniyat");
assert_eq!(
app.state.search_results[1].title,
"Ek Deewane Ki Deewaniyat"
);
assert!(app.state.search_exhausted);
app.handle_requests(Action::SearchSuccess {
context,
request_id,
query: "deewaniyat".into(),
page: 2,
items: vec![],
})
.await;
assert_eq!(app.state.search_results.len(), 2);
assert!(app.state.search_exhausted);
}
#[tokio::test]
async fn test_episode_streams_auto_selects_saved_stream_filename() {
let mut app = App::new();
app.state.active_provider = ProviderKind::FourKHdHub;
let context = app.request_context();
app.state.active_subject_id = Some("dune-2021".to_string());
app.state.selected_details = Some(crate::providers::models::MediaDetails {
id: crate::providers::models::ProviderMediaId {
provider: ProviderKind::FourKHdHub,
value: "dune-2021".to_string(),
},
title: "Dune".to_string(),
media_type: crate::models::MediaType::Movie,
year: Some("2021".to_string()),
description: None,
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
});
let hist = crate::history::WatchHistoryItem {
provider: "4khdhub".to_string(),
subject_id: "dune-2021".to_string(),
title: "Dune".to_string(),
cover_url: None,
stype: 1,
release_year: "2021".to_string(),
season: 1,
episode: 1,
timestamp: 1000,
duration_seconds: Some(7200),
progress_seconds: 1500,
completed: false,
stream_filename: Some("Dune.1080p.mkv".to_string()),
};
app.state.history.recent.push(hist);
let streams = vec![
Release {
provider: ProviderKind::FourKHdHub,
filename: "Dune.2160p.mkv".to_string(),
quality: Some("2160p".to_string()),
codec: Some("hevc".to_string()),
language: None,
size_bytes: Some(15000000000),
season: None,
episode: None,
mirrors: vec![],
resource_id: None,
},
Release {
provider: ProviderKind::FourKHdHub,
filename: "Dune.1080p.mkv".to_string(),
quality: Some("1080p".to_string()),
codec: Some("hevc".to_string()),
language: None,
size_bytes: Some(3000000000),
season: None,
episode: None,
mirrors: vec![],
resource_id: None,
},
Release {
provider: ProviderKind::FourKHdHub,
filename: "Dune.720p.mkv".to_string(),
quality: Some("720p".to_string()),
codec: Some("h264".to_string()),
language: None,
size_bytes: Some(1000000000),
season: None,
episode: None,
mirrors: vec![],
resource_id: None,
},
];
app.handle_requests(Action::EpisodeStreamsReady(
context,
0,
"dune-2021".to_string(),
1,
1,
streams,
))
.await;
assert_eq!(app.state.resource_list_state.selected(), Some(1));
}
}