Skip to content

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.md
index 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.md
index 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.md
index 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.md
index 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 verification
diff --git a/src/models.rs b/src/models.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 = state
diff --git a/src/tui/state.rs b/src/tui/state.rs
index 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)]