Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
feat: implement download module, add provider switching, and remove unit tests for maintenance efficiency.
Samir Hossains33cca0e62b02
diff --git a/src/cache.rs b/src/cache.rsindex af8a1f8..5c4f744 100644--- a/src/cache.rs+++ b/src/cache.rs@@ -243,26 +243,4 @@ pub fn set_homepage_cache(tab_id: &str, page: usize, data: &serde_json::Value) {}}-#[cfg(test)]-mod tests {- use super::*;- #[test]- fn provider_cache_paths_are_isolated() {- let moviebox = get_provider_search_path(ProviderKind::MovieBox, "same");- let fourk = get_provider_search_path(ProviderKind::FourKHdHub, "same");- assert_ne!(moviebox, fourk);- assert!(moviebox.to_string_lossy().contains("moviebox"));- assert!(fourk.to_string_lossy().contains("fourkhdhub"));- }-- #[test]- fn empty_search_payloads_are_not_cacheable() {- assert!(!search_payload_has_results(- &serde_json::json!({ "results": [{ "subjects": [] }] })- ));- assert!(search_payload_has_results(- &serde_json::json!({ "results": [{ "subjects": [{ "subjectId": "1" }] }] })- ));- }-}diff --git a/src/download.rs b/src/download.rsnew file mode 100644index 0000000..b9fce0d--- /dev/null+++ b/src/download.rs@@ -0,0 +1,709 @@+use reqwest::{+ Client, StatusCode,+ header::{ACCEPT_RANGES, CONTENT_RANGE, ETAG, IF_RANGE, LAST_MODIFIED, RANGE},+};+use serde::{Deserialize, Serialize};+use std::{+ path::{Path, PathBuf},+ sync::{+ Arc,+ atomic::{AtomicBool, AtomicU64, Ordering},+ },+ time::{Duration, Instant},+};+use thiserror::Error;+use tokio::io::AsyncWriteExt;++const MAX_ATTEMPTS: usize = 4;+const SEGMENT_THRESHOLD: u64 = 32 * 1024 * 1024;+const MAX_SEGMENTS: usize = 8;++pub fn safe_file_stem(value: &str) -> String {+ let mut stem = value+ .chars()+ .take(120)+ .map(|character| {+ if character.is_control()+ || character.is_whitespace()+ || matches!(+ character,+ '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|'+ )+ {+ '_'+ } else {+ character+ }+ })+ .collect::<String>();+ stem = stem.trim_matches(['.', ' ', '_']).to_string();+ if stem.is_empty() {+ return "MovieBox-Tui_Stream".into();+ }+ let upper = stem.to_ascii_uppercase();+ let reserved = matches!(upper.as_str(), "CON" | "PRN" | "AUX" | "NUL")+ || upper+ .strip_prefix("COM")+ .or_else(|| upper.strip_prefix("LPT"))+ .is_some_and(|number| {+ number.len() == 1 && number.bytes().all(|byte| matches!(byte, b'1'..=b'9'))+ });+ if reserved {+ stem.push('_');+ }+ stem+}++#[derive(Debug, Clone)]+pub struct DownloadProgress {+ pub downloaded: u64,+ pub total: Option<u64>,+ pub bytes_per_second: f64,+ pub attempt: usize,+ pub workers: usize,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum DownloadOutcome {+ Completed { bytes: u64 },+ Paused { bytes: u64 },+}++#[derive(Debug, Error)]+pub enum DownloadError {+ #[error("server returned HTTP {0}")]+ Http(StatusCode),+ #[error("network error: {0}")]+ Network(#[from] reqwest::Error),+ #[error("file error: {0}")]+ File(#[from] std::io::Error),+ #[error("invalid partial response: {0}")]+ InvalidRange(String),+ #[error("download ended at {downloaded} of {expected} bytes")]+ Incomplete { downloaded: u64, expected: u64 },+ #[error("download paused")]+ Paused,+}++#[derive(Debug, Clone, Default, Serialize, Deserialize)]+struct ResumeMetadata {+ etag: Option<String>,+ last_modified: Option<String>,+ total: Option<u64>,+ segments: Option<usize>,+}++pub async fn download<F>(+ client: &Client,+ url: &str,+ destination: &Path,+ cancel: Arc<AtomicBool>,+ mut report: F,+) -> Result<DownloadOutcome, DownloadError>+where+ F: FnMut(DownloadProgress),+{+ let partial = sidecar_path(destination, "part");+ let metadata_path = sidecar_path(destination, "part.json");+ let mut metadata = read_metadata(&metadata_path).await;+ let started = Instant::now();+ let mut last_report = Instant::now() - Duration::from_secs(1);+ let mut last_error = None;+ let mut segmented_disabled = false;++ for attempt in 1..=MAX_ATTEMPTS {+ if cancel.load(Ordering::Relaxed) {+ return Ok(DownloadOutcome::Paused {+ bytes: file_len(&partial).await,+ });+ }++ let mut offset = file_len(&partial).await;+ let mut request = client.get(url);+ if offset > 0 {+ request = request.header(RANGE, format!("bytes={offset}-"));+ if let Some(validator) = metadata.etag.as_ref().or(metadata.last_modified.as_ref()) {+ request = request.header(IF_RANGE, validator);+ }+ }++ let response = match request.send().await {+ Ok(response) => response,+ Err(error) => {+ last_error = Some(DownloadError::Network(error));+ retry_delay(attempt).await;+ continue;+ }+ };++ if response.status() == StatusCode::RANGE_NOT_SATISFIABLE && metadata.total == Some(offset)+ {+ finalize(&partial, &metadata_path, destination).await?;+ return Ok(DownloadOutcome::Completed { bytes: offset });+ }+ if !response.status().is_success() {+ last_error = Some(DownloadError::Http(response.status()));+ retry_delay(attempt).await;+ continue;+ }++ if !segmented_disabled+ && offset == 0+ && response.status() == StatusCode::OK+ && response+ .headers()+ .get(ACCEPT_RANGES)+ .and_then(|value| value.to_str().ok())+ .is_some_and(|value| value.eq_ignore_ascii_case("bytes"))+ && response+ .content_length()+ .is_some_and(|total| total >= SEGMENT_THRESHOLD)+ {+ let total = response.content_length().unwrap_or_default();+ let segments = segment_count(total);+ let current_metadata = ResumeMetadata {+ etag: header_string(&response, ETAG),+ last_modified: header_string(&response, LAST_MODIFIED),+ total: Some(total),+ segments: Some(segments),+ };+ if !metadata_matches(&metadata, ¤t_metadata) {+ remove_segment_files(destination).await;+ }+ write_metadata(&metadata_path, ¤t_metadata).await?;+ drop(response);+ match download_segmented(+ client,+ url,+ destination,+ &metadata_path,+ current_metadata,+ cancel.clone(),+ &mut report,+ )+ .await+ {+ Err(DownloadError::InvalidRange(_)) => {+ remove_segment_files(destination).await;+ metadata = ResumeMetadata::default();+ write_metadata(&metadata_path, &metadata).await?;+ segmented_disabled = true;+ continue;+ }+ result => return result,+ }+ }++ let response_total = if response.status() == StatusCode::PARTIAL_CONTENT {+ let content_range = response+ .headers()+ .get(CONTENT_RANGE)+ .and_then(|value| value.to_str().ok())+ .ok_or_else(|| DownloadError::InvalidRange("Content-Range missing".into()))?;+ let (start, total) = parse_content_range(content_range)?;+ if start != offset {+ return Err(DownloadError::InvalidRange(format!(+ "requested byte {offset}, received {start}"+ )));+ }+ total+ } else {+ if offset > 0 {+ truncate(&partial).await?;+ offset = 0;+ }+ response.content_length()+ };++ if offset > 0+ && let (Some(previous), Some(current)) = (metadata.total, response_total)+ && previous != current+ {+ truncate(&partial).await?;+ metadata = ResumeMetadata::default();+ write_metadata(&metadata_path, &metadata).await?;+ last_error = Some(DownloadError::InvalidRange(+ "remote file size changed; partial reset".into(),+ ));+ retry_delay(attempt).await;+ continue;+ }++ metadata.etag = header_string(&response, ETAG).or(metadata.etag);+ metadata.last_modified = header_string(&response, LAST_MODIFIED).or(metadata.last_modified);+ metadata.total = response_total.or(metadata.total);+ metadata.segments = None;+ write_metadata(&metadata_path, &metadata).await?;++ let mut file = tokio::fs::OpenOptions::new()+ .create(true)+ .append(true)+ .open(&partial)+ .await?;+ let mut response = response;+ let mut downloaded = offset;+ let transfer_started = Instant::now();++ loop {+ if cancel.load(Ordering::Relaxed) {+ file.flush().await?;+ return Ok(DownloadOutcome::Paused { bytes: downloaded });+ }++ match response.chunk().await {+ Ok(Some(chunk)) => {+ file.write_all(&chunk).await?;+ downloaded += chunk.len() as u64;+ if last_report.elapsed() >= Duration::from_millis(200) {+ let elapsed = started.elapsed().as_secs_f64();+ report(DownloadProgress {+ downloaded,+ total: metadata.total,+ bytes_per_second: if elapsed > 0.0 {+ downloaded as f64 / elapsed+ } else {+ 0.0+ },+ attempt,+ workers: 1,+ });+ last_report = Instant::now();+ }+ }+ Ok(None) => {+ file.flush().await?;+ file.sync_data().await?;+ if let Some(expected) = metadata.total+ && downloaded != expected+ {+ last_error = Some(DownloadError::Incomplete {+ downloaded,+ expected,+ });+ break;+ }+ report(DownloadProgress {+ downloaded,+ total: metadata.total.or(Some(downloaded)),+ bytes_per_second: if transfer_started.elapsed().as_secs_f64() > 0.0 {+ downloaded.saturating_sub(offset) as f64+ / transfer_started.elapsed().as_secs_f64()+ } else {+ 0.0+ },+ attempt,+ workers: 1,+ });+ finalize(&partial, &metadata_path, destination).await?;+ return Ok(DownloadOutcome::Completed { bytes: downloaded });+ }+ Err(error) => {+ file.flush().await?;+ last_error = Some(DownloadError::Network(error));+ break;+ }+ }+ }++ retry_delay(attempt).await;+ }++ Err(last_error.unwrap_or(DownloadError::InvalidRange(+ "download failed without a response".into(),+ )))+}++async fn download_segmented<F>(+ client: &Client,+ url: &str,+ destination: &Path,+ metadata_path: &Path,+ metadata: ResumeMetadata,+ cancel: Arc<AtomicBool>,+ report: &mut F,+) -> Result<DownloadOutcome, DownloadError>+where+ F: FnMut(DownloadProgress),+{+ let total = metadata+ .total+ .ok_or_else(|| DownloadError::InvalidRange("segment total missing".into()))?;+ let segments = metadata.segments.unwrap_or_else(|| segment_count(total));+ let ranges = segment_ranges(total, segments);+ let mut initial = 0;++ for (index, (start, end)) in ranges.iter().copied().enumerate() {+ let path = segment_path(destination, index);+ let expected = end - start + 1;+ let length = file_len(&path).await;+ if length > expected {+ truncate(&path).await?;+ } else {+ initial += length;+ }+ }++ let downloaded = Arc::new(AtomicU64::new(initial));+ let (progress_sender, mut progress_receiver) =+ tokio::sync::mpsc::unbounded_channel::<(u64, usize)>();+ let mut tasks = tokio::task::JoinSet::new();+ let validator = metadata.etag.clone().or(metadata.last_modified.clone());++ for (index, (start, end)) in ranges.iter().copied().enumerate() {+ let client = client.clone();+ let url = url.to_string();+ let path = segment_path(destination, index);+ let cancel = cancel.clone();+ let progress_sender = progress_sender.clone();+ let validator = validator.clone();+ tasks.spawn(async move {+ download_segment(+ &client,+ &url,+ &path,+ start,+ end,+ total,+ validator,+ cancel,+ progress_sender,+ )+ .await+ });+ }+ drop(progress_sender);++ let started = Instant::now();+ let mut last_report = Instant::now() - Duration::from_secs(1);+ let mut finished = 0;+ while finished < segments {+ tokio::select! {+ progress = progress_receiver.recv() => {+ if let Some((bytes, attempt)) = progress {+ let current = downloaded.fetch_add(bytes, Ordering::Relaxed) + bytes;+ if last_report.elapsed() >= Duration::from_millis(200) {+ let elapsed = started.elapsed().as_secs_f64();+ report(DownloadProgress {+ downloaded: current,+ total: Some(total),+ bytes_per_second: if elapsed > 0.0 {+ current.saturating_sub(initial) as f64 / elapsed+ } else {+ 0.0+ },+ attempt,+ workers: segments,+ });+ last_report = Instant::now();+ }+ }+ }+ result = tasks.join_next() => {+ match result {+ Some(Ok(Ok(()))) => finished += 1,+ Some(Ok(Err(DownloadError::Paused))) => {+ tasks.abort_all();+ return Ok(DownloadOutcome::Paused {+ bytes: downloaded.load(Ordering::Relaxed),+ });+ }+ Some(Ok(Err(error))) => {+ tasks.abort_all();+ return Err(error);+ }+ Some(Err(error)) => {+ tasks.abort_all();+ return Err(DownloadError::InvalidRange(format!(+ "download worker stopped: {error}"+ )));+ }+ None => break,+ }+ }+ }+ }++ if cancel.load(Ordering::Relaxed) {+ return Ok(DownloadOutcome::Paused {+ bytes: downloaded.load(Ordering::Relaxed),+ });+ }++ let assembly = sidecar_path(destination, "assembling");+ let mut output = tokio::fs::File::create(&assembly).await?;+ for index in 0..segments {+ let path = segment_path(destination, index);+ let mut part = tokio::fs::File::open(&path).await?;+ tokio::io::copy(&mut part, &mut output).await?;+ }+ output.flush().await?;+ output.sync_data().await?;+ if file_len(&assembly).await != total {+ return Err(DownloadError::Incomplete {+ downloaded: file_len(&assembly).await,+ expected: total,+ });+ }+ tokio::fs::rename(&assembly, destination).await?;+ for index in 0..segments {+ let _ = tokio::fs::remove_file(segment_path(destination, index)).await;+ }+ let _ = tokio::fs::remove_file(metadata_path).await;+ report(DownloadProgress {+ downloaded: total,+ total: Some(total),+ bytes_per_second: if started.elapsed().as_secs_f64() > 0.0 {+ total.saturating_sub(initial) as f64 / started.elapsed().as_secs_f64()+ } else {+ 0.0+ },+ attempt: 1,+ workers: segments,+ });+ Ok(DownloadOutcome::Completed { bytes: total })+}++#[allow(clippy::too_many_arguments)]+async fn download_segment(+ client: &Client,+ url: &str,+ path: &Path,+ start: u64,+ end: u64,+ total: u64,+ validator: Option<String>,+ cancel: Arc<AtomicBool>,+ progress: tokio::sync::mpsc::UnboundedSender<(u64, usize)>,+) -> Result<(), DownloadError> {+ let expected = end - start + 1;+ let mut last_error = None;++ for attempt in 1..=MAX_ATTEMPTS {+ if cancel.load(Ordering::Relaxed) {+ return Err(DownloadError::Paused);+ }+ let existing = file_len(path).await.min(expected);+ if existing == expected {+ return Ok(());+ }+ let requested_start = start + existing;+ let mut request = client+ .get(url)+ .header(RANGE, format!("bytes={requested_start}-{end}"));+ if let Some(validator) = &validator {+ request = request.header(IF_RANGE, validator);+ }+ let response = match request.send().await {+ Ok(response) => response,+ Err(error) => {+ last_error = Some(DownloadError::Network(error));+ retry_delay(attempt).await;+ continue;+ }+ };+ if response.status() != StatusCode::PARTIAL_CONTENT {+ last_error = Some(DownloadError::InvalidRange(format!(+ "worker expected HTTP 206, received {}",+ response.status()+ )));+ retry_delay(attempt).await;+ continue;+ }+ let content_range = response+ .headers()+ .get(CONTENT_RANGE)+ .and_then(|value| value.to_str().ok())+ .ok_or_else(|| DownloadError::InvalidRange("Content-Range missing".into()))?;+ let (received_start, received_total) = parse_content_range(content_range)?;+ if received_start != requested_start || received_total != Some(total) {+ return Err(DownloadError::InvalidRange(format!(+ "worker requested {requested_start}-{end}/{total}, received {content_range}"+ )));+ }++ let mut file = tokio::fs::OpenOptions::new()+ .create(true)+ .append(true)+ .open(path)+ .await?;+ let mut response = response;+ let mut written = existing;+ loop {+ if cancel.load(Ordering::Relaxed) {+ file.flush().await?;+ return Err(DownloadError::Paused);+ }+ match response.chunk().await {+ Ok(Some(chunk)) => {+ let remaining = expected - written;+ let bytes = chunk.len().min(remaining as usize);+ file.write_all(&chunk[..bytes]).await?;+ written += bytes as u64;+ progress.send((bytes as u64, attempt)).ok();+ if written == expected {+ file.flush().await?;+ file.sync_data().await?;+ return Ok(());+ }+ }+ Ok(None) => {+ file.flush().await?;+ last_error = Some(DownloadError::Incomplete {+ downloaded: written,+ expected,+ });+ break;+ }+ Err(error) => {+ file.flush().await?;+ last_error = Some(DownloadError::Network(error));+ break;+ }+ }+ }+ retry_delay(attempt).await;+ }++ Err(last_error.unwrap_or(DownloadError::Incomplete {+ downloaded: file_len(path).await,+ expected,+ }))+}++fn segment_count(total: u64) -> usize {+ if total < 256 * 1024 * 1024 {+ 2+ } else if total < 2 * 1024 * 1024 * 1024 {+ 4+ } else {+ MAX_SEGMENTS+ }+}++fn segment_ranges(total: u64, segments: usize) -> Vec<(u64, u64)> {+ let size = total / segments as u64;+ (0..segments)+ .map(|index| {+ let start = index as u64 * size;+ let end = if index + 1 == segments {+ total - 1+ } else {+ start + size - 1+ };+ (start, end)+ })+ .collect()+}++fn segment_path(destination: &Path, index: usize) -> PathBuf {+ sidecar_path(destination, &format!("part.{index}"))+}++fn metadata_matches(previous: &ResumeMetadata, current: &ResumeMetadata) -> bool {+ previous.total == current.total+ && previous.segments == current.segments+ && match (&previous.etag, ¤t.etag) {+ (Some(previous), Some(current)) => previous == current,+ _ => match (&previous.last_modified, ¤t.last_modified) {+ (Some(previous), Some(current)) => previous == current,+ _ => true,+ },+ }+}++async fn remove_segment_files(destination: &Path) {+ for index in 0..MAX_SEGMENTS {+ let _ = tokio::fs::remove_file(segment_path(destination, index)).await;+ }+ let _ = tokio::fs::remove_file(sidecar_path(destination, "assembling")).await;+}++fn parse_content_range(value: &str) -> Result<(u64, Option<u64>), DownloadError> {+ let value = value+ .strip_prefix("bytes ")+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;+ let (range, total) = value+ .split_once('/')+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;+ let (start, _) = range+ .split_once('-')+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;+ let start = start+ .parse()+ .map_err(|_| DownloadError::InvalidRange(value.into()))?;+ let total = if total == "*" {+ None+ } else {+ Some(+ total+ .parse()+ .map_err(|_| DownloadError::InvalidRange(value.into()))?,+ )+ };+ Ok((start, total))+}++fn sidecar_path(destination: &Path, suffix: &str) -> PathBuf {+ let mut name = destination.as_os_str().to_os_string();+ name.push(".");+ name.push(suffix);+ PathBuf::from(name)+}++async fn file_len(path: &Path) -> u64 {+ tokio::fs::metadata(path)+ .await+ .map(|metadata| metadata.len())+ .unwrap_or_default()+}++async fn truncate(path: &Path) -> Result<(), std::io::Error> {+ tokio::fs::OpenOptions::new()+ .create(true)+ .write(true)+ .truncate(true)+ .open(path)+ .await+ .map(|_| ())+}++async fn finalize(+ partial: &Path,+ metadata: &Path,+ destination: &Path,+) -> Result<(), std::io::Error> {+ tokio::fs::rename(partial, destination).await?;+ let _ = tokio::fs::remove_file(metadata).await;+ Ok(())+}++async fn read_metadata(path: &Path) -> ResumeMetadata {+ let Ok(bytes) = tokio::fs::read(path).await else {+ return ResumeMetadata::default();+ };+ serde_json::from_slice(&bytes).unwrap_or_default()+}++async fn write_metadata(path: &Path, metadata: &ResumeMetadata) -> Result<(), std::io::Error> {+ let bytes = serde_json::to_vec(metadata).map_err(std::io::Error::other)?;+ tokio::fs::write(path, bytes).await+}++fn header_string(+ response: &reqwest::Response,+ name: reqwest::header::HeaderName,+) -> Option<String> {+ response+ .headers()+ .get(name)+ .and_then(|value| value.to_str().ok())+ .map(str::to_string)+}++async fn retry_delay(attempt: usize) {+ if attempt < MAX_ATTEMPTS {+ tokio::time::sleep(Duration::from_secs(1 << (attempt - 1))).await;+ }+}++diff --git a/src/lib.rs b/src/lib.rsindex 40fa048..8b36830 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -1,3 +1,4 @@pub mod cache;+pub mod download;pub mod providers;pub mod tui;diff --git a/src/providers/fourkhdhub/client.rs b/src/providers/fourkhdhub/client.rsindex ce470c8..5b5ff56 100644--- a/src/providers/fourkhdhub/client.rs+++ b/src/providers/fourkhdhub/client.rs@@ -209,102 +209,3 @@ fn build_client() -> reqwest::Client {.build().unwrap_or_default()}--#[cfg(test)]-mod live_tests {- use super::*;-- #[tokio::test]- #[ignore = "requires live 4KHDHub network access"]- async fn movie_and_series_catalog_gate() {- let client = FourKHdHubClient::new();- client.health_check().await.expect("provider health");-- for title in ["Oppenheimer", "Inception", "Interstellar"] {- let movies = client.search(title).await.expect("movie search");- let movie = movies- .iter()- .find(|item| item.title == title)- .expect("exact movie");- let details = client- .details(&movie.id.value)- .await- .expect("movie details");- assert_eq!(details.title, title);- assert!(- !client- .releases(&movie.id.value, 0, 0)- .await- .expect("movie releases")- .is_empty()- );- }-- for title in ["Breaking Bad", "Chernobyl", "Stranger Things", "Off Campus"] {- let series = client.search(title).await.expect("series search");- let show = series- .iter()- .find(|item| item.title == title)- .expect("exact series");- let show_details = client- .details(&show.id.value)- .await- .expect("series details");- assert!(show_details.seasons.iter().any(|season| {- season.number == 1 && season.episodes.iter().any(|episode| episode.number == 1)- }));- let releases = client- .releases(&show.id.value, 1, 1)- .await- .expect("episode releases");- assert!(!releases.is_empty());- assert!(- releases- .iter()- .all(|release| release.season == Some(1) && release.episode == Some(1))- );- }- }-- #[tokio::test]- #[ignore = "requires live resolver and media hosts"]- async fn hubcloud_resolution_gate() {- let client = FourKHdHubClient::new();- let movies = client.search("Oppenheimer").await.expect("movie search");- let movie = movies- .iter()- .find(|item| item.title == "Oppenheimer")- .expect("exact movie");- let releases = client- .releases(&movie.id.value, 0, 0)- .await- .expect("movie releases");- let source = client- .resolve_release(releases.first().expect("release"))- .await- .expect("playback source");- assert_eq!(source.provider, ProviderKind::FourKHdHub);- assert!(source.url.starts_with("https://"));- }-- #[tokio::test]- #[ignore = "requires live Off Campus resolver and PixelDrain"]- async fn off_campus_episode_resolution_gate() {- let client = FourKHdHubClient::new();- let series = client.search("Off Campus").await.expect("series search");- let show = series- .iter()- .find(|item| item.title == "Off Campus")- .expect("exact series");- let releases = client- .releases(&show.id.value, 1, 1)- .await- .expect("episode releases");- let source = client- .resolve_release(releases.first().expect("episode release"))- .await- .expect("episode playback source");- assert_eq!(source.provider, ProviderKind::FourKHdHub);- assert!(source.url.contains("pixeldrain.dev/api/file/"));- }-}diff --git a/src/providers/fourkhdhub/hubcloud.rs b/src/providers/fourkhdhub/hubcloud.rsindex 823eca4..7e0d0a6 100644--- a/src/providers/fourkhdhub/hubcloud.rs+++ b/src/providers/fourkhdhub/hubcloud.rs@@ -225,48 +225,3 @@ fn clean_label(label: &str) -> String {clean}}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn rejects_local_and_non_media_destinations() {- assert!(validate_playback_url("https://127.0.0.1/video.mp4").is_err());- assert!(validate_playback_url("https://example.com/login.php").is_err());- assert!(validate_playback_url("https://example.com/pack.zip").is_err());- assert!(validate_playback_url("https://cdn.example.com/video.mp4").is_ok());- }-- #[test]- fn pixel_gateway_precedes_fsl() {- assert!(- score("https://pixel.hubcloud.cx/?id=x", "Download")- < score("https://hub.latent.click/file", "FSL")- );- }-- #[test]- fn extracts_hidden_pixeldrain_api_source() {- let html = r#"- <a href="https://pixeldrain.dev/u/dead">Pixel Server</a>- <script>var pxl = "https://pixeldrain.dev/u/8UJ3KFve";</script>- "#;- assert_eq!(- extract_script_pixeldrain_urls(html),- vec!["https://pixeldrain.dev/api/file/8UJ3KFve?download"]- );- }-- #[test]- fn extracts_hubcloud_fallback_from_hubdrive() {- let html = r#"- <a href="/login">Login</a>- <a href="https://hubcloud.cx/drive/pss5r5pacmsn1lp">HubCloud Server</a>- "#;- assert_eq!(- extract_hubcloud_drive_url(html).as_deref(),- Some("https://hubcloud.cx/drive/pss5r5pacmsn1lp")- );- }-}diff --git a/src/providers/fourkhdhub/parser.rs b/src/providers/fourkhdhub/parser.rsindex a234e37..60855f4 100644--- a/src/providers/fourkhdhub/parser.rs+++ b/src/providers/fourkhdhub/parser.rs@@ -512,189 +512,3 @@ fn normalize_filename(value: &str) -> String {.filter(|character| character.is_ascii_alphanumeric()).collect()}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn parses_episode_identity() {- assert_eq!(- parse_season_episode("Breaking.Bad.S01E07.1080p.mkv"),- Some((1, 7))- );- assert_eq!(parse_season_episode("movie.mkv"), None);- }-- #[test]- fn parses_sizes() {- assert_eq!(parse_size_bytes("1.5 GB"), Some(1_610_612_736));- assert_eq!(parse_size_bytes("480 MB"), Some(503_316_480));- }-- #[test]- fn strips_only_a_trailing_year_from_titles() {- assert_eq!(strip_trailing_year("Oppenheimer (2023)"), "Oppenheimer");- assert_eq!(strip_trailing_year("The 100"), "The 100");- }-- #[test]- fn archive_detection_excludes_packs() {- assert!(is_archive("Show S01 Complete Season.zip"));- assert!(!is_archive("Show S01E01.mkv"));- }-- #[test]- fn parses_provider_metadata_without_technical_badges_as_genres() {- let html = r#"- <meta property="og:image" content="https://image.example/poster.jpg">- <h1 class="page-title">Off Campus</h1>- <p class="movie-tagline">Love was never part of the deal.</p>- <span class="imdb-score">8.2</span>- <span class="badge-outline"><a>2160p</a></span>- <span class="badge-outline"><a>Drama</a></span>- <span class="badge-outline"><a>Romance</a></span>- <div class="content-section">- <p class="mt-4">The real provider synopsis.</p>- <div class="metadata-item">- <span class="metadata-label">Last Air:</span>- <span class="metadata-value">2026-05-13</span>- </div>- <div class="metadata-item">- <span class="metadata-label">Audios:</span>- <span class="metadata-value">Hindi | English</span>- </div>- </div>- <div id="episodes"></div>- "#;- let details = parse_details("/off-campus-series-1/", html).expect("details");- assert_eq!(- details.description.as_deref(),- Some("The real provider synopsis.")- );- assert_eq!(details.imdb_rating.as_deref(), Some("8.2"));- assert_eq!(details.year.as_deref(), Some("2026"));- assert_eq!(details.genres, ["Drama", "Romance"]);- assert_eq!(details.audios.as_deref(), Some("Hindi | English"));- }-- #[test]- fn normalizes_dotted_video_codecs() {- assert_eq!(- detect_codec("Show.1080p.H.265.mkv").as_deref(),- Some("H.265")- );- assert_eq!(- detect_codec("Show.1080p.H.264.mkv").as_deref(),- Some("H.264")- );- }-- #[test]- fn fixture_groups_mirrors_and_rejects_adjacent_episodes() {- let html = r#"- <div id="episodes">- <div class="episode-download-item">- <div class="episode-file-title">Show.S01E01.1080p.HEVC.English.mkv</div>- <span class="badge-size">1.5 GB</span>- <a href="https://hubcloud.ist/drive/one">HubCloud</a>- <a href="https://hubdrive.tips/file/one">HubDrive</a>- </div>- <div class="episode-download-item">- <div class="episode-file-title">Show.S01E02.1080p.HEVC.English.mkv</div>- <a href="https://hubcloud.ist/drive/two">HubCloud</a>- </div>- <div class="episode-download-item">- <div class="episode-file-title">Show.S01.Complete.Season.zip</div>- <a href="https://hubcloud.ist/drive/pack">HubCloud</a>- </div>- </div>- "#;- let releases = parse_releases(html, 1, 1).expect("fixture parses");- assert_eq!(releases.len(), 1);- assert_eq!(releases[0].mirrors.len(), 2);- assert_eq!(releases[0].episode, Some(1));- }-- #[test]- fn release_language_falls_back_to_page_audio_metadata() {- let html = r#"- <div class="metadata-item">- <span class="metadata-label">Audios:</span>- <span class="metadata-value">English</span>- </div>- <div id="episodes">- <div class="episode-download-item">- <div class="episode-file-title">Show.S01E01.2160p.DDP5.1.H.265.mkv</div>- <a href="https://hubcloud.ist/drive/english">HubCloud</a>- </div>- </div>- "#;- let releases = parse_releases(html, 1, 1).expect("fixture parses");- assert_eq!(releases[0].language.as_deref(), Some("English"));- }-- #[test]- fn filename_language_takes_priority_over_page_audio_metadata() {- let html = r#"- <div class="metadata-item">- <span class="metadata-label">Audios:</span>- <span class="metadata-value">Hindi | English</span>- </div>- <div id="episodes">- <div class="episode-download-item">- <div class="episode-file-title">Show.S01E01.1080p.English.H.264.mkv</div>- <a href="https://hubcloud.ist/drive/english">HubCloud</a>- </div>- </div>- "#;- let releases = parse_releases(html, 1, 1).expect("fixture parses");- assert_eq!(releases[0].language.as_deref(), Some("English"));- }-- #[test]- fn compatibility_release_payload_is_an_array() {- let payload = releases_to_moviebox_json(&[Release {- provider: ProviderKind::FourKHdHub,- filename: "Movie.2160p.HEVC.mkv".into(),- quality: Some("2160p".into()),- codec: Some("HEVC".into()),- language: None,- size_bytes: Some(1024),- season: None,- episode: None,- mirrors: vec![SourceMirror {- label: "HubCloud".into(),- resolver_url: "https://hubcloud.ist/drive/test".into(),- headers: vec![],- direct_file: false,- }],- }]);- assert!(payload.is_array());- assert_eq!(payload[0]["resolution"], 2160);- assert_eq!(payload[0]["se"], 0);- assert_eq!(payload[0]["ep"], 0);- }-- #[test]- fn episode_payload_preserves_stream_pool_identity() {- let payload = releases_to_moviebox_json(&[Release {- provider: ProviderKind::FourKHdHub,- filename: "Off.Campus.S01E01.2160p.mkv".into(),- quality: Some("2160p".into()),- codec: Some("HEVC".into()),- language: Some("English".into()),- size_bytes: Some(1024),- season: Some(1),- episode: Some(1),- mirrors: vec![SourceMirror {- label: "HubCloud".into(),- resolver_url: "https://hubcloud.ist/drive/off-campus".into(),- headers: vec![],- direct_file: false,- }],- }]);- assert_eq!(payload[0]["se"], 1);- assert_eq!(payload[0]["ep"], 1);- }-}diff --git a/src/providers/models.rs b/src/providers/models.rsindex af1ff6d..c4800a9 100644--- a/src/providers/models.rs+++ b/src/providers/models.rs@@ -135,20 +135,4 @@ impl PlaybackSource {}}-#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn provider_scoped_ids_do_not_collide() {- let moviebox = ProviderMediaId {- provider: ProviderKind::MovieBox,- value: "42".into(),- };- let fourk = ProviderMediaId {- provider: ProviderKind::FourKHdHub,- value: "42".into(),- };- assert_ne!(moviebox, fourk);- }-}+diff --git a/src/tui/action.rs b/src/tui/action.rsindex b148f65..a0f3241 100644--- a/src/tui/action.rs+++ b/src/tui/action.rs@@ -56,6 +56,10 @@ pub enum Action {PlayersDetected(Vec<crate::tui::state::PlayerKind>),DownloadStream(Option<String>),UpdateDownload(Option<f64>, Option<String>),+ DownloadCompleted(String),+ DownloadFailed(String),+ DownloadPaused(String),+ ClearDownload,CancelDownload,PromptDownloadEpisode,ConfirmDownloadEpisode,diff --git a/src/tui/app.rs b/src/tui/app.rsindex 0a0d1e9..c319bd1 100644--- a/src/tui/app.rs+++ b/src/tui/app.rs@@ -298,6 +298,186 @@ impl App {.and_then(|value| serde_json::from_value(value.clone()).ok())}+ fn start_resilient_download(&mut self, subtitle_url: Option<String>) {+ if self.state.download_progress.is_some() || self.state.active_screen != Screen::Details {+ return;+ }+ let Some(link) = self.get_selected_link() else {+ if self.state.is_fetching_streams {+ self.state.is_waiting_for_download_stream = true;+ self.state.toast_message = Some("Waiting for stream details...".into());+ } else {+ self.state.toast_message = Some("No downloadable stream selected.".into());+ }+ self.state.toast_timer = 120;+ return;+ };++ let title = self+ .state+ .selected_details+ .as_ref()+ .and_then(|details| details.get("title"))+ .and_then(|title| title.as_str())+ .unwrap_or("MovieBox-Tui_Stream");+ let media_type = self+ .state+ .selected_details+ .as_ref()+ .and_then(|details| details.get("stype").or_else(|| details.get("subjectType")))+ .and_then(|value| value.as_i64())+ .unwrap_or(1);+ let season = self.state.selected_season;+ let episode = self.state.selected_episode;+ let safe_title = crate::download::safe_file_stem(title);++ let extension = self+ .state+ .selected_resources+ .as_ref()+ .and_then(|resources| resources.get("list"))+ .and_then(|list| list.as_array())+ .and_then(|list| list.get(self.state.resource_list_state.selected().unwrap_or(0)))+ .and_then(|resource| {+ resource+ .get("fileName")+ .or_else(|| resource.get("title"))+ .and_then(|name| name.as_str())+ })+ .and_then(|name| std::path::Path::new(name).extension())+ .and_then(|extension| extension.to_str())+ .filter(|extension| {+ matches!(+ extension.to_ascii_lowercase().as_str(),+ "mp4" | "mkv" | "webm" | "avi" | "mov" | "m4v"+ )+ })+ .unwrap_or("mp4")+ .to_ascii_lowercase();++ let base_dir = dirs::download_dir()+ .unwrap_or_else(|| std::path::PathBuf::from("."))+ .join("MovieBox-TUI");+ let (target_dir, base_name) = if media_type == 2 {+ (+ base_dir+ .join("Series")+ .join(&safe_title)+ .join(format!("Season {season}")),+ format!("{safe_title}_S{season:02}E{episode:02}"),+ )+ } else {+ (base_dir.join("Movies"), safe_title)+ };+ let mut destination = target_dir.join(format!("{base_name}.{extension}"));+ let mut counter = 2;+ while destination.exists() {+ destination = target_dir.join(format!("{base_name}_{counter}.{extension}"));+ counter += 1;+ }++ self.state.is_waiting_for_download_stream = false;+ self.state.download_status = Some("Preparing download...".into());+ self.state.download_progress = Some(0.0);+ self.state+ .cancel_download+ .store(false, std::sync::atomic::Ordering::SeqCst);+ self.state.toast_message = Some("Download started. Partial data will be preserved.".into());+ self.state.toast_timer = 80;++ let cancel = self.state.cancel_download.clone();+ let sender = self.action_sender.clone();+ let client = reqwest::Client::builder()+ .connect_timeout(std::time::Duration::from_secs(15))+ .tcp_keepalive(std::time::Duration::from_secs(30))+ .build()+ .unwrap_or_else(|_| self.client.http_client().clone());++ tokio::spawn(async move {+ if let Err(error) = tokio::fs::create_dir_all(&target_dir).await {+ sender+ .send(Action::DownloadFailed(format!(+ "Cannot create download directory: {error}"+ )))+ .ok();+ return;+ }++ if let Some(subtitle_url) = subtitle_url {+ let subtitle_path = destination.with_extension("srt");+ let subtitle_client = client.clone();+ tokio::spawn(async move {+ if let Ok(response) = subtitle_client.get(subtitle_url).send().await+ && response.status().is_success()+ && let Ok(bytes) = response.bytes().await+ {+ let _ = tokio::fs::write(subtitle_path, bytes).await;+ }+ });+ }++ let progress_sender = sender.clone();+ let result =+ crate::download::download(&client, &link, &destination, cancel, move |progress| {+ let total = progress.total.unwrap_or_default();+ let percentage = if total > 0 {+ progress.downloaded as f64 / total as f64 * 100.0+ } else {+ 0.0+ };+ let speed = progress.bytes_per_second / 1024.0 / 1024.0;+ let eta = if total > progress.downloaded && progress.bytes_per_second > 0.0 {+ (total - progress.downloaded) as f64 / progress.bytes_per_second+ } else {+ 0.0+ };+ let status = if total > 0 {+ format!(+ "{:.1}/{:.1} MB | {:.1} MB/s | ETA {:.0}s | {}x | attempt {}",+ progress.downloaded as f64 / 1024.0 / 1024.0,+ total as f64 / 1024.0 / 1024.0,+ speed,+ eta,+ progress.workers,+ progress.attempt+ )+ } else {+ format!(+ "{:.1} MB | {:.1} MB/s | {}x | attempt {}",+ progress.downloaded as f64 / 1024.0 / 1024.0,+ speed,+ progress.workers,+ progress.attempt+ )+ };+ progress_sender+ .send(Action::UpdateDownload(Some(percentage), Some(status)))+ .ok();+ })+ .await;++ match result {+ Ok(crate::download::DownloadOutcome::Completed { .. }) => {+ sender+ .send(Action::DownloadCompleted(+ destination.to_string_lossy().into_owned(),+ ))+ .ok();+ }+ Ok(crate::download::DownloadOutcome::Paused { .. }) => {+ sender+ .send(Action::DownloadPaused(+ destination.to_string_lossy().into_owned(),+ ))+ .ok();+ }+ Err(error) => {+ sender.send(Action::DownloadFailed(error.to_string())).ok();+ }+ }+ });+ }+pub async fn run<B: ratatui::backend::Backend>(&mut self,terminal: &mut ratatui::Terminal<B>,@@ -2958,610 +3138,9 @@ impl App {}}Action::DownloadStream(subtitle_url) => {- if self.state.download_progress.is_some() {- return None;- }- if self.state.active_screen == Screen::Details {- let link_opt = self.get_selected_link();- let title = self- .state- .selected_details- .as_ref()- .and_then(|d| d.get("title"))- .and_then(|t| t.as_str())- .unwrap_or("MovieBox-Tui_Stream")- .to_string();- let stype = self- .state- .selected_details- .as_ref()- .and_then(|d| d.get("stype").or_else(|| d.get("subjectType")))- .and_then(|v| v.as_i64())- .unwrap_or(1);- let season = self.state.selected_season;- let episode = self.state.selected_episode;-- let mut sanitized_title = title.replace(" ", "_");- for c in &['/', '\\', ':', '*', '?', '"', '<', '>', '|'] {- sanitized_title = sanitized_title.replace(*c, "_");- }-- if let Some(link) = link_opt {- self.state.is_waiting_for_download_stream = false;- self.state.toast_message = Some(format!(- "{} Starting native download...",- if self.state.basic_terminal {- "[OK]"- } else {- "✓"- }- ));- self.state.toast_timer = 40;- self.state.download_status = Some("Connecting...".to_string());- self.state.download_progress = Some(0.0);- self.state- .cancel_download- .store(false, std::sync::atomic::Ordering::SeqCst);-- let cancel_token = self.state.cancel_download.clone();- let sender = self.action_sender.clone();- let client = reqwest::Client::builder()- .connect_timeout(std::time::Duration::from_secs(10))- .tcp_keepalive(std::time::Duration::from_secs(30))- .build()- .unwrap_or_else(|_| self.client.http_client().clone());- tokio::spawn(async move {- let head_res = client.head(&link).send().await;- let (total_size, supports_ranges, ext) = match head_res {- Ok(r) => {- let size = r.content_length().unwrap_or(0);- let ranges = r- .headers()- .get(reqwest::header::ACCEPT_RANGES)- .and_then(|v| v.to_str().ok())- .unwrap_or("")- == "bytes";- let ext = r- .headers()- .get(reqwest::header::CONTENT_DISPOSITION)- .and_then(|v| v.to_str().ok())- .and_then(|s| s.split('.').next_back())- .unwrap_or("mp4")- .to_string();- (size, ranges, ext)- }- Err(e) => {- sender- .send(Action::UpdateDownload(- None,- Some(format!("Head Error: {}", e)),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3)).await;- sender.send(Action::UpdateDownload(None, None)).ok();- return;- }- };-- let base_dir = dirs::download_dir()- .unwrap_or_else(|| std::path::PathBuf::from("."))- .join("MovieBox-TUI");-- let (target_dir, base_filename) = if stype == 2 {- let dir = base_dir- .join("Series")- .join(&sanitized_title)- .join(format!("Season {}", season));- let fname =- format!("{}_S{:02}E{:02}", sanitized_title, season, episode);- (dir, fname)- } else {- let dir = base_dir.join("Movies");- (dir, sanitized_title.clone())- };-- std::fs::create_dir_all(&target_dir).ok();-- let mut filename = format!("{}.{}", base_filename, ext);- let mut filepath = target_dir.join(&filename);-- let mut counter = 2;- while filepath.exists() {- filename = format!("{}_{}.{}", base_filename, counter, ext);- filepath = target_dir.join(&filename);- counter += 1;- }-- if let Some(sub_url) = subtitle_url {- let sub_ext = sub_url.split('.').next_back().unwrap_or("srt");- let sub_ext = if sub_ext.len() <= 4 { sub_ext } else { "srt" };-- let mut sub_filename = filename.clone();- if let Some(dot_idx) = sub_filename.rfind('.') {- sub_filename.truncate(dot_idx);- }- sub_filename.push_str(&format!(".{}", sub_ext));-- let sub_target = target_dir.join(&sub_filename);- let sub_client = client.clone();- tokio::spawn(async move {- if let Ok(res) = sub_client.get(&sub_url).send().await {- if let Ok(bytes) = res.bytes().await {- let _ = tokio::fs::write(sub_target, bytes).await;- }- }- });- }-- if supports_ranges && total_size > 5 * 1024 * 1024 {- let num_connections = 16;- let chunk_size = total_size / num_connections;- let mut handles = vec![];-- let downloaded_total =- std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0));- let start_time = std::time::Instant::now();-- let ui_downloaded = downloaded_total.clone();- let ui_sender = sender.clone();- let ui_cancel = cancel_token.clone();- let ui_handle = tokio::spawn(async move {- loop {- tokio::time::sleep(std::time::Duration::from_millis(200))- .await;- if ui_cancel.load(std::sync::atomic::Ordering::Relaxed) {- break;- }-- let current_dl = ui_downloaded- .load(std::sync::atomic::Ordering::Relaxed);- let progress = (current_dl as f64 / total_size as f64)- .clamp(0.0, 1.0)- * 100.0;- let elapsed = start_time.elapsed().as_secs_f64();- let speed_bps = if elapsed > 0.0 {- current_dl as f64 / elapsed- } else {- 0.0- };- let speed_mbps = speed_bps / 1024.0 / 1024.0;- let remaining_bytes =- total_size.saturating_sub(current_dl) as f64;- let eta_secs = if speed_bps > 0.0 {- remaining_bytes / speed_bps- } else {- 0.0- };-- let status = format!(- "{:.1} MB / {:.1} MB | {:.1} MB/s | ETA: {:.0}s [16x]",- current_dl as f64 / 1024.0 / 1024.0,- total_size as f64 / 1024.0 / 1024.0,- speed_mbps,- eta_secs- );- ui_sender- .send(Action::UpdateDownload(- Some(progress),- Some(status),- ))- .ok();- if current_dl >= total_size {- break;- }- }- });-- let mut temp_files = vec![];- for i in 0..num_connections {- let start = i * chunk_size;- let end = if i == num_connections - 1 {- total_size - 1- } else {- start + chunk_size - 1- };-- let part_filepath =- filepath.with_extension(format!("part{}", i));- temp_files.push(part_filepath.clone());-- let client_clone = client.clone();- let link_clone = link.clone();- let dl_total = downloaded_total.clone();- let c_token = cancel_token.clone();-- handles.push(tokio::spawn(async move {- let file_res =- tokio::fs::File::create(&part_filepath).await;- if file_res.is_err() {- return Err(());- }- let mut file = tokio::io::BufWriter::with_capacity(- 128 * 1024,- file_res.unwrap(),- );-- let req = client_clone- .get(&link_clone)- .header(- reqwest::header::RANGE,- format!("bytes={}-{}", start, end),- )- .send()- .await;- if req.is_err() {- return Err(());- }- let mut res = req.unwrap();-- use tokio::io::AsyncWriteExt;- let expected_size = end - start + 1;- let mut part_downloaded = 0;- loop {- match res.chunk().await {- Ok(Some(chunk)) => {- if c_token- .load(std::sync::atomic::Ordering::Relaxed)- {- return Err(());- }-- let chunk_to_write = if part_downloaded- + chunk.len() as u64- > expected_size- {- &chunk[..(expected_size - part_downloaded)- as usize]- } else {- &chunk[..]- };-- if file.write_all(chunk_to_write).await.is_err()- {- return Err(());- }- dl_total.fetch_add(- chunk_to_write.len() as u64,- std::sync::atomic::Ordering::Relaxed,- );- part_downloaded += chunk_to_write.len() as u64;-- if part_downloaded >= expected_size {- break;- }- }- Ok(None) => break,- Err(_) => return Err(()),- }- }-- if part_downloaded < expected_size {- return Err(());- }- let _ = file.flush().await;- Ok(())- }));- }-- let mut any_err = false;- for h in handles {- if let Ok(res) = h.await {- if res.is_err() {- any_err = true;- }- } else {- any_err = true;- }- }- ui_handle.abort();-- if cancel_token.load(std::sync::atomic::Ordering::Relaxed) {- for file in temp_files {- let _ = tokio::fs::remove_file(file).await;- }- let _ = tokio::fs::remove_file(&filepath).await;- sender- .send(Action::UpdateDownload(- None,- Some("Download Cancelled".to_string()),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3)).await;- sender.send(Action::UpdateDownload(None, None)).ok();- return;- }-- if any_err {- for tmp in &temp_files {- let _ = tokio::fs::remove_file(tmp).await;- }- sender- .send(Action::UpdateDownload(- None,- Some("Failed to download parts".to_string()),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3)).await;- sender.send(Action::UpdateDownload(None, None)).ok();- return;- }-- sender- .send(Action::UpdateDownload(- Some(100.0),- Some("Merging parts...".to_string()),- ))- .ok();- if let Ok(final_file) = tokio::fs::File::create(&filepath).await {- use tokio::io::AsyncWriteExt;- let mut final_buf = tokio::io::BufWriter::with_capacity(- 1024 * 1024,- final_file,- );- let mut merge_ok = true;- for tmp in &temp_files {- if let Ok(mut part_file) = tokio::fs::File::open(tmp).await- {- if tokio::io::copy(&mut part_file, &mut final_buf)- .await- .is_err()- {- merge_ok = false;- break;- }- } else {- merge_ok = false;- break;- }- }- let _ = final_buf.flush().await;- for tmp in &temp_files {- let _ = tokio::fs::remove_file(tmp).await;- }-- if merge_ok {- sender- .send(Action::UpdateDownload(- Some(100.0),- Some("Completed!".to_string()),- ))- .ok();- } else {- let _ = tokio::fs::remove_file(&filepath).await;- sender- .send(Action::UpdateDownload(- None,- Some("Failed to merge parts".to_string()),- ))- .ok();- }- }- tokio::time::sleep(std::time::Duration::from_secs(3)).await;- sender.send(Action::UpdateDownload(None, None)).ok();- } else {- match client.get(&link).send().await {- Ok(mut response) => {- if !response.status().is_success() {- sender- .send(Action::UpdateDownload(- None,- Some(format!(- "Error: Status {}",- response.status()- )),- ))- .ok();- return;- }- let mut downloaded: u64 = 0;- if let Ok(file) = tokio::fs::File::create(&filepath).await {- use tokio::io::AsyncWriteExt;- let mut buf_writer =- tokio::io::BufWriter::with_capacity(- 1024 * 1024,- file,- );- let start_time = std::time::Instant::now();- let mut last_ui_update = std::time::Instant::now();-- sender- .send(Action::UpdateDownload(- None,- Some(format!("Downloading to {}", filename)),- ))- .ok();- loop {- match response.chunk().await {- Ok(Some(chunk)) => {- if cancel_token.load(- std::sync::atomic::Ordering::Relaxed,- ) {- let _ =- tokio::fs::remove_file(&filepath)- .await;- sender- .send(Action::UpdateDownload(- None,- Some(- "Download Cancelled"- .to_string(),- ),- ))- .ok();- tokio::time::sleep(- std::time::Duration::from_secs(2),- )- .await;- sender- .send(Action::UpdateDownload(- None, None,- ))- .ok();- return;- }- if buf_writer- .write_all(&chunk)- .await- .is_err()- {- sender- .send(Action::UpdateDownload(- None,- Some(- "File write error!"- .to_string(),- ),- ))- .ok();- return;- }- downloaded += chunk.len() as u64;-- let now = std::time::Instant::now();- if now- .duration_since(last_ui_update)- .as_millis()- > 200- {- last_ui_update = now;- let progress = if total_size > 0 {- (downloaded as f64- / total_size as f64)- * 100.0- } else {- 0.0- };-- let elapsed = now- .duration_since(start_time)- .as_secs_f64();- let speed_bps = if elapsed > 0.0 {- downloaded as f64 / elapsed- } else {- 0.0- };- let speed_mbps =- speed_bps / 1024.0 / 1024.0;-- let remaining_bytes = total_size- .saturating_sub(downloaded)- as f64;- let eta_secs = if speed_bps > 0.0 {- remaining_bytes / speed_bps- } else {- 0.0- };-- let status = format!(- "{:.1} MB / {:.1} MB | {:.1} MB/s | ETA: {:.0}s [1x]",- downloaded as f64 / 1024.0 / 1024.0,- total_size as f64 / 1024.0 / 1024.0,- speed_mbps,- eta_secs- );- sender- .send(Action::UpdateDownload(- Some(progress),- Some(status),- ))- .ok();- }- }- Ok(None) => break,- Err(e) => {- let _ =- tokio::fs::remove_file(&filepath).await;- sender- .send(Action::UpdateDownload(- None,- Some(format!(- "Stream Error: {}",- e- )),- ))- .ok();- tokio::time::sleep(- std::time::Duration::from_secs(3),- )- .await;- sender- .send(Action::UpdateDownload(- None, None,- ))- .ok();- return;- }- }- }-- if total_size > 0 && downloaded != total_size {- let _ = tokio::fs::remove_file(&filepath).await;- sender- .send(Action::UpdateDownload(- None,- Some("Incomplete download".to_string()),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(- 3,- ))- .await;- sender- .send(Action::UpdateDownload(None, None))- .ok();- return;- }- let _ = buf_writer.flush().await;- sender- .send(Action::UpdateDownload(- Some(100.0),- Some("Completed!".to_string()),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3))- .await;- sender.send(Action::UpdateDownload(None, None)).ok();- } else {- sender- .send(Action::UpdateDownload(- None,- Some("Failed to create file".to_string()),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3))- .await;- sender.send(Action::UpdateDownload(None, None)).ok();- }- }- Err(e) => {- sender- .send(Action::UpdateDownload(- None,- Some(format!("Network Error: {}", e)),- ))- .ok();- tokio::time::sleep(std::time::Duration::from_secs(3)).await;- sender.send(Action::UpdateDownload(None, None)).ok();- }- }- }- });- } else if self.state.is_fetching_streams {- self.state.toast_message =- Some("Waiting for streams to load...".to_string());- self.state.toast_timer = 60;- self.state.is_waiting_for_download_stream = true;- } else {- self.state.toast_message =- Some("No streams available to download.".to_string());- self.state.toast_timer = 60;- if self.state.download_queue_total > 0 {- self.action_sender.send(Action::ProcessDownloadQueue).ok();- }- }- }+ self.start_resilient_download(subtitle_url);+ return None;}-Action::PromptDownloadEpisode => {if self.state.active_provider != ProviderKind::MovieBox {self.state.status_message =@@ -4412,9 +3991,52 @@ impl App {self.state.download_status = stat;self.state.dirty = true;}-- if prog.is_none() && !self.state.download_queue.is_empty() {+ }+ Action::DownloadCompleted(path) => {+ self.state.download_progress = Some(100.0);+ self.state.download_status = Some("Completed".into());+ self.state.toast_message = Some(format!("Downloaded to {path}"));+ self.state.toast_timer = 120;+ let sender = self.action_sender.clone();+ tokio::spawn(async move {+ tokio::time::sleep(std::time::Duration::from_secs(2)).await;+ sender.send(Action::ClearDownload).ok();+ });+ }+ Action::DownloadFailed(error) => {+ self.state.download_progress = None;+ self.state.download_status = None;+ self.state.download_queue.clear();+ self.state.download_queue_total = 0;+ self.state.toast_message =+ Some(format!("Download failed; partial preserved: {error}"));+ self.state.toast_timer = 240;+ self.state.status_message =+ format!("Download failed; retry to resume. Reason: {error}");+ self.state.status_timer = 240;+ }+ Action::DownloadPaused(path) => {+ self.state.download_progress = None;+ self.state.download_status = None;+ self.state.download_queue.clear();+ self.state.download_queue_total = 0;+ self.state.toast_message = Some(format!(+ "Download paused. Start again to resume: {path}.part"+ ));+ self.state.toast_timer = 240;+ }+ Action::ClearDownload => {+ self.state.download_progress = None;+ self.state.download_status = None;+ if !self.state.download_queue.is_empty() {self.action_sender.send(Action::ProcessDownloadQueue).ok();+ } else if self.state.download_queue_total > 0 {+ self.state.toast_message = Some(format!(+ "Season download complete! ({} files)",+ self.state.download_queue_total+ ));+ self.state.toast_timer = 120;+ self.state.download_queue_total = 0;}}Action::CancelDownload => {