Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
refactor(core): modernize provider traits, task cancellation, and tui architecture
Samir Hossains15a3a29644c3
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 6e2c7d9..b51fd95 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -3,11 +3,21 @@## [Unreleased]### Added+- **Core Domain Typing & Modernized Provider Traits (`src/models.rs`, `src/providers/`)**:+ - Refactored `Provider` and `ReleaseProvider` trait methods to return strongly typed domain models (`Result<Vec<CatalogItem>, ProviderError>`, `Result<MediaDetails, ProviderError>`, and `Result<Vec<Release>, ProviderError>`) instead of untyped `serde_json::Value` objects.+ - Introduced structured, classified error boundaries (`ProviderError`) with automatic user notification formatting via `.user_message(provider)` and `From` conversions for provider client errors (`ScraperError`, `FourKHdHubError`, `CircleFtpError`, `DhakaFlixError`).+ - Added strongly typed domain adapters (`moviebox_search_json_to_catalog`, `moviebox_details_json_to_media_details`, `meta_to_catalog_item`, `meta_detail_to_media_details`) and exposed `search_typed` and `details_typed` on `MovieBoxService`.+- **In-Flight Async Task Tracking & Cancellation (`RequestTaskHandles`)**:+ - Added `RequestTaskHandles` to `App` with atomic `JoinHandle::abort` cancellation triggers (`cancel_search`, `cancel_details`, `cancel_streams`, `cancel_suggest`, `cancel_homepage`, `cancel_all`), preventing stale network requests and CPU leaks when navigating or changing search queries.+- **AppState Domain Partitioning & Sub-States (`src/tui/state.rs`)**:+ - Partitioned the monolithic `AppState` into cohesive domain sub-states (`UiState`, `CatalogState`, `PlaybackState`, `DownloadState`) to decouple modal UI flags, search catalogs, playback handles, and download queues.+- **Unified Header-Aware List Navigation (`src/tui/state.rs`, `src/tui/app/keyboard.rs`)**:+ - Consolidated duplicate manager list wrapping, header-skipping, and step math into reusable helpers (`step_header_aware_list`, `step_tv_manager_selected`, `step_addon_manager_selected`, `first_*`, `last_*`).+- **Unified Screen Layout & Mouse Hitbox Geometry (`src/tui/screens/details.rs`, `src/tui/app/mouse.rs`)**:+ - Exported `DetailsScreenLayout` and `details_screen_layout` so both visual rendering and mouse hit-testing derive from identical calculated rect bounds across all viewport tiers.+- **Centralized Slash Command Dispatch & Complete Command Inventory (`src/tui/commands.rs`, `src/tui/app/search.rs`)**:+ - Centralized command input-clearing pre-conditions and expanded `SlashCommand::ALL` to all 19 registered variants.- **Unified Interactive Settings & Preferences Hub (`/settings`)**: Introduced a consolidated, mouse-friendly modal dialog replacing fragmented slash commands. Features 4 categorized tabs (`General`, `Content Modes`, `Appearance`, `Maintenance`), installed media player selection via interactive popup picker, live visual theme palette swatch picker integration, inline download directory editing, and multi-mode toggling with safety guards. Streamlined slash command autocomplete suggestions and in-app help overlays while retaining full legacy command compatibility.-- **Stream list tabular column headers (`stream_table_header_spans`)**: Rendered aligned header row (`Quality`, `Size`, `Codecs`, `Duration`, `Release / Source`) at the top of stream results in the Details view on viewports $\ge 76$ columns.-- **Vim navigation in Theme picker (`j` / `k`)**: Added `j` (down) and `k` (up) key support to navigate and live-preview themes inside the `/theme` picker popup.-- **Live stream verification test suite (`tests/live_stream_verification.rs`)**: Integrated end-to-end verification verifying movie and series stream resolution against live backend endpoints and asserting absence of legacy notice hashes.-- **Unified Command Hub landing design**: Redesigned the homepage landing screen into a single cohesive, proportional modal container seamlessly combining the search bar, embedded provider pill (`[MovieBox · Ctrl+P]`), live suggestions, recent favorites, and quick command shortcuts.- **Details Screen Subtitles Shortcut (`[s]`)**: Added `s`/`S` keyboard shortcut on Details screen to open the subtitle language picker, matching mouse click and footer hints.- **Theme picker 3-point color swatches**: Rendered 3-point color swatches (`■ ■ ■` Accent | Surface | Base) previewing palette colors in `/theme`.- **Category origin pill badges**: Added `[MOVIES]`, `[SERIES]`, and `[DISCOVER]` category badges in the `/browse` preset dialog.diff --git a/docs/controls.md b/docs/controls.mdindex 7425829..eb81149 100644--- a/docs/controls.md+++ b/docs/controls.md@@ -117,9 +117,19 @@ Type these commands directly into the search bar:| `/favorites` | Streaming / Addon | View all starred titles || `/theme` | All | Open visual theme palette swatch picker || `/clear` | All | Clear search results and return to landing |-| `/help` | All | Open interactive keybinding help menu |+| `/help` | All | Open interactive keybinding help menu (alias `/?`) || `/list` | TV | View live TV channels |-## Help Overlay+| `/config` | All | Open mode-specific configuration dialog (TV Playlists, Addons, or Settings) |+| `/download-dir [path]` | All | View or configure custom media download folder (`reset` for default) |+| `/update` | All | Trigger interactive manual update check against GitHub |+| `/clear-cache` | All | Evict temporary cache files and image artifacts |+| `/github` | All | Open MovieBox-TUI GitHub repository in default browser |+| `/toggle-update` | All | Toggle automatic update checks on startup |+| `/toggle-bdix` | Streaming | Toggle BDIX FTP scrapers on/off |+| `/toggle-streaming` | All | Toggle Streaming Mode content availability |+| `/toggle-tv` | All | Toggle TV Mode IPTV player |+| `/toggle-addons` | All | Toggle Addon Mode HTTP metadata/stream extensions |+| `/probe` | All | Re-probe terminal graphics protocol support (Kitty, Sixel, iTerm2) |- Open with `?`; close with `?`, `Esc`, or `q`.- `↑`/`↓`, `PageUp`/`PageDown`, and the mouse wheel scroll long content.diff --git a/docs/known-issues.md b/docs/known-issues.mdindex 6b21e15..163d893 100644--- a/docs/known-issues.md+++ b/docs/known-issues.md@@ -28,7 +28,7 @@ Tracked here so future work and issue reports reference the same facts.Termux launch is observed.## Verification--- Automated testing is enforced via `cargo test --all-features --locked` covering 284 unit and integration tests across 18 test suites (see [`docs/testing.md`](testing.md)). The count is updated when tests change; it does not replace real-player and real-device verification.++- Automated testing is enforced via `cargo test --all-features --locked` covering 296+ unit and integration tests across 19 test suites (see [`docs/testing.md`](testing.md)). The count is updated when tests change; it does not replace real-player and real-device verification.- Static correctness is enforced by strict compiler type checking, the lint gate (`cargo clippy --all-targets --all-features --locked -- -D warnings`), formatting (`cargo fmt --check`), dependency vulnerability scanning (`cargo audit`), and packaging verification (`cargo package --locked`).- Runtime and platform-specific behavior (terminal resize, focus handling, external player launch, and Termux chooser) are verified through the release checklist in [`release-checklist.md`](release-checklist.md).diff --git a/docs/testing.md b/docs/testing.mdindex fc806bc..459e26b 100644--- a/docs/testing.md+++ b/docs/testing.md@@ -4,7 +4,7 @@ This document describes the testing architecture, quality assurance procedures,## 1. Test Architecture-The test suite comprises **284 automated tests across 18 test suites** (151 unit tests in `src/lib.rs`, 0 binary tests in `src/main.rs`, and 133 integration tests across 17 test suites in `tests/`), running fully offline by default without mocking or live network dependencies.+The test suite comprises **296+ automated tests across 19 test suites** (158 unit tests in `src/lib.rs`, 0 binary tests in `src/main.rs`, and 138 integration tests across 18 test suites in `tests/`), running fully offline by default without mocking or live network dependencies.The MovieBox-TUI test architecture follows a strict separation of concerns:@@ -20,6 +20,7 @@ MovieBox-TUI/│ │ └── sample_playlist.m3u│ └── addons/│ └── manifest.json+ ├── settings_hub.rs # Interactive Settings Hub modal tab navigation, choices, & option rows├── history_reconciliation.rs # History identity & background state reconciliation├── history_audit.rs # Cross-mode watch progress, series advancement, & boundary audit├── grand_user_journey.rs # End-to-end full multi-phase user lifecycle verificationdiff --git a/src/models.rs b/src/models.rsindex 9c7f668..87a78e6 100644--- a/src/models.rs+++ b/src/models.rs@@ -1,4 +1,12 @@-pub use crate::providers::models::ProviderKind;+pub use crate::providers::models::{+ CatalogItem, Episode, MediaDetails, MediaType, PlaybackSource, ProviderError, ProviderKind,+ ProviderMediaId, Release, Season, SourceMirror, SubtitleOption,+};++pub type SeasonInfo = Season;+pub type EpisodeInfo = Episode;+pub type StreamResource = Release;+pub type StreamMirror = SourceMirror;use serde::{Deserialize, Serialize};use std::collections::{HashMap, HashSet};use std::time::{Duration, Instant};diff --git a/src/providers/addons/adapter.rs b/src/providers/addons/adapter.rsindex e99f4cb..877bb47 100644--- a/src/providers/addons/adapter.rs+++ b/src/providers/addons/adapter.rs@@ -1,6 +1,9 @@use super::models::{MetaDetail, MetaItem, StreamItem};use crate::models::SearchResult;-use crate::providers::models::{PlaybackSource, ProviderKind, Release, SourceMirror};+use crate::providers::models::{+ CatalogItem, Episode, MediaDetails, MediaType, PlaybackSource, ProviderKind, ProviderMediaId,+ Release, Season, SourceMirror,+};use std::collections::BTreeMap;pub fn meta_to_search_result(item: &MetaItem) -> SearchResult {@@ -35,6 +38,135 @@ pub fn meta_to_search_result(item: &MetaItem) -> SearchResult {}}+pub fn meta_to_catalog_item(item: &MetaItem) -> CatalogItem {+ let is_series = item.r#type.eq_ignore_ascii_case("series")+ || item.r#type.eq_ignore_ascii_case("tv")+ || item.r#type.eq_ignore_ascii_case("anime");+ let year: Option<String> = item+ .release_info+ .as_deref()+ .or(item.year.as_deref())+ .or(item.released.as_deref())+ .map(crate::tui::text::extract_4digit_year)+ .filter(|y| !y.is_empty());++ let title = if !item.name.trim().is_empty() {+ item.name.clone()+ } else {+ item.title.clone().unwrap_or_else(|| "Unknown".to_string())+ };++ let poster_url = item.poster.clone().or_else(|| item.cover.clone());++ CatalogItem {+ id: ProviderMediaId {+ provider: ProviderKind::Addons,+ value: item.id.clone(),+ },+ title,+ media_type: if is_series {+ MediaType::Series+ } else {+ MediaType::Movie+ },+ year,+ poster_url,+ season_count: None,+ }+}++pub fn meta_detail_to_media_details(detail: &MetaDetail) -> MediaDetails {+ let is_series = detail.r#type.eq_ignore_ascii_case("series")+ || detail.r#type.eq_ignore_ascii_case("tv")+ || detail.r#type.eq_ignore_ascii_case("anime")+ || !detail.videos.is_empty();++ let mut season_map: BTreeMap<usize, Vec<usize>> = BTreeMap::new();+ for video in &detail.videos {+ let s = video.season.unwrap_or(1);+ let e = video.episode.unwrap_or(1);+ let eps = season_map.entry(s).or_default();+ if !eps.contains(&e) {+ eps.push(e);+ }+ }++ for eps in season_map.values_mut() {+ eps.sort_unstable();+ }++ let seasons = season_map+ .into_iter()+ .map(|(season_num, eps)| Season {+ number: season_num,+ episodes: eps+ .into_iter()+ .map(|ep_num| Episode {+ season: season_num,+ number: ep_num,+ title: None,+ })+ .collect(),+ })+ .collect::<Vec<_>>();++ let year = detail+ .release_info+ .as_deref()+ .or(detail.year.as_deref())+ .or(detail.released.as_deref())+ .map(crate::tui::text::extract_4digit_year)+ .filter(|y| !y.is_empty());++ let title = if !detail.name.trim().is_empty() {+ detail.name.clone()+ } else {+ detail+ .title+ .clone()+ .unwrap_or_else(|| "Unknown".to_string())+ };++ let poster_url = detail.poster.clone().or_else(|| detail.cover.clone());++ MediaDetails {+ id: ProviderMediaId {+ provider: ProviderKind::Addons,+ value: detail.id.clone(),+ },+ title,+ media_type: if is_series {+ MediaType::Series+ } else {+ MediaType::Movie+ },+ year,+ description: detail.description.clone(),+ tagline: None,+ imdb_rating: detail.imdb_rating.clone().or_else(|| detail.rating.clone()),+ director: if !detail.director.is_empty() {+ Some(detail.director.join(", "))+ } else {+ None+ },+ stars: if !detail.cast.is_empty() {+ Some(detail.cast.join(", "))+ } else {+ None+ },+ prints: None,+ audios: None,+ poster_url,+ duration: detail.runtime.clone(),+ genres: if !detail.genres.is_empty() {+ detail.genres.clone()+ } else {+ detail.genre.clone()+ },+ seasons,+ }+}+pub fn metas_to_moviebox_search_json(metas: Vec<MetaItem>) -> serde_json::Value {let mut seen_ids = std::collections::HashSet::new();let subjects = metas@@ -621,3 +753,100 @@ pub fn release_to_playback_source(release: &Release) -> Option<PlaybackSource> {source_label: mirror.label.clone(),})}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn test_meta_to_catalog_item() {+ let item = MetaItem {+ id: "tt1234".to_string(),+ r#type: "movie".to_string(),+ name: "Test Movie".to_string(),+ title: None,+ poster: Some("https://example.com/poster.jpg".to_string()),+ cover: None,+ description: Some("Description".to_string()),+ overview: None,+ synopsis: None,+ release_info: Some("2022".to_string()),+ year: None,+ released: None,+ imdb_rating: Some("7.5".to_string()),+ rating: None,+ genres: vec!["Action".to_string()],+ genre: Vec::new(),+ };++ let catalog = meta_to_catalog_item(&item);+ assert_eq!(catalog.id.value, "tt1234");+ assert_eq!(catalog.title, "Test Movie");+ assert_eq!(catalog.media_type, MediaType::Movie);+ assert_eq!(catalog.year.as_deref(), Some("2022"));+ assert_eq!(+ catalog.poster_url.as_deref(),+ Some("https://example.com/poster.jpg")+ );+ }++ #[test]+ fn test_meta_detail_to_media_details() {+ let detail = MetaDetail {+ id: "tt5678".to_string(),+ r#type: "series".to_string(),+ name: "Test Series".to_string(),+ title: None,+ poster: Some("https://example.com/series.jpg".to_string()),+ cover: None,+ background: None,+ logo: None,+ description: Some("Series description".to_string()),+ overview: None,+ synopsis: None,+ release_info: Some("2021".to_string()),+ year: None,+ released: None,+ imdb_rating: Some("8.2".to_string()),+ rating: None,+ genres: vec!["Drama".to_string()],+ genre: Vec::new(),+ runtime: Some("45m".to_string()),+ cast: vec!["Actor One".to_string(), "Actor Two".to_string()],+ director: vec!["Director Name".to_string()],+ videos: vec![+ super::super::models::MetaVideo {+ id: Some("ep1".to_string()),+ title: Some("Pilot".to_string()),+ name: None,+ season: Some(1),+ episode: Some(1),+ number: None,+ released: None,+ thumbnail: None,+ },+ super::super::models::MetaVideo {+ id: Some("ep2".to_string()),+ title: Some("Episode 2".to_string()),+ name: None,+ season: Some(1),+ episode: Some(2),+ number: None,+ released: None,+ thumbnail: None,+ },+ ],+ };++ let media = meta_detail_to_media_details(&detail);+ assert_eq!(media.id.value, "tt5678");+ assert_eq!(media.title, "Test Series");+ assert_eq!(media.media_type, MediaType::Series);+ assert_eq!(media.year.as_deref(), Some("2021"));+ assert_eq!(media.director.as_deref(), Some("Director Name"));+ assert_eq!(media.stars.as_deref(), Some("Actor One, Actor Two"));+ assert_eq!(media.seasons.len(), 1);+ assert_eq!(media.seasons[0].number, 1);+ assert_eq!(media.seasons[0].episodes.len(), 2);+ }+}diff --git a/src/providers/addons/mod.rs b/src/providers/addons/mod.rsindex 5b5cb55..417a98d 100644--- a/src/providers/addons/mod.rs+++ b/src/providers/addons/mod.rs@@ -3,12 +3,15 @@ pub mod aggregator;pub mod client;pub mod models;-pub use adapter::{meta_detail_to_moviebox_json, meta_to_search_result, releases_to_moviebox_json};+pub use adapter::{+ meta_detail_to_media_details, meta_detail_to_moviebox_json, meta_to_catalog_item,+ meta_to_search_result, releases_to_moviebox_json,+};pub use aggregator::aggregate_streams;pub use client::AddonClient;pub use models::{AddonManifest, InstalledAddon, MetaDetail, MetaItem, StreamItem};-use crate::providers::models::ProviderKind;+use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind};use crate::providers::{Provider, ProviderCapabilities};impl Provider for AddonClient {@@ -26,11 +29,11 @@ impl Provider for AddonClient {}}- async fn search(&self, _query: &str, _page: usize) -> Result<serde_json::Value, String> {- Ok(serde_json::json!({ "list": [] }))+ async fn search(&self, _query: &str, _page: usize) -> Result<Vec<CatalogItem>, ProviderError> {+ Ok(Vec::new())}- async fn details(&self, _id: &str) -> Result<serde_json::Value, String> {- Ok(serde_json::json!({}))+ async fn details(&self, _id: &str) -> Result<MediaDetails, ProviderError> {+ Err(ProviderError::NotFound)}}diff --git a/src/providers/bdix/circleftp/mod.rs b/src/providers/bdix/circleftp/mod.rsindex 6531384..d1b8a5c 100644--- a/src/providers/bdix/circleftp/mod.rs+++ b/src/providers/bdix/circleftp/mod.rs@@ -3,11 +3,17 @@ pub mod parser;pub use client::{CircleFtpClient, CircleFtpError};-use crate::providers::models::{ProviderKind, Release};-use crate::providers::{- Provider, ProviderCapabilities, ReleaseProvider,- fourkhdhub::{details_to_moviebox_json, search_to_moviebox_json},-};+use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind, Release};+use crate::providers::{Provider, ProviderCapabilities, ReleaseProvider};++impl From<CircleFtpError> for ProviderError {+ fn from(err: CircleFtpError) -> Self {+ match err {+ CircleFtpError::Network(e) => ProviderError::Network(e.to_string()),+ CircleFtpError::Parse(p) => ProviderError::Parsing(p),+ }+ }+}impl Provider for client::CircleFtpClient {fn id(&self) -> ProviderKind {@@ -24,18 +30,12 @@ impl Provider for client::CircleFtpClient {}}- async fn search(&self, query: &str, _page: usize) -> Result<serde_json::Value, String> {- self.search(query)- .await- .map(|items| search_to_moviebox_json(&items))- .map_err(|error| error.to_string())+ async fn search(&self, query: &str, _page: usize) -> Result<Vec<CatalogItem>, ProviderError> {+ self.search(query).await.map_err(ProviderError::from)}- async fn details(&self, id: &str) -> Result<serde_json::Value, String> {- self.details(id)- .await- .map(|details| details_to_moviebox_json(&details))- .map_err(|error| error.to_string())+ async fn details(&self, id: &str) -> Result<MediaDetails, ProviderError> {+ self.details(id).await.map_err(ProviderError::from)}}@@ -45,9 +45,9 @@ impl ReleaseProvider for client::CircleFtpClient {id: &str,season: usize,episode: usize,- ) -> Result<Vec<Release>, String> {+ ) -> Result<Vec<Release>, ProviderError> {self.releases(id, Some(season), Some(episode)).await- .map_err(|error| error.to_string())+ .map_err(ProviderError::from)}}diff --git a/src/providers/bdix/dhakaflix/mod.rs b/src/providers/bdix/dhakaflix/mod.rsindex f5bf464..7a727b0 100644--- a/src/providers/bdix/dhakaflix/mod.rs+++ b/src/providers/bdix/dhakaflix/mod.rs@@ -1,10 +1,18 @@pub mod client;-use crate::providers::models::{ProviderKind, Release};-use crate::providers::{- Provider, ProviderCapabilities, ReleaseProvider,- fourkhdhub::{details_to_moviebox_json, search_to_moviebox_json},-};+pub use client::{DhakaFlixClient, DhakaFlixError};++use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind, Release};+use crate::providers::{Provider, ProviderCapabilities, ReleaseProvider};++impl From<DhakaFlixError> for ProviderError {+ fn from(err: DhakaFlixError) -> Self {+ match err {+ DhakaFlixError::Network(e) => ProviderError::Network(e.to_string()),+ DhakaFlixError::Parse(p) => ProviderError::Parsing(p),+ }+ }+}impl Provider for client::DhakaFlixClient {fn id(&self) -> ProviderKind {@@ -21,18 +29,12 @@ impl Provider for client::DhakaFlixClient {}}- async fn search(&self, query: &str, _page: usize) -> Result<serde_json::Value, String> {- self.search(query)- .await- .map(|items| search_to_moviebox_json(&items))- .map_err(|error| error.to_string())+ async fn search(&self, query: &str, _page: usize) -> Result<Vec<CatalogItem>, ProviderError> {+ self.search(query).await.map_err(ProviderError::from)}- async fn details(&self, id: &str) -> Result<serde_json::Value, String> {- self.details(id)- .await- .map(|details| details_to_moviebox_json(&details))- .map_err(|error| error.to_string())+ async fn details(&self, id: &str) -> Result<MediaDetails, ProviderError> {+ self.details(id).await.map_err(ProviderError::from)}}@@ -42,7 +44,7 @@ impl ReleaseProvider for client::DhakaFlixClient {id: &str,_season: usize,_episode: usize,- ) -> Result<Vec<Release>, String> {- self.streams(id).await.map_err(|error| error.to_string())+ ) -> Result<Vec<Release>, ProviderError> {+ self.streams(id).await.map_err(ProviderError::from)}}diff --git a/src/providers/fourkhdhub/mod.rs b/src/providers/fourkhdhub/mod.rsindex dfcb6c5..96b8fb0 100644--- a/src/providers/fourkhdhub/mod.rs+++ b/src/providers/fourkhdhub/mod.rs@@ -5,9 +5,20 @@ mod parser;pub use client::{FourKHdHubClient, FourKHdHubError};pub use parser::{details_to_moviebox_json, releases_to_moviebox_json, search_to_moviebox_json};-use crate::providers::models::{ProviderKind, Release};+use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind, Release};use crate::providers::{Provider, ProviderCapabilities, ReleaseProvider};+impl From<FourKHdHubError> for ProviderError {+ fn from(err: FourKHdHubError) -> Self {+ match err {+ FourKHdHubError::Network(e) => ProviderError::Network(e.to_string()),+ FourKHdHubError::InvalidUrl(u) => ProviderError::Parsing(format!("Invalid URL: {u}")),+ FourKHdHubError::Parse(p) => ProviderError::Parsing(p),+ FourKHdHubError::NoPlayableMirror(_) => ProviderError::NotFound,+ }+ }+}+impl Provider for FourKHdHubClient {fn id(&self) -> ProviderKind {ProviderKind::FourKHdHub@@ -23,18 +34,12 @@ impl Provider for FourKHdHubClient {}}- async fn search(&self, query: &str, _page: usize) -> Result<serde_json::Value, String> {- self.search(query)- .await- .map(|items| search_to_moviebox_json(&items))- .map_err(|error| error.to_string())+ async fn search(&self, query: &str, _page: usize) -> Result<Vec<CatalogItem>, ProviderError> {+ self.search(query).await.map_err(ProviderError::from)}- async fn details(&self, id: &str) -> Result<serde_json::Value, String> {- self.details(id)- .await- .map(|details| details_to_moviebox_json(&details))- .map_err(|error| error.to_string())+ async fn details(&self, id: &str) -> Result<MediaDetails, ProviderError> {+ self.details(id).await.map_err(ProviderError::from)}}@@ -44,9 +49,9 @@ impl ReleaseProvider for FourKHdHubClient {id: &str,season: usize,episode: usize,- ) -> Result<Vec<Release>, String> {+ ) -> Result<Vec<Release>, ProviderError> {self.releases(id, season, episode).await- .map_err(|error| error.to_string())+ .map_err(ProviderError::from)}}diff --git a/src/providers/mod.rs b/src/providers/mod.rsindex b88d754..d57a5d1 100644--- a/src/providers/mod.rs+++ b/src/providers/mod.rs@@ -7,7 +7,10 @@ pub mod tv;pub use tv as m3u;-use models::{ProviderKind, Release};+pub use models::{+ CatalogItem, Episode, MediaDetails, MediaType, PlaybackSource, ProviderError, ProviderKind,+ ProviderMediaId, Release, Season, SourceMirror, SubtitleOption,+};use serde::{Deserialize, Serialize};#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]@@ -31,45 +34,12 @@ impl Default for ProviderCapabilities {}}-#[derive(Debug, thiserror::Error, Clone)]-pub enum ProviderError {- #[error("Network connection failed: {0}")]- Network(String),-- #[error("Rate limited by provider")]- RateLimited(Option<u64>),-- #[error("Item not found on provider")]- NotFound,-- #[error("Failed to parse response: {0}")]- Parsing(String),-- #[error("Provider is temporarily unavailable: {0}")]- Unavailable(String),-}--impl ProviderError {- pub fn user_message(&self, provider: ProviderKind) -> String {- match self {- Self::Network(msg) => format!("Network error on {provider}: {msg}"),- Self::RateLimited(secs) => match secs {- Some(s) => format!("Rate limited on {provider}. Retry in {s}s."),- None => format!("Rate limited on {provider}."),- },- Self::NotFound => format!("Content not found on {provider}."),- Self::Parsing(msg) => format!("Parser error on {provider}: {msg}"),- Self::Unavailable(msg) => format!("{provider} unavailable: {msg}"),- }- }-}-#[allow(async_fn_in_trait)]pub trait Provider: Send + Sync {fn id(&self) -> ProviderKind;fn capabilities(&self) -> ProviderCapabilities;- async fn search(&self, query: &str, page: usize) -> Result<serde_json::Value, String>;- async fn details(&self, id: &str) -> Result<serde_json::Value, String>;+ async fn search(&self, query: &str, page: usize) -> Result<Vec<CatalogItem>, ProviderError>;+ async fn details(&self, id: &str) -> Result<MediaDetails, ProviderError>;}#[allow(async_fn_in_trait)]@@ -79,5 +49,5 @@ pub trait ReleaseProvider: Send + Sync {id: &str,season: usize,episode: usize,- ) -> Result<Vec<Release>, String>;+ ) -> Result<Vec<Release>, ProviderError>;}diff --git a/src/providers/models.rs b/src/providers/models.rsindex 5520184..3879fe6 100644--- a/src/providers/models.rs+++ b/src/providers/models.rs@@ -174,3 +174,43 @@ impl PlaybackSource {}}}+#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub enum ProviderError {+ #[error("Network connection failed: {0}")]+ Network(String),+ #[error("Rate limited by provider")]+ RateLimited(Option<u64>),+ #[error("Item not found on provider")]+ NotFound,+ #[error("Failed to parse response: {0}")]+ Parsing(String),+ #[error("Provider is temporarily unavailable: {0}")]+ Unavailable(String),+}++impl ProviderError {+ pub fn user_message(&self, provider: ProviderKind) -> String {+ match self {+ Self::Network(msg) => format!("Network error on {provider}: {msg}"),+ Self::RateLimited(secs) => match secs {+ Some(s) => format!("Rate limited on {provider}. Retry in {s}s."),+ None => format!("Rate limited on {provider}."),+ },+ Self::NotFound => format!("Content not found on {provider}."),+ Self::Parsing(msg) => format!("Parser error on {provider}: {msg}"),+ Self::Unavailable(msg) => format!("{provider} unavailable: {msg}"),+ }+ }+}++impl From<String> for ProviderError {+ fn from(msg: String) -> Self {+ Self::Unavailable(msg)+ }+}++impl From<&str> for ProviderError {+ fn from(msg: &str) -> Self {+ Self::Unavailable(msg.to_string())+ }+}diff --git a/src/providers/moviebox/adapt.rs b/src/providers/moviebox/adapt.rsindex 628afda..685f300 100644--- a/src/providers/moviebox/adapt.rs+++ b/src/providers/moviebox/adapt.rs@@ -1,5 +1,7 @@-use crate::providers::models::SubtitleOption;-+use crate::providers::models::{+ CatalogItem, Episode, MediaDetails, MediaType, ProviderError, ProviderKind, ProviderMediaId,+ Season, SubtitleOption,+};pub fn captions_json_to_options(payload: &serde_json::Value) -> Vec<SubtitleOption> {let Some(captions) = payload.get("extCaptions").and_then(|c| c.as_array()) else {return Vec::new();@@ -23,3 +25,347 @@ pub fn captions_json_to_options(payload: &serde_json::Value) -> Vec<SubtitleOpti}).collect()}++pub fn moviebox_search_json_to_catalog(payload: &serde_json::Value) -> Vec<CatalogItem> {+ let mut items = Vec::new();+ let subjects = payload+ .get("data")+ .and_then(|d| d.get("results"))+ .or_else(|| payload.get("results"))+ .and_then(|r| r.as_array())+ .and_then(|arr| arr.first())+ .and_then(|first| first.get("subjects"))+ .and_then(|s| s.as_array());++ let subjects_slice = match subjects {+ Some(s) => s.as_slice(),+ None => {+ if let Some(list) = payload+ .get("data")+ .and_then(|d| d.get("list"))+ .or_else(|| payload.get("list"))+ .and_then(|l| l.as_array())+ {+ list.as_slice()+ } else {+ &[]+ }+ }+ };++ for s in subjects_slice {+ let id_str = s+ .get("subjectId")+ .or_else(|| s.get("id"))+ .and_then(|v| {+ if let Some(num) = v.as_i64() {+ Some(num.to_string())+ } else {+ v.as_str().map(|str_val| str_val.to_string())+ }+ })+ .unwrap_or_default();++ if id_str.is_empty() {+ continue;+ }++ let title = s+ .get("title")+ .and_then(|t| t.as_str())+ .unwrap_or("Unknown")+ .to_string();++ let stype = s+ .get("subjectType")+ .or_else(|| s.get("stype"))+ .and_then(|st| st.as_i64())+ .unwrap_or(1);++ let media_type = if stype == 2 {+ MediaType::Series+ } else {+ MediaType::Movie+ };++ let year = s+ .get("releaseDate")+ .or_else(|| s.get("year"))+ .and_then(|y| y.as_str())+ .map(crate::tui::text::extract_4digit_year)+ .filter(|y| !y.is_empty());++ let poster_url = s+ .get("cover")+ .and_then(|c| c.get("url"))+ .or_else(|| s.get("coverUrl"))+ .and_then(|u| u.as_str())+ .map(|u| u.to_string());++ let season_count = s+ .get("season")+ .and_then(|sc| sc.as_u64())+ .map(|sc| sc as usize);++ items.push(CatalogItem {+ id: ProviderMediaId {+ provider: ProviderKind::MovieBox,+ value: id_str,+ },+ title,+ media_type,+ year,+ poster_url,+ season_count,+ });+ }++ items+}++pub fn moviebox_details_json_to_media_details(+ payload: &serde_json::Value,+) -> Result<MediaDetails, ProviderError> {+ let subject = payload+ .get("data")+ .and_then(|d| d.get("subject"))+ .or_else(|| payload.get("subject"))+ .unwrap_or(payload);++ let id_str = subject+ .get("subjectId")+ .or_else(|| subject.get("id"))+ .and_then(|v| {+ if let Some(num) = v.as_i64() {+ Some(num.to_string())+ } else {+ v.as_str().map(|str_val| str_val.to_string())+ }+ })+ .ok_or(ProviderError::NotFound)?;++ let title = subject+ .get("title")+ .and_then(|t| t.as_str())+ .unwrap_or("Unknown")+ .to_string();++ let stype = subject+ .get("subjectType")+ .or_else(|| subject.get("stype"))+ .and_then(|st| st.as_i64())+ .unwrap_or(1);++ let media_type = if stype == 2 {+ MediaType::Series+ } else {+ MediaType::Movie+ };++ let year = subject+ .get("releaseDate")+ .or_else(|| subject.get("year"))+ .and_then(|y| y.as_str())+ .map(crate::tui::text::extract_4digit_year)+ .filter(|y| !y.is_empty());++ let description = subject+ .get("description")+ .or_else(|| subject.get("intro"))+ .and_then(|d| d.as_str())+ .map(|d| d.to_string());++ let tagline = subject+ .get("tagline")+ .and_then(|t| t.as_str())+ .map(|t| t.to_string());++ let imdb_rating = subject+ .get("imdbRatingValue")+ .or_else(|| subject.get("rating"))+ .and_then(|r| {+ if let Some(n) = r.as_f64() {+ Some(format!("{:.1}", n))+ } else {+ r.as_str().map(|s| s.to_string())+ }+ });++ let director = subject+ .get("director")+ .and_then(|d| d.as_str())+ .map(|d| d.to_string());++ let stars = subject+ .get("stars")+ .and_then(|s| s.as_str())+ .map(|s| s.to_string());++ let prints = subject+ .get("prints")+ .and_then(|p| p.as_str())+ .map(|p| p.to_string());++ let audios = subject+ .get("audios")+ .and_then(|a| a.as_str())+ .map(|a| a.to_string());++ let poster_url = subject+ .get("cover")+ .and_then(|c| c.get("url"))+ .or_else(|| subject.get("coverUrl"))+ .and_then(|u| u.as_str())+ .map(|u| u.to_string());++ let duration = subject.get("duration").and_then(|d| {+ if let Some(n) = d.as_u64() {+ Some(format!("{}m", n / 60))+ } else {+ d.as_str().map(|s| s.to_string())+ }+ });++ let genres = subject+ .get("genre")+ .or_else(|| subject.get("genres"))+ .and_then(|g| g.as_array())+ .map(|arr| {+ arr.iter()+ .filter_map(|v| v.as_str().map(|s| s.to_string()))+ .collect()+ })+ .unwrap_or_default();++ let mut seasons = Vec::new();+ if let Some(seasons_arr) = subject+ .get("seasons")+ .and_then(|s| s.get("seasons").or(Some(s)))+ .and_then(|s| s.as_array())+ {+ for s in seasons_arr {+ let se_num = s.get("se").and_then(|v| v.as_u64()).unwrap_or(1) as usize;+ let mut episodes = Vec::new();+ if let Some(eps) = s.get("episodeNumbers").and_then(|e| e.as_array()) {+ for ep in eps {+ if let Some(ep_num) = ep.as_u64() {+ episodes.push(Episode {+ season: se_num,+ number: ep_num as usize,+ title: None,+ });+ }+ }+ } else if let Some(max_ep) = s.get("maxEp").and_then(|m| m.as_u64()) {+ for ep_num in 1..=max_ep as usize {+ episodes.push(Episode {+ season: se_num,+ number: ep_num,+ title: None,+ });+ }+ }+ seasons.push(Season {+ number: se_num,+ episodes,+ });+ }+ }++ Ok(MediaDetails {+ id: ProviderMediaId {+ provider: ProviderKind::MovieBox,+ value: id_str,+ },+ title,+ media_type,+ year,+ description,+ tagline,+ imdb_rating,+ director,+ stars,+ prints,+ audios,+ poster_url,+ duration,+ genres,+ seasons,+ })+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn test_moviebox_search_json_to_catalog() {+ let payload = json!({+ "data": {+ "results": [{+ "subjects": [+ {+ "subjectId": "12345",+ "title": "Inception",+ "subjectType": 1,+ "releaseDate": "2010-07-16",+ "cover": { "url": "https://example.com/cover.jpg" },+ "season": 0+ },+ {+ "subjectId": "67890",+ "title": "Breaking Bad",+ "subjectType": 2,+ "releaseDate": "2008",+ "cover": { "url": "https://example.com/bb.jpg" },+ "season": 5+ }+ ]+ }]+ }+ });++ let catalog = moviebox_search_json_to_catalog(&payload);+ assert_eq!(catalog.len(), 2);+ assert_eq!(catalog[0].id.value, "12345");+ assert_eq!(catalog[0].title, "Inception");+ assert_eq!(catalog[0].media_type, MediaType::Movie);+ assert_eq!(catalog[0].year.as_deref(), Some("2010"));++ assert_eq!(catalog[1].id.value, "67890");+ assert_eq!(catalog[1].title, "Breaking Bad");+ assert_eq!(catalog[1].media_type, MediaType::Series);+ assert_eq!(catalog[1].season_count, Some(5));+ }++ #[test]+ fn test_moviebox_details_json_to_media_details() {+ let payload = json!({+ "data": {+ "subject": {+ "subjectId": "999",+ "title": "Interstellar",+ "subjectType": 1,+ "releaseDate": "2014",+ "description": "Space exploration film",+ "imdbRatingValue": "8.7",+ "director": "Christopher Nolan",+ "stars": "Matthew McConaughey, Anne Hathaway",+ "duration": 10140,+ "genre": ["Sci-Fi", "Adventure"],+ "cover": { "url": "https://example.com/interstellar.jpg" }+ }+ }+ });++ let details = moviebox_details_json_to_media_details(&payload).unwrap();+ assert_eq!(details.id.value, "999");+ assert_eq!(details.title, "Interstellar");+ assert_eq!(details.media_type, MediaType::Movie);+ assert_eq!(details.director.as_deref(), Some("Christopher Nolan"));+ assert_eq!(details.imdb_rating.as_deref(), Some("8.7"));+ assert_eq!(details.duration.as_deref(), Some("169m"));+ assert_eq!(details.genres, vec!["Sci-Fi", "Adventure"]);+ }+}diff --git a/src/providers/moviebox/mod.rs b/src/providers/moviebox/mod.rsindex 1004804..5b33ada 100644--- a/src/providers/moviebox/mod.rs+++ b/src/providers/moviebox/mod.rs@@ -5,9 +5,25 @@ pub mod title;pub use title::clean_moviebox_title;-use crate::providers::models::ProviderKind;+use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind};use crate::providers::{Provider, ProviderCapabilities};+impl From<ScraperError> for ProviderError {+ fn from(err: ScraperError) -> Self {+ match err {+ ScraperError::Reqwest(e) => ProviderError::Network(e.to_string()),+ ScraperError::ApiStatus(429) => ProviderError::RateLimited(None),+ ScraperError::ApiStatus(404) => ProviderError::NotFound,+ ScraperError::ApiStatus(s) => ProviderError::Unavailable(format!("HTTP status {s}")),+ ScraperError::HostsExhausted => {+ ProviderError::Unavailable("All hosts exhausted".to_string())+ }+ ScraperError::Json(e) => ProviderError::Parsing(e.to_string()),+ ScraperError::MissingToken => ProviderError::Unavailable("Missing token".to_string()),+ }+ }+}+impl Provider for client::MovieBoxClient {fn id(&self) -> ProviderKind {ProviderKind::MovieBox@@ -23,16 +39,17 @@ impl Provider for client::MovieBoxClient {}}- async fn search(&self, query: &str, page: usize) -> Result<serde_json::Value, String> {- self.search(query, page)+ async fn search(&self, query: &str, page: usize) -> Result<Vec<CatalogItem>, ProviderError> {+ let json = self+ .search(query, page).await- .map_err(|error| format!("{error:?}"))+ .map_err(ProviderError::from)?;+ Ok(adapt::moviebox_search_json_to_catalog(&json))}- async fn details(&self, id: &str) -> Result<serde_json::Value, String> {- self.get_details(id)- .await- .map_err(|error| format!("{error:?}"))+ async fn details(&self, id: &str) -> Result<MediaDetails, ProviderError> {+ let json = self.get_details(id).await.map_err(ProviderError::from)?;+ adapt::moviebox_details_json_to_media_details(&json)}}diff --git a/src/service.rs b/src/service.rsindex edc6a56..39facb6 100644--- a/src/service.rs+++ b/src/service.rs@@ -6,7 +6,7 @@ use crate::providers::Provider;use crate::providers::bdix::circleftp::CircleFtpClient;use crate::providers::bdix::dhakaflix::client::DhakaFlixClient;use crate::providers::fourkhdhub::FourKHdHubClient;-use crate::providers::models::ProviderKind;+use crate::providers::models::{CatalogItem, MediaDetails, ProviderError, ProviderKind};use crate::providers::moviebox::client::MovieBoxClient;#[derive(Clone)]@@ -64,19 +64,18 @@ impl MovieBoxService {self.client.suggest(query).await.map_err(|e| e.to_string())}- pub async fn search(+ pub async fn search_typed(&self,provider: ProviderKind,query: &str,page: usize,- ) -> Result<serde_json::Value, String> {+ ) -> Result<Vec<CatalogItem>, ProviderError> {match provider {ProviderKind::MovieBox => Provider::search(&self.client, query, page).await,ProviderKind::FourKHdHub => {- let fourk = self- .fourk_client- .as_ref()- .ok_or_else(|| "4KHDHub provider is unavailable".to_string())?;+ let fourk = self.fourk_client.as_ref().ok_or_else(|| {+ ProviderError::Unavailable("4KHDHub is unavailable".to_string())+ })?;Provider::search(fourk, query, page).await}ProviderKind::BdixCircleFtp => {@@ -85,6 +84,80 @@ impl MovieBoxService {ProviderKind::BdixDhakaFlix => {Provider::search(&self.dhakaflix_client, query, page).await}+ ProviderKind::Addons => {+ let addons = crate::config::load_addons();+ let catalog_addons: Vec<_> = addons+ .iter()+ .filter(|a| a.enabled && (a.provides_meta || a.provides_catalog))+ .collect();++ if catalog_addons.is_empty() {+ return Err(ProviderError::Unavailable(+ "No catalog/metadata addon enabled. Open /config to configure one."+ .to_string(),+ ));+ }++ let mut combined = Vec::new();+ for addon in catalog_addons {+ let base_url =+ crate::providers::addons::AddonClient::base_addon_url(&addon.manifest_url);+ if let Ok(movies) = self+ .addon_client+ .fetch_catalog_search(&base_url, "movie", "top", query)+ .await+ {+ combined.extend(movies);+ }+ if let Ok(series) = self+ .addon_client+ .fetch_catalog_search(&base_url, "series", "top", query)+ .await+ {+ combined.extend(series);+ }+ if !combined.is_empty() {+ break;+ }+ }++ if combined.is_empty() {+ return Err(ProviderError::NotFound);+ }++ let mut seen = std::collections::HashSet::new();+ Ok(combined+ .into_iter()+ .filter(|m| seen.insert(m.id.clone()))+ .map(|m| crate::providers::addons::adapter::meta_to_catalog_item(&m))+ .collect())+ }+ }+ }++ pub async fn search(+ &self,+ provider: ProviderKind,+ query: &str,+ page: usize,+ ) -> Result<serde_json::Value, String> {+ match provider {+ ProviderKind::MovieBox => self+ .client+ .search(query, page)+ .await+ .map_err(|e| e.to_string()),+ ProviderKind::FourKHdHub+ | ProviderKind::BdixCircleFtp+ | ProviderKind::BdixDhakaFlix => {+ let items = self+ .search_typed(provider, query, page)+ .await+ .map_err(|e| e.to_string())?;+ Ok(crate::providers::fourkhdhub::search_to_moviebox_json(+ &items,+ ))+ }ProviderKind::Addons => {let addons = crate::config::load_addons();let catalog_addons: Vec<_> = addons@@ -175,18 +248,17 @@ impl MovieBoxService {Ok(json)}- pub async fn details(+ pub async fn details_typed(&self,provider: ProviderKind,subject_id: &str,- ) -> Result<serde_json::Value, String> {+ ) -> Result<MediaDetails, ProviderError> {match provider {ProviderKind::MovieBox => Provider::details(&self.client, subject_id).await,ProviderKind::FourKHdHub => {- let fourk = self- .fourk_client- .as_ref()- .ok_or_else(|| "4KHDHub provider is unavailable".to_string())?;+ let fourk = self.fourk_client.as_ref().ok_or_else(|| {+ ProviderError::Unavailable("4KHDHub is unavailable".to_string())+ })?;Provider::details(fourk, subject_id).await}ProviderKind::BdixCircleFtp => {@@ -205,6 +277,97 @@ impl MovieBoxService {let types_to_try = ["series", "tv", "anime", "movie", "other"];let mut best_detail: Option<crate::providers::addons::models::MetaDetail> = None;+ for addon in &meta_addons {+ let base_url =+ crate::providers::addons::AddonClient::base_addon_url(&addon.manifest_url);+ for t in types_to_try {+ if let Ok(d) = self.addon_client.fetch_meta(&base_url, t, subject_id).await+ {+ if !d.videos.is_empty()+ || d.r#type.eq_ignore_ascii_case("series")+ || d.r#type.eq_ignore_ascii_case("tv")+ {+ return Ok(+ crate::providers::addons::adapter::meta_detail_to_media_details(+ &d,+ ),+ );+ }+ if best_detail.is_none() {+ best_detail = Some(d);+ }+ }+ }+ }++ for addon in &addons {+ if addon.enabled+ && !meta_addons+ .iter()+ .any(|m| m.manifest_url == addon.manifest_url)+ {+ let base_url = crate::providers::addons::AddonClient::base_addon_url(+ &addon.manifest_url,+ );+ for t in types_to_try {+ if let Ok(d) =+ self.addon_client.fetch_meta(&base_url, t, subject_id).await+ {+ if !d.videos.is_empty()+ || d.r#type.eq_ignore_ascii_case("series")+ || d.r#type.eq_ignore_ascii_case("tv")+ {+ return Ok(crate::providers::addons::adapter::meta_detail_to_media_details(&d));+ }+ if best_detail.is_none() {+ best_detail = Some(d);+ }+ }+ }+ }+ }++ if let Some(d) = best_detail {+ return Ok(crate::providers::addons::adapter::meta_detail_to_media_details(&d));+ }++ Err(ProviderError::NotFound)+ }+ }+ }++ pub async fn details(+ &self,+ provider: ProviderKind,+ subject_id: &str,+ ) -> Result<serde_json::Value, String> {+ match provider {+ ProviderKind::MovieBox => self+ .client+ .get_details(subject_id)+ .await+ .map_err(|e| e.to_string()),+ ProviderKind::FourKHdHub+ | ProviderKind::BdixCircleFtp+ | ProviderKind::BdixDhakaFlix => {+ let details = self+ .details_typed(provider, subject_id)+ .await+ .map_err(|e| e.to_string())?;+ Ok(crate::providers::fourkhdhub::details_to_moviebox_json(+ &details,+ ))+ }+ ProviderKind::Addons => {+ let addons = crate::config::load_addons();+ let meta_addons: Vec<_> = addons+ .iter()+ .filter(|a| a.enabled && a.provides_meta)+ .collect();++ let types_to_try = ["series", "tv", "anime", "movie", "other"];+ let mut best_detail: Option<crate::providers::addons::models::MetaDetail> = None;+for addon in &meta_addons {let base_url =crate::providers::addons::AddonClient::base_addon_url(&addon.manifest_url);diff --git a/src/tui/app/keyboard.rs b/src/tui/app/keyboard.rsindex 015dca2..e2ce539 100644--- a/src/tui/app/keyboard.rs+++ b/src/tui/app/keyboard.rs@@ -644,118 +644,22 @@ impl App {self.state.addon_manager_popup = false;}KeyCode::Up => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- let total = rows.len();- let mut next = if self.state.addon_manager_selected == 0 {- total.saturating_sub(1)- } else {- self.state.addon_manager_selected - 1- };- while next != self.state.addon_manager_selected- && matches!(rows.get(next), Some(AddonManagerRow::Header(_)))- {- next = if next == 0 {- total.saturating_sub(1)- } else {- next - 1- };- }- self.state.addon_manager_selected = next;+ self.state.step_addon_manager_selected(-1);}KeyCode::Down => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- let total = rows.len();- let mut next = if self.state.addon_manager_selected + 1 >= total {- 0- } else {- self.state.addon_manager_selected + 1- };- while next != self.state.addon_manager_selected- && matches!(rows.get(next), Some(AddonManagerRow::Header(_)))- {- next = if next + 1 >= total { 0 } else { next + 1 };- }- self.state.addon_manager_selected = next;+ self.state.step_addon_manager_selected(1);}KeyCode::Home => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- if let Some(idx) = rows- .iter()- .position(|r| !matches!(r, AddonManagerRow::Header(_)))- {- self.state.addon_manager_selected = idx;- }+ self.state.first_addon_manager_selected();}KeyCode::End => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- if let Some(idx) = rows- .iter()- .rposition(|r| !matches!(r, AddonManagerRow::Header(_)))- {- self.state.addon_manager_selected = idx;- }+ self.state.last_addon_manager_selected();}KeyCode::PageUp => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- let total = rows.len();- if total > 0 {- let mut target =- self.state.addon_manager_selected.saturating_sub(5);- while target > 0- && matches!(- rows.get(target),- Some(AddonManagerRow::Header(_))- )- {- target = target.saturating_sub(1);- }- if matches!(rows.get(target), Some(AddonManagerRow::Header(_)))- {- if let Some(idx) = rows- .iter()- .position(|r| !matches!(r, AddonManagerRow::Header(_)))- {- target = idx;- }- }- self.state.addon_manager_selected = target;- }+ self.state.step_addon_manager_selected(-5);}KeyCode::PageDown => {- use crate::tui::state::AddonManagerRow;- let rows = self.state.addon_manager_rows();- let total = rows.len();- if total > 0 {- let mut target = (self.state.addon_manager_selected + 5)- .min(total.saturating_sub(1));- while target < total- && matches!(- rows.get(target),- Some(AddonManagerRow::Header(_))- )- {- target += 1;- }- if target >= total- || matches!(- rows.get(target),- Some(AddonManagerRow::Header(_))- )- {- if let Some(idx) = rows- .iter()- .rposition(|r| !matches!(r, AddonManagerRow::Header(_)))- {- target = idx;- }- }- self.state.addon_manager_selected = target;- }+ self.state.step_addon_manager_selected(5);}KeyCode::Char('d') | KeyCode::Delete => {use crate::tui::state::AddonManagerRow;@@ -837,107 +741,22 @@ impl App {self.state.tv_config_popup = false;}KeyCode::Up => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- let total = rows.len();- let mut next = if self.state.tv_manager_selected == 0 {- total.saturating_sub(1)- } else {- self.state.tv_manager_selected - 1- };- while next != self.state.tv_manager_selected- && matches!(rows.get(next), Some(TvManagerRow::Header(_)))- {- next = if next == 0 {- total.saturating_sub(1)- } else {- next - 1- };- }- self.state.tv_manager_selected = next;+ self.state.step_tv_manager_selected(-1);}KeyCode::Down => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- let total = rows.len();- let mut next = if self.state.tv_manager_selected + 1 >= total {- 0- } else {- self.state.tv_manager_selected + 1- };- while next != self.state.tv_manager_selected- && matches!(rows.get(next), Some(TvManagerRow::Header(_)))- {- next = if next + 1 >= total { 0 } else { next + 1 };- }+ self.state.step_tv_manager_selected(1);}KeyCode::Home => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- if let Some(idx) = rows- .iter()- .position(|r| !matches!(r, TvManagerRow::Header(_)))- {- self.state.tv_manager_selected = idx;- }+ self.state.first_tv_manager_selected();}KeyCode::End => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- if let Some(idx) = rows- .iter()- .rposition(|r| !matches!(r, TvManagerRow::Header(_)))- {- self.state.tv_manager_selected = idx;- }+ self.state.last_tv_manager_selected();}KeyCode::PageUp => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- let total = rows.len();- if total > 0 {- let mut target =- self.state.tv_manager_selected.saturating_sub(5);- while target > 0- && matches!(rows.get(target), Some(TvManagerRow::Header(_)))- {- target = target.saturating_sub(1);- }- if matches!(rows.get(target), Some(TvManagerRow::Header(_))) {- if let Some(idx) = rows- .iter()- .position(|r| !matches!(r, TvManagerRow::Header(_)))- {- target = idx;- }- }- self.state.tv_manager_selected = target;- }+ self.state.step_tv_manager_selected(-5);}KeyCode::PageDown => {- use crate::tui::state::TvManagerRow;- let rows = self.state.tv_manager_rows();- let total = rows.len();- if total > 0 {- let mut target = (self.state.tv_manager_selected + 5)- .min(total.saturating_sub(1));- while target < total- && matches!(rows.get(target), Some(TvManagerRow::Header(_)))- {- target += 1;- }- if target >= total- || matches!(rows.get(target), Some(TvManagerRow::Header(_)))- {- if let Some(idx) = rows- .iter()- .rposition(|r| !matches!(r, TvManagerRow::Header(_)))- {- target = idx;- }- }- self.state.tv_manager_selected = target;- }+ self.state.step_tv_manager_selected(5);}KeyCode::Char('d') | KeyCode::Delete => {use crate::tui::state::TvManagerRow;diff --git a/src/tui/app/mod.rs b/src/tui/app/mod.rsindex 948867c..ee5b14f 100644--- a/src/tui/app/mod.rs+++ b/src/tui/app/mod.rs@@ -17,12 +17,62 @@ mod search;mod system;mod tv;+#[derive(Default)]+pub struct RequestTaskHandles {+ pub search: Option<tokio::task::JoinHandle<()>>,+ pub details: Option<tokio::task::JoinHandle<()>>,+ pub streams: Option<tokio::task::JoinHandle<()>>,+ pub suggest: Option<tokio::task::JoinHandle<()>>,+ pub homepage: Option<tokio::task::JoinHandle<()>>,+}++impl RequestTaskHandles {+ pub fn cancel_search(&mut self) {+ if let Some(h) = self.search.take() {+ h.abort();+ }+ }++ pub fn cancel_details(&mut self) {+ if let Some(h) = self.details.take() {+ h.abort();+ }+ }++ pub fn cancel_streams(&mut self) {+ if let Some(h) = self.streams.take() {+ h.abort();+ }+ }++ pub fn cancel_suggest(&mut self) {+ if let Some(h) = self.suggest.take() {+ h.abort();+ }+ }++ pub fn cancel_homepage(&mut self) {+ if let Some(h) = self.homepage.take() {+ h.abort();+ }+ }++ pub fn cancel_all(&mut self) {+ self.cancel_search();+ self.cancel_details();+ self.cancel_streams();+ self.cancel_suggest();+ self.cancel_homepage();+ }+}+pub struct App {state: AppState,theme: Theme,service: std::sync::Arc<crate::service::MovieBoxService>,action_sender: mpsc::UnboundedSender<Action>,action_receiver: mpsc::UnboundedReceiver<Action>,+ request_tasks: RequestTaskHandles,}impl Default for App {@@ -113,6 +163,7 @@ impl App {service,action_sender,action_receiver,+ request_tasks: RequestTaskHandles::default(),};if app.state.is_tv_mode {app.load_tv_playlists_from_config();diff --git a/src/tui/app/mouse.rs b/src/tui/app/mouse.rsindex 0cdf7c2..d295d34 100644--- a/src/tui/app/mouse.rs+++ b/src/tui/app/mouse.rs@@ -829,22 +829,14 @@ impl App {available_panes.push(DetailsPane::Episodes);}- let tier = crate::tui::screens::details::DetailsLayoutTier::for_area(area);- let header_height = tier.header_height(area, self.state.selected_details.as_ref());- let footer_height = tier.footer_height(area.width);-- let chunks = Layout::vertical([- Constraint::Length(header_height),- Constraint::Length(1),- Constraint::Min(5),- Constraint::Length(footer_height),- ])- .split(area);-- let workflow_area = chunks[1];- let bottom_area = chunks[2];- let footer_area = chunks[3];-+ let layout = crate::tui::screens::details::details_screen_layout(+ area,+ self.state.selected_details.as_ref(),+ );+ let tier = layout.tier;+ let workflow_area = layout.workflow_area;+ let bottom_area = layout.bottom_area;+ let footer_area = layout.footer_area;if row >= footer_area.y && row < footer_area.bottom() {self.handle_details_footer_click(col, row - footer_area.y, area.width);return None;diff --git a/src/tui/app/requests.rs b/src/tui/app/requests.rsindex 3e6a60e..6d2035c 100644--- a/src/tui/app/requests.rs+++ b/src/tui/app/requests.rs@@ -40,16 +40,17 @@ impl App {return None;}+ self.request_tasks.cancel_suggest();let service = self.service.clone();let sender = self.action_sender.clone();let query_clone = query.clone();- tokio::spawn(async move {+ self.request_tasks.suggest = Some(tokio::spawn(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, payload) => {@@ -1562,7 +1563,9 @@ impl App {).await} else {- Err("4KHDHub provider is unavailable".to_string())+ Err(crate::providers::models::ProviderError::Unavailable(+ "4KHDHub provider is unavailable".to_string(),+ ))}}ProviderKind::BdixCircleFtp => {@@ -1671,7 +1674,8 @@ impl App {let resolutions = pool.available_resolutions.clone();let is_movie = season == 0 && episode == 0;- tokio::spawn(async move {+ self.request_tasks.cancel_streams();+ self.request_tasks.streams = Some(tokio::spawn(async move {sender.send(Action::SetStatus("Fetching streams...".to_string())).ok();@@ -1825,7 +1829,7 @@ impl App {)).ok();}- });+ }));}Action::EpisodeStreamsReady(diff --git a/src/tui/app/search.rs b/src/tui/app/search.rsindex b73b43d..0b60336 100644--- a/src/tui/app/search.rs+++ b/src/tui/app/search.rs@@ -125,46 +125,49 @@ impl App {let ctrl_t = crate::tui::text::ctrl_key("T");let ctrl_a = crate::tui::text::ctrl_key("A");+ let will_handle = !matches!(+ &parsed,+ crate::tui::commands::ParsedCommand::History if current_mode != crate::tui::state::AppMode::Tv+ ) && !matches!(+ &parsed,+ crate::tui::commands::ParsedCommand::Favorites if current_mode != crate::tui::state::AppMode::Tv+ ) && !matches!(+ &parsed,+ crate::tui::commands::ParsedCommand::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::ParsedCommand::Settings => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ToggleSettingsPopup).ok();Some(true)}crate::tui::commands::ParsedCommand::ClearCache => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ClearCache).ok();Some(true)}crate::tui::commands::ParsedCommand::Clear => {self.state.clear_search_state();- self.state.input_mode = InputMode::Normal;self.state.set_status_default("Search cleared.");Some(true)}crate::tui::commands::ParsedCommand::Help => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ToggleHelp).ok();Some(true)}crate::tui::commands::ParsedCommand::Github => {let _ = open::that("https://github.com/mesamirh/MovieBox-Tui");- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;Some(true)}crate::tui::commands::ParsedCommand::Probe => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ProbeTerminal).ok();Some(true)}crate::tui::commands::ParsedCommand::Update => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;if !self.state.is_checking_updates {self.state.update_available = None;self.state.manual_update_check = true;@@ -178,8 +181,6 @@ impl App {crate::tui::commands::ParsedCommand::ToggleUpdate => {self.state.auto_update = !self.state.auto_update;self.persist_config();- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"Auto Update Check",@@ -192,14 +193,10 @@ impl App {Some(true)}crate::tui::commands::ParsedCommand::Theme => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ToggleThemePopup).ok();Some(true)}crate::tui::commands::ParsedCommand::Browse => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;if current_mode == crate::tui::state::AppMode::Tv {self.state.notify(NotificationKind::Info,@@ -213,8 +210,6 @@ impl App {}crate::tui::commands::ParsedCommand::History => {if current_mode == crate::tui::state::AppMode::Tv {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"TV Mode",@@ -227,8 +222,6 @@ impl App {}crate::tui::commands::ParsedCommand::Favorites => {if current_mode == crate::tui::state::AppMode::Tv {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"TV Mode",@@ -243,8 +236,6 @@ impl App {if current_mode == crate::tui::state::AppMode::Tv {self.apply_tv_search_results(query, lower_query);} else {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"TV Mode",@@ -262,16 +253,11 @@ impl App {} else if current_mode == crate::tui::state::AppMode::Addon {self.action_sender.send(Action::ShowAddonManager).ok();} else {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.action_sender.send(Action::ToggleSettingsPopup).ok();}Some(true)}crate::tui::commands::ParsedCommand::DownloadDir(raw_arg) => {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;-if raw_arg.is_empty() {let current = crate::logging::sanitize_path(self.resolve_download_base_dir());self.state@@ -369,8 +355,6 @@ impl App {crate::tui::commands::ParsedCommand::ToggleBdix => {let enable_req = !self.state.bdix_enabled;if current_mode != crate::tui::state::AppMode::Streaming {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"BDIX Sources",@@ -381,8 +365,6 @@ impl App {self.state.bdix_enabled = enable_req;self.persist_config();- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"BDIX Providers",@@ -407,8 +389,6 @@ impl App {crate::tui::commands::ParsedCommand::ToggleStreaming => {let enable_req = !self.state.streaming_enabled;if !enable_req && !self.state.tv_enabled && !self.state.addons_enabled {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Warning,"Streaming Mode",@@ -419,8 +399,6 @@ impl App {self.state.streaming_enabled = enable_req;self.persist_config();- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"Streaming Mode",@@ -445,8 +423,6 @@ impl App {crate::tui::commands::ParsedCommand::ToggleTv => {let enable_req = !self.state.tv_enabled;if !enable_req && !self.state.streaming_enabled && !self.state.addons_enabled {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Warning,"TV Mode",@@ -457,8 +433,6 @@ impl App {self.state.tv_enabled = enable_req;self.persist_config();- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"TV Mode",@@ -480,8 +454,6 @@ impl App {crate::tui::commands::ParsedCommand::ToggleAddons => {let enable_req = !self.state.addons_enabled;if !enable_req && !self.state.streaming_enabled && !self.state.tv_enabled {- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Warning,"Addon Mode",@@ -492,8 +464,6 @@ impl App {self.state.addons_enabled = enable_req;self.persist_config();- self.state.search_query.clear();- self.state.input_mode = InputMode::Normal;self.state.notify(NotificationKind::Info,"Addon Mode",@@ -573,16 +543,17 @@ impl App {}pub(super) fn run_search_request(- &self,+ &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();- tokio::spawn(async move {+ self.request_tasks.search = Some(tokio::spawn(async move {if !force_refresh {let q = query.clone();let provider = context.provider;@@ -629,7 +600,7 @@ impl App {.ok();}}- });+ }));}pub(super) fn prepare_homepage_request(&mut self, tab_id: &str, page: usize) {@@ -677,15 +648,16 @@ impl App {}pub(super) fn run_details_request(- &self,+ &mut self,id: String,force_refresh: bool,context: RequestContext,) {+ self.request_tasks.cancel_details();let request_id = self.state.active_details_request;let service = self.service.clone();let sender = self.action_sender.clone();- tokio::spawn(async move {+ 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 || {@@ -728,14 +700,15 @@ impl App {.ok();}}- });+ }));}- pub(super) fn run_homepage_request(&self, tab_id: String, page: usize) {+ 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;let service = self.service.clone();let sender = self.action_sender.clone();- tokio::spawn(async move {+ self.request_tasks.homepage = Some(tokio::spawn(async move {let t_clone = tab_id.clone();if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {crate::cache::get_homepage_cache(&t_clone, page)@@ -775,7 +748,7 @@ impl App {.ok();}}- });+ }));}pub(super) fn extract_homepage_subjects(payload: &serde_json::Value) -> Vec<serde_json::Value> {diff --git a/src/tui/commands.rs b/src/tui/commands.rsindex 186ceb0..7498b74 100644--- a/src/tui/commands.rs+++ b/src/tui/commands.rs@@ -47,7 +47,7 @@ pub enum ParsedCommand<'a> {}impl SlashCommand {- pub const ALL: [Self; 13] = [+ pub const ALL: [Self; 19] = [Self::Settings,Self::Browse,Self::History,@@ -61,6 +61,12 @@ impl SlashCommand {Self::Update,Self::ClearCache,Self::Github,+ Self::ToggleUpdate,+ Self::ToggleBdix,+ Self::ToggleStreaming,+ Self::ToggleTv,+ Self::ToggleAddons,+ Self::Probe,];pub const PRIMARY: [Self; 7] = [@@ -341,7 +347,7 @@ mod tests {#[test]fn test_toggle_commands_and_aliases_parse() {let state = AppState::default();- assert_eq!(SlashCommand::ALL.len(), 13);+ assert_eq!(SlashCommand::ALL.len(), 19);assert_eq!(SlashCommand::parse("/clear"), Some(ParsedCommand::Clear));assert!(SlashCommand::Clear.is_available(&state));assert_eq!(SlashCommand::Clear.name(), "/clear");diff --git a/src/tui/screens/details.rs b/src/tui/screens/details.rsindex e6ae3fc..2ba8dc7 100644--- a/src/tui/screens/details.rs+++ b/src/tui/screens/details.rs@@ -11,7 +11,7 @@ use ratatui::{};#[derive(Debug, Clone, Copy, PartialEq, Eq)]-pub(crate) enum DetailsLayoutTier {+pub enum DetailsLayoutTier {Wide,Medium,Narrow,@@ -19,7 +19,7 @@ pub(crate) enum DetailsLayoutTier {}impl DetailsLayoutTier {- pub(crate) fn for_area(area: Rect) -> Self {+ pub fn for_area(area: Rect) -> Self {if area.width < 60 || area.height < 24 {Self::Tiny} else if area.width < 80 {@@ -121,9 +121,21 @@ fn subject_provider(state: &AppState, subject_id: &str) -> crate::providers::mod.unwrap_or(state.active_provider)}-pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme) {+#[derive(Debug, Clone, Copy)]+pub struct DetailsScreenLayout {+ pub tier: DetailsLayoutTier,+ pub header_area: Rect,+ pub workflow_area: Rect,+ pub bottom_area: Rect,+ pub footer_area: Rect,+}++pub fn details_screen_layout(+ area: Rect,+ selected_details: Option<&serde_json::Value>,+) -> DetailsScreenLayout {let tier = DetailsLayoutTier::for_area(area);- let header_height = tier.header_height(area, state.selected_details.as_ref());+ let header_height = tier.header_height(area, selected_details);let footer_height = tier.footer_height(area.width);let chunks = Layout::vertical([Constraint::Length(header_height),@@ -132,9 +144,23 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)Constraint::Length(footer_height),]).split(area);- let workflow_area = chunks[1];- let bottom_area = chunks[2];+ DetailsScreenLayout {+ tier,+ header_area: chunks[0],+ workflow_area: chunks[1],+ bottom_area: chunks[2],+ footer_area: chunks[3],+ }+}++pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme) {+ let layout = details_screen_layout(area, state.selected_details.as_ref());+ let tier = layout.tier;+ let header_area = layout.header_area;+ let workflow_area = layout.workflow_area;+ let bottom_area = layout.bottom_area;+ let footer_area = layout.footer_area;let details_json = match &state.selected_details {Some(d) => d,None => {@@ -325,8 +351,8 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)0,));- let inner_area = details_block.inner(chunks[0]);- frame.render_widget(details_block.clone(), chunks[0]);+ let inner_area = details_block.inner(header_area);+ frame.render_widget(details_block.clone(), header_area);let show_poster = !matches!(tier, DetailsLayoutTier::Tiny)&& inner_area.height >= 6@@ -1425,7 +1451,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)])}.alignment(Alignment::Center);- frame.render_widget(footer_p, chunks[3]);+ frame.render_widget(footer_p, footer_area);if state.subtitle_popup || state.is_download_subtitle_popup {let items = statediff --git a/src/tui/state.rs b/src/tui/state.rsindex 625722a..db30f45 100644--- a/src/tui/state.rs+++ b/src/tui/state.rs@@ -3,8 +3,9 @@ use ratatui::widgets::{ListState, TableState};pub use crate::player::PlayerKind;-#[derive(Debug, Clone, Copy, PartialEq, Eq)]+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]pub enum Screen {+ #[default]Home,Details,}@@ -25,8 +26,9 @@ pub enum AppMode {Addon,}-#[derive(Debug, Clone, Copy, PartialEq, Eq)]+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]pub enum InputMode {+ #[default]Normal,Editing,}@@ -132,6 +134,70 @@ pub fn result_columns_for(width: u16) -> u16 {}}+#[derive(Debug, Default)]+pub struct UiState {+ pub active_screen: Screen,+ pub input_mode: InputMode,+ pub dirty: bool,+ pub show_theme_popup: bool,+ pub active_theme_kind: String,+ pub theme_is_auto: bool,+ pub show_browse_popup: bool,+ pub show_settings_popup: bool,+ pub settings_category: SettingsCategory,+ pub settings_selected_row: usize,+ pub show_help: bool,+ pub help_scroll: usize,+ pub cursor_beam: bool,+ pub details_pane: DetailsPane,+ pub player_picker_popup: bool,+ pub settings_player_picker: bool,+ pub subtitle_popup: bool,+ pub is_download_subtitle_popup: bool,+ pub tv_config_popup: bool,+ pub addon_manager_popup: bool,+ pub favorites_focus: bool,+ pub is_loading: bool,+ pub is_resolving_playback: bool,+ pub is_fetching_streams: bool,+}++#[derive(Debug, Default)]+pub struct CatalogState {+ pub active_provider: ProviderKind,+ pub provider_generation: u64,+ pub current_tab_id: String,+ pub current_page: usize,+ pub is_homepage_mode: bool,+ pub active_subject_id: Option<String>,+ pub search_error: Option<String>,+ pub details_error: Option<String>,+ pub stream_error: Option<String>,+}++#[derive(Debug, Default)]+pub struct PlaybackState {+ pub is_playing: bool,+ pub default_player: Option<String>,+ pub available_players: Vec<PlayerKind>,+ pub pending_play_link: Option<String>,+ pub pending_open_with: bool,+}++#[derive(Debug, Default)]+pub struct DownloadState {+ pub download_progress: Option<f64>,+ pub download_status: Option<String>,+ pub download_dir: Option<std::path::PathBuf>,+ pub download_queue_total: usize,+ pub show_season_download_confirm: bool,+ pub season_download_confirm_yes_selected: bool,+ pub show_episode_download_confirm: bool,+ pub episode_download_confirm_yes_selected: bool,+ pub is_waiting_for_download_stream: bool,+ pub auto_play_on_ready: bool,+}+pub struct AppState {pub active_provider: ProviderKind,pub provider_generation: u64,@@ -872,6 +938,64 @@ pub enum AddonManagerRow {Addon(usize),AddUrl,}+pub fn step_header_aware_list<F>(current: usize, total: usize, step: isize, is_header: F) -> usize+where+ F: Fn(usize) -> bool,+{+ if total == 0 {+ return 0;+ }+ if step == 0 {+ return current;+ }++ if step < -1 {+ let jump = (-step) as usize;+ let mut target = current.saturating_sub(jump);+ while target > 0 && is_header(target) {+ target = target.saturating_sub(1);+ }+ if is_header(target) {+ if let Some(first_valid) = (0..total).find(|&i| !is_header(i)) {+ target = first_valid;+ }+ }+ return target;+ } else if step > 1 {+ let jump = step as usize;+ let mut target = (current + jump).min(total.saturating_sub(1));+ while target < total && is_header(target) {+ target += 1;+ }+ if target >= total || is_header(target) {+ if let Some(last_valid) = (0..total).rposition(|i| !is_header(i)) {+ target = last_valid;+ }+ }+ return target;+ }++ let forward = step > 0;+ let mut next = if forward {+ if current + 1 >= total { 0 } else { current + 1 }+ } else if current == 0 {+ total.saturating_sub(1)+ } else {+ current - 1+ };++ while next != current && is_header(next) {+ next = if forward {+ if next + 1 >= total { 0 } else { next + 1 }+ } else if next == 0 {+ total.saturating_sub(1)+ } else {+ next - 1+ };+ }++ next+}impl AppState {pub fn tv_manager_rows(&self) -> Vec<TvManagerRow> {@@ -894,6 +1018,34 @@ impl AppState {rows}+ pub fn step_tv_manager_selected(&mut self, step: isize) {+ let rows = self.tv_manager_rows();+ self.tv_manager_selected =+ step_header_aware_list(self.tv_manager_selected, rows.len(), step, |idx| {+ matches!(rows.get(idx), Some(TvManagerRow::Header(_)))+ });+ }++ pub fn first_tv_manager_selected(&mut self) {+ let rows = self.tv_manager_rows();+ if let Some(idx) = rows+ .iter()+ .position(|r| !matches!(r, TvManagerRow::Header(_)))+ {+ self.tv_manager_selected = idx;+ }+ }++ pub fn last_tv_manager_selected(&mut self) {+ let rows = self.tv_manager_rows();+ if let Some(idx) = rows+ .iter()+ .rposition(|r| !matches!(r, TvManagerRow::Header(_)))+ {+ self.tv_manager_selected = idx;+ }+ }+pub fn addon_manager_rows(&self) -> Vec<AddonManagerRow> {let mut rows = vec![AddonManagerRow::Header("Installed Addons")];for index in 0..self.installed_addons.len() {@@ -902,6 +1054,34 @@ impl AppState {rows.push(AddonManagerRow::AddUrl);rows}++ pub fn step_addon_manager_selected(&mut self, step: isize) {+ let rows = self.addon_manager_rows();+ self.addon_manager_selected =+ step_header_aware_list(self.addon_manager_selected, rows.len(), step, |idx| {+ matches!(rows.get(idx), Some(AddonManagerRow::Header(_)))+ });+ }++ pub fn first_addon_manager_selected(&mut self) {+ let rows = self.addon_manager_rows();+ if let Some(idx) = rows+ .iter()+ .position(|r| !matches!(r, AddonManagerRow::Header(_)))+ {+ self.addon_manager_selected = idx;+ }+ }++ pub fn last_addon_manager_selected(&mut self) {+ let rows = self.addon_manager_rows();+ if let Some(idx) = rows+ .iter()+ .rposition(|r| !matches!(r, AddonManagerRow::Header(_)))+ {+ self.addon_manager_selected = idx;+ }+ }}#[cfg(test)]