Skip to content

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

50.7 KB
Raw Blame
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::{AsyncSeekExt, AsyncWriteExt};

const MAX_ATTEMPTS: usize = 4;
const SEGMENT_THRESHOLD: u64 = 8 * 1024 * 1024;
const MAX_SEGMENTS: usize = 16;
pub const DEFAULT_STREAM_NAME: &str = "MovieBox-Tui_Stream";

pub fn safe_file_stem(value: &str) -> String {
    let mut stem = value
        .chars()
        .take(120)
        .map(|character| {
            if character.is_control()
                || matches!(
                    character,
                    '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|'
                )
            {
                '_'
            } else {
                character
            }
        })
        .collect::<String>();
    stem = stem.trim_matches(['.', ' ', '_']).to_string();
    if stem.is_empty() {
        return DEFAULT_STREAM_NAME.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
}

pub fn resolve_media_target(
    base_dir: &Path,
    safe_title: &str,
    is_series: bool,
    season: usize,
    episode: usize,
) -> (PathBuf, String) {
    if is_series {
        (
            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").join(safe_title),
            safe_title.to_string(),
        )
    }
}

#[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,
}

impl DownloadError {
    pub fn user_message(&self) -> String {
        match self {
            Self::Http(status) => match *status {
                StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => {
                    format!("Server refused download (HTTP {}).", status.as_u16())
                }
                StatusCode::NOT_FOUND | StatusCode::GONE => {
                    "File is no longer available on server.".to_string()
                }
                StatusCode::TOO_MANY_REQUESTS => {
                    "Server rate limit exceeded. Try again later.".to_string()
                }
                other if other.is_server_error() => {
                    format!("Server error (HTTP {}). Try again later.", other.as_u16())
                }
                other => format!("Server returned HTTP {}.", other.as_u16()),
            },
            Self::Network(error) => {
                if error.is_timeout() {
                    "Connection timed out.".to_string()
                } else if error.is_connect() {
                    "Cannot reach download server.".to_string()
                } else {
                    "Connection to server was lost.".to_string()
                }
            }
            Self::File(error) => format!("File write error: {}.", error.kind()),
            Self::InvalidRange(reason) if reason.contains("timeout") => {
                "Connection timed out.".to_string()
            }
            Self::InvalidRange(_) => "Server returned invalid partial response.".to_string(),
            Self::Incomplete {
                downloaded,
                expected,
            } => format!(
                "Download stopped at {:.1} of {:.1} MB.",
                *downloaded as f64 / 1_048_576.0,
                *expected as f64 / 1_048_576.0
            ),
            Self::Paused => "Download paused.".to_string(),
        }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct ResumeMetadata {
    etag: Option<String>,
    last_modified: Option<String>,
    total: Option<u64>,
    segments: Option<usize>,
    #[serde(default)]
    segment_progress: Vec<u64>,
}

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 {
        let is_segmented_state = metadata.segments.is_some();
        if cancel.load(Ordering::Relaxed) {
            let paused_bytes = if is_segmented_state {
                metadata.segment_progress.iter().sum()
            } else {
                file_len(&partial).await
            };
            return Ok(DownloadOutcome::Paused {
                bytes: paused_bytes,
            });
        }

        let mut offset = if is_segmented_state {
            0
        } else {
            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);
            }
        } else if !segmented_disabled {
            request = request.header(RANGE, "bytes=0-0");
        }

        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 || !metadata.segment_progress.is_empty())
            && (response.status() == StatusCode::OK
                || response.status() == StatusCode::PARTIAL_CONTENT)
            && response
                .headers()
                .get(ACCEPT_RANGES)
                .and_then(|value| value.to_str().ok())
                .is_none_or(|value| !value.eq_ignore_ascii_case("none"))
        {
            let total_opt = if response.status() == StatusCode::PARTIAL_CONTENT {
                response
                    .headers()
                    .get(CONTENT_RANGE)
                    .and_then(|value| value.to_str().ok())
                    .and_then(|cr| parse_content_range(cr).ok())
                    .and_then(|(_, t)| t)
            } else {
                response.content_length()
            };
            if let Some(total) = total_opt.filter(|&t| t >= SEGMENT_THRESHOLD) {
                let segments = segment_count(total);
                let mut current_metadata = ResumeMetadata {
                    etag: header_string(&response, ETAG),
                    last_modified: header_string(&response, LAST_MODIFIED),
                    total: Some(total),
                    segments: Some(segments),
                    segment_progress: vec![0; segments],
                };
                if metadata_matches(&metadata, &current_metadata)
                    && metadata.segment_progress.len() == segments
                    && file_len(&partial).await == total
                {
                    current_metadata.segment_progress = metadata.segment_progress.clone();
                }
                write_metadata(&metadata_path, &current_metadata).await?;
                drop(response);
                match download_segmented(
                    client,
                    url,
                    destination,
                    &metadata_path,
                    current_metadata,
                    cancel.clone(),
                    &mut report,
                )
                .await
                {
                    Err(DownloadError::InvalidRange(_))
                    | Err(DownloadError::Http(_))
                    | Err(DownloadError::Network(_)) => {
                        let _ = tokio::fs::remove_file(&partial).await;
                        metadata = ResumeMetadata::default();
                        write_metadata(&metadata_path, &metadata).await?;
                        segmented_disabled = true;
                        continue;
                    }
                    result => return result,
                }
            }
            if offset == 0 && response.status() == StatusCode::PARTIAL_CONTENT {
                drop(response);
                segmented_disabled = true;
                continue;
            }
        }
        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;
        }

        if offset == 0 && file_len(&partial).await > 0 {
            truncate(&partial).await?;
        }
        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;
        metadata.segment_progress.clear();
        write_metadata(&metadata_path, &metadata).await?;
        let raw_file = tokio::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(&partial)
            .await?;
        let mut file = tokio::io::BufWriter::with_capacity(256 * 1024, raw_file);
        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 tokio::time::timeout(Duration::from_secs(30), response.chunk()).await {
                Ok(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.saturating_sub(offset) as f64 / elapsed
                            } else {
                                0.0
                            },
                            attempt,
                            workers: 1,
                        });
                        last_report = Instant::now();
                    }
                }
                Ok(Ok(None)) => {
                    file.flush().await?;
                    file.get_mut().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 });
                }
                Ok(Err(error)) => {
                    file.flush().await?;
                    last_error = Some(DownloadError::Network(error));
                    break;
                }
                Err(_) => {
                    file.flush().await?;
                    last_error = Some(DownloadError::InvalidRange("read timeout".into()));
                    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,
    mut metadata: ResumeMetadata,
    cancel: Arc<AtomicBool>,
    report: &mut F,
) -> Result<DownloadOutcome, DownloadError>
where
    F: FnMut(DownloadProgress),
{
    let partial_buf = sidecar_path(destination, "part");
    let partial_path = partial_buf.as_path();
    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);
    if metadata.segment_progress.len() != segments {
        metadata.segment_progress = vec![0; segments];
    }

    let raw_partial = tokio::fs::OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(false)
        .open(partial_path)
        .await?;
    if raw_partial.metadata().await.map(|m| m.len()).unwrap_or(0) != total {
        raw_partial.set_len(total).await?;
        metadata.segment_progress.fill(0);
    }
    drop(raw_partial);

    let mut initial = 0u64;
    let mut segment_counters = Vec::with_capacity(segments);
    for (index, &(start, end)) in ranges.iter().enumerate() {
        let expected = end - start + 1;
        let written = metadata.segment_progress[index].min(expected);
        metadata.segment_progress[index] = written;
        initial += written;
        segment_counters.push(Arc::new(AtomicU64::new(written)));
    }
    write_metadata(metadata_path, &metadata).await?;

    let downloaded = Arc::new(AtomicU64::new(initial));
    let (progress_sender, mut progress_receiver) = tokio::sync::mpsc::channel::<(u64, usize)>(128);
    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 = partial_path.to_path_buf();
        let cancel = cancel.clone();
        let progress_sender = progress_sender.clone();
        let validator = validator.clone();
        let seg_counter = Arc::clone(&segment_counters[index]);
        tasks.spawn(async move {
            download_segment(
                &client,
                &url,
                &path,
                start,
                end,
                total,
                seg_counter,
                validator,
                cancel,
                progress_sender,
            )
            .await
        });
    }
    drop(progress_sender);

    let started = Instant::now();
    let mut last_report = Instant::now() - Duration::from_secs(1);
    let mut last_meta_flush = Instant::now();
    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();
                    }
                    if last_meta_flush.elapsed() >= Duration::from_secs(2) {
                        for (idx, counter) in segment_counters.iter().enumerate() {
                            metadata.segment_progress[idx] = counter.load(Ordering::Relaxed);
                        }
                        let _ = write_metadata(metadata_path, &metadata).await;
                        last_meta_flush = Instant::now();
                    }
                }
            }
            result = tasks.join_next() => {
                match result {
                    Some(Ok(Ok(()))) => finished += 1,
                    Some(Ok(Err(DownloadError::Paused))) => {
                        tasks.abort_all();
                        for (idx, counter) in segment_counters.iter().enumerate() {
                            metadata.segment_progress[idx] = counter.load(Ordering::Relaxed);
                        }
                        let _ = write_metadata(metadata_path, &metadata).await;
                        return Ok(DownloadOutcome::Paused {
                            bytes: downloaded.load(Ordering::Relaxed),
                        });
                    }
                    Some(Ok(Err(error))) => {
                        tasks.abort_all();
                        for (idx, counter) in segment_counters.iter().enumerate() {
                            metadata.segment_progress[idx] = counter.load(Ordering::Relaxed);
                        }
                        let _ = write_metadata(metadata_path, &metadata).await;
                        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) {
        for (idx, counter) in segment_counters.iter().enumerate() {
            metadata.segment_progress[idx] = counter.load(Ordering::Relaxed);
        }
        let _ = write_metadata(metadata_path, &metadata).await;
        return Ok(DownloadOutcome::Paused {
            bytes: downloaded.load(Ordering::Relaxed),
        });
    }

    let final_file = tokio::fs::OpenOptions::new()
        .write(true)
        .open(partial_path)
        .await?;
    final_file.sync_data().await?;
    drop(final_file);
    if file_len(partial_path).await != total {
        return Err(DownloadError::Incomplete {
            downloaded: file_len(partial_path).await,
            expected: total,
        });
    }
    finalize(partial_path, metadata_path, destination).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,
    segment_written: Arc<AtomicU64>,
    validator: Option<String>,
    cancel: Arc<AtomicBool>,
    progress: tokio::sync::mpsc::Sender<(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 = segment_written.load(Ordering::Relaxed).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 {
            let error = DownloadError::InvalidRange(format!(
                "worker expected HTTP 206, received {}",
                response.status()
            ));
            if response.status() == StatusCode::OK {
                return Err(error);
            }
            last_error = Some(error);
            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 raw_file = tokio::fs::OpenOptions::new()
            .create(true)
            .write(true)
            .truncate(false)
            .open(path)
            .await?;
        raw_file
            .seek(std::io::SeekFrom::Start(requested_start))
            .await?;
        let mut file = tokio::io::BufWriter::with_capacity(1024 * 1024, raw_file);
        let mut response = response;
        let mut written = existing;
        let mut unbatched_bytes = 0u64;
        let mut last_progress_send = Instant::now();
        loop {
            if cancel.load(Ordering::Relaxed) {
                if unbatched_bytes > 0 {
                    let _ = progress.send((unbatched_bytes, attempt)).await;
                }
                file.flush().await?;
                segment_written.store(written, Ordering::Relaxed);
                return Err(DownloadError::Paused);
            }
            match tokio::time::timeout(Duration::from_secs(30), response.chunk()).await {
                Ok(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;
                    segment_written.store(written - file.buffer().len() as u64, Ordering::Relaxed);
                    unbatched_bytes += bytes as u64;
                    if unbatched_bytes >= 512 * 1024
                        || last_progress_send.elapsed() >= Duration::from_millis(120)
                    {
                        let _ = progress.try_send((unbatched_bytes, attempt));
                        unbatched_bytes = 0;
                        last_progress_send = Instant::now();
                    }
                    if written == expected {
                        if unbatched_bytes > 0 {
                            let _ = progress.send((unbatched_bytes, attempt)).await;
                        }
                        file.flush().await?;
                        return Ok(());
                    }
                }
                Ok(Ok(None)) => {
                    if unbatched_bytes > 0 {
                        let _ = progress.send((unbatched_bytes, attempt)).await;
                    }
                    file.flush().await?;
                    segment_written.store(written, Ordering::Relaxed);
                    last_error = Some(DownloadError::Incomplete {
                        downloaded: written,
                        expected,
                    });
                    break;
                }
                Ok(Err(error)) => {
                    if unbatched_bytes > 0 {
                        let _ = progress.send((unbatched_bytes, attempt)).await;
                    }
                    file.flush().await?;
                    segment_written.store(written, Ordering::Relaxed);
                    last_error = Some(DownloadError::Network(error));
                    break;
                }
                Err(_) => {
                    if unbatched_bytes > 0 {
                        let _ = progress.send((unbatched_bytes, attempt)).await;
                    }
                    file.flush().await?;
                    segment_written.store(written, Ordering::Relaxed);
                    last_error = Some(DownloadError::InvalidRange("read timeout".into()));
                    break;
                }
            }
        }
        retry_delay(attempt).await;
    }

    Err(last_error.unwrap_or(DownloadError::Incomplete {
        downloaded: segment_written.load(Ordering::Relaxed),
        expected,
    }))
}

fn segment_count(total: u64) -> usize {
    if total < 32 * 1024 * 1024 {
        4
    } else if total < 128 * 1024 * 1024 {
        8
    } else if total < 512 * 1024 * 1024 {
        12
    } 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 metadata_matches(previous: &ResumeMetadata, current: &ResumeMetadata) -> bool {
    if previous.total.is_none()
        || previous.total != current.total
        || previous.segments != current.segments
    {
        return false;
    }

    if let (Some(a), Some(b)) = (&previous.etag, &current.etag) {
        return a == b;
    }

    match (&previous.last_modified, &current.last_modified) {
        (Some(a), Some(b)) => a == b,
        (None, None) => previous.etag.is_none() && current.etag.is_none(),
        _ => false,
    }
}

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> {
    if tokio::fs::rename(partial, destination).await.is_err() {
        let _ = tokio::fs::remove_file(destination).await;
        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;
    }
}

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

    #[test]
    fn test_parse_content_range_valid() {
        let (start, total) = parse_content_range("bytes 0-1023/2048").unwrap();
        assert_eq!(start, 0);
        assert_eq!(total, Some(2048));

        let (start, total) = parse_content_range("bytes 500-999/*").unwrap();
        assert_eq!(start, 500);
        assert_eq!(total, None);
    }

    #[test]
    fn test_parse_content_range_invalid() {
        assert!(parse_content_range("invalid range").is_err());
        assert!(parse_content_range("bytes invalid").is_err());
    }

    #[test]
    fn test_segment_ranges_partitioning() {
        let total = 1000;
        let ranges = segment_ranges(total, 4);
        assert_eq!(ranges.len(), 4);
        assert_eq!(ranges[0], (0, 249));
        assert_eq!(ranges[1], (250, 499));
        assert_eq!(ranges[2], (500, 749));
        assert_eq!(ranges[3], (750, 999));
    }

    #[test]
    fn test_segment_count_scaling() {
        assert_eq!(segment_count(16 * 1024 * 1024), 4);
        assert_eq!(segment_count(64 * 1024 * 1024), 8);
        assert_eq!(segment_count(256 * 1024 * 1024), 12);
        assert_eq!(segment_count(1024 * 1024 * 1024), 16);
    }

    #[tokio::test]
    async fn test_segmented_in_place_download_and_resume() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        use tokio::net::TcpListener;

        let total_size: usize = 16 * 1024 * 1024;
        let payload: Arc<Vec<u8>> = Arc::new((0..total_size).map(|i| (i % 251) as u8).collect());

        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let url = format!("http://127.0.0.1:{port}/segmented_movie.mp4");

        let server_payload = Arc::clone(&payload);
        let server = tokio::spawn(async move {
            loop {
                let Ok((mut socket, _)) = listener.accept().await else {
                    break;
                };
                let data = Arc::clone(&server_payload);
                tokio::spawn(async move {
                    let mut buf = [0u8; 2048];
                    let Ok(n) = socket.read(&mut buf).await else {
                        return;
                    };
                    let req = String::from_utf8_lossy(&buf[..n]);
                    let mut range_header = None;
                    for line in req.lines() {
                        if let Some(val) = line
                            .strip_prefix("Range: bytes=")
                            .or_else(|| line.strip_prefix("range: bytes="))
                        {
                            range_header = Some(val.trim().to_string());
                        }
                    }
                    let total = data.len();
                    if let Some(r) = range_header {
                        let (s_str, e_str) = r.split_once('-').unwrap();
                        let start: usize = s_str.parse().unwrap();
                        if start >= total {
                            let resp = format!(
                                "HTTP/1.1 416 Range Not Satisfiable\r\nContent-Range: bytes */{total}\r\nConnection: close\r\n\r\n"
                            );
                            let _ = socket.write_all(resp.as_bytes()).await;
                            return;
                        }
                        let end: usize = if e_str.is_empty() {
                            total - 1
                        } else {
                            e_str.parse().unwrap()
                        };
                        let slice = &data[start..=end];
                        let resp = format!(
                            "HTTP/1.1 206 Partial Content\r\nAccept-Ranges: bytes\r\nContent-Range: bytes {start}-{end}/{total}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
                            slice.len()
                        );
                        let _ = socket.write_all(resp.as_bytes()).await;
                        let _ = socket.write_all(slice).await;
                    } else {
                        let resp = format!(
                            "HTTP/1.1 200 OK\r\nAccept-Ranges: bytes\r\nContent-Length: {total}\r\nConnection: close\r\n\r\n"
                        );
                        let _ = socket.write_all(resp.as_bytes()).await;
                    }
                });
            }
        });

        let temp_dir = std::env::temp_dir().join(format!("mbx_seg_inplace_{}", std::process::id()));
        tokio::fs::create_dir_all(&temp_dir).await.unwrap();
        let dest_file = temp_dir.join("movie.mp4");
        let client = crate::net::http_client_builder_base().build().unwrap();
        let cancel = Arc::new(AtomicBool::new(false));
        let mut max_workers = 0usize;

        let part_file = sidecar_path(&dest_file, "part");
        let meta_file = sidecar_path(&dest_file, "part.json");
        let seg_len = (total_size / 4) as u64;
        let mut pre_buf = vec![0u8; total_size];
        pre_buf[..seg_len as usize].copy_from_slice(&payload[..seg_len as usize]);
        tokio::fs::write(&part_file, &pre_buf).await.unwrap();
        write_metadata(
            &meta_file,
            &ResumeMetadata {
                etag: None,
                last_modified: None,
                total: Some(total_size as u64),
                segments: Some(4),
                segment_progress: vec![seg_len, 0, 0, 0],
            },
        )
        .await
        .unwrap();
        let res = download(&client, &url, &dest_file, cancel, |prog| {
            max_workers = max_workers.max(prog.workers);
        })
        .await;

        server.abort();
        assert!(
            matches!(res, Ok(DownloadOutcome::Completed { bytes }) if bytes == total_size as u64)
        );
        assert_eq!(max_workers, 4);
        let saved = tokio::fs::read(&dest_file).await.unwrap();
        assert_eq!(saved.len(), total_size);
        assert_eq!(saved, *payload);
        assert!(!sidecar_path(&dest_file, "part").exists());
        assert!(!sidecar_path(&dest_file, "part.json").exists());

        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
    }

    #[tokio::test]
    async fn test_segmented_pause_records_only_bytes_on_disk() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        use tokio::net::TcpListener;

        let total_size: usize = 16 * 1024 * 1024;
        let payload: Arc<Vec<u8>> = Arc::new((0..total_size).map(|i| (i % 251) as u8).collect());

        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let url = format!("http://127.0.0.1:{port}/slow_movie.mp4");

        let server_payload = Arc::clone(&payload);
        let server = tokio::spawn(async move {
            loop {
                let Ok((mut socket, _)) = listener.accept().await else {
                    break;
                };
                let data = Arc::clone(&server_payload);
                tokio::spawn(async move {
                    let mut buf = [0u8; 2048];
                    let Ok(n) = socket.read(&mut buf).await else {
                        return;
                    };
                    let req = String::from_utf8_lossy(&buf[..n]);
                    let range = req.lines().find_map(|line| {
                        line.strip_prefix("Range: bytes=")
                            .or_else(|| line.strip_prefix("range: bytes="))
                            .map(|v| v.trim().to_string())
                    });
                    let total = data.len();
                    let Some(range) = range else {
                        return;
                    };
                    let (s_str, e_str) = range.split_once('-').unwrap();
                    let start: usize = s_str.parse().unwrap();
                    let end: usize = if e_str.is_empty() {
                        total - 1
                    } else {
                        e_str.parse().unwrap()
                    };
                    let resp = format!(
                        "HTTP/1.1 206 Partial Content\r\nAccept-Ranges: bytes\r\nContent-Range: bytes {start}-{end}/{total}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
                        end - start + 1
                    );
                    if socket.write_all(resp.as_bytes()).await.is_err() {
                        return;
                    }
                    for chunk in data[start..=end].chunks(16 * 1024) {
                        if socket.write_all(chunk).await.is_err() {
                            return;
                        }
                        tokio::time::sleep(Duration::from_millis(5)).await;
                    }
                });
            }
        });

        let temp_dir = std::env::temp_dir().join(format!("mbx_seg_pause_{}", std::process::id()));
        tokio::fs::create_dir_all(&temp_dir).await.unwrap();
        let dest_file = temp_dir.join("movie.mp4");
        let part_file = sidecar_path(&dest_file, "part");
        let meta_file = sidecar_path(&dest_file, "part.json");
        let client = crate::net::http_client_builder_base().build().unwrap();

        let cancel = Arc::new(AtomicBool::new(false));
        let pause = Arc::clone(&cancel);
        let res = download(&client, &url, &dest_file, cancel, move |prog| {
            if prog.downloaded >= 1024 * 1024 {
                pause.store(true, Ordering::Relaxed);
            }
        })
        .await;
        assert!(matches!(res, Ok(DownloadOutcome::Paused { .. })));

        let metadata = read_metadata(&meta_file).await;
        let partial = tokio::fs::read(&part_file).await.unwrap();
        let ranges = segment_ranges(total_size as u64, metadata.segments.unwrap());
        for (&(start, _), &written) in ranges.iter().zip(&metadata.segment_progress) {
            let (start, written) = (start as usize, written as usize);
            assert_eq!(
                partial[start..start + written],
                payload[start..start + written],
                "segment at {start} claims {written} bytes that are not on disk"
            );
        }

        let res = download(
            &client,
            &url,
            &dest_file,
            Arc::new(AtomicBool::new(false)),
            |_| {},
        )
        .await;
        server.abort();
        assert!(
            matches!(res, Ok(DownloadOutcome::Completed { bytes }) if bytes == total_size as u64)
        );
        let saved = tokio::fs::read(&dest_file).await.unwrap();
        assert!(saved == *payload, "resumed download must match the source");

        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
    }

    #[test]
    fn test_safe_file_stem_empty_fallback() {
        assert_eq!(safe_file_stem(""), DEFAULT_STREAM_NAME);
        assert_eq!(safe_file_stem("   "), DEFAULT_STREAM_NAME);
        assert_eq!(safe_file_stem("..."), DEFAULT_STREAM_NAME);
        assert_eq!(safe_file_stem("___"), DEFAULT_STREAM_NAME);
    }

    #[test]
    fn test_safe_file_stem_sanitization_and_reserved() {
        assert_eq!(safe_file_stem("../../../etc/passwd"), "etc_passwd");
        assert_eq!(
            safe_file_stem("C:\\Windows\\System32\\calc.exe"),
            "C__Windows_System32_calc.exe"
        );
        assert_eq!(safe_file_stem("CON"), "CON_");
        assert_eq!(safe_file_stem("con"), "con_");
        assert_eq!(safe_file_stem("PRN"), "PRN_");
        assert_eq!(safe_file_stem("AUX"), "AUX_");
        assert_eq!(safe_file_stem("NUL"), "NUL_");
        assert_eq!(safe_file_stem("COM1"), "COM1_");
        assert_eq!(safe_file_stem("LPT9"), "LPT9_");
        assert_eq!(
            safe_file_stem("Normal Title: Special"),
            "Normal Title_ Special"
        );
        assert_eq!(
            safe_file_stem("Movie: The <Ultimate> Edition *?|"),
            "Movie_ The _Ultimate_ Edition"
        );
    }

    #[tokio::test]
    async fn test_finalize_replaces_existing_destination_cleanly() {
        let dir = std::env::temp_dir().join(format!(
            "mbx_test_finalize_{}_{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_nanos()
        ));
        tokio::fs::create_dir_all(&dir).await.unwrap();
        let partial = dir.join("video.mp4.part");
        let metadata = dir.join("video.mp4.metadata");
        let destination = dir.join("video.mp4");

        tokio::fs::write(&destination, b"old version")
            .await
            .unwrap();
        tokio::fs::write(&partial, b"new version").await.unwrap();
        tokio::fs::write(&metadata, b"{}").await.unwrap();

        let res = finalize(&partial, &metadata, &destination).await;
        assert!(res.is_ok());
        assert!(!partial.exists());
        assert!(!metadata.exists());
        assert!(destination.exists());
        assert_eq!(
            tokio::fs::read_to_string(&destination).await.unwrap(),
            "new version"
        );
        let _ = tokio::fs::remove_dir_all(&dir).await;
    }
    #[test]
    fn test_download_error_user_message() {
        let err_403 = DownloadError::Http(StatusCode::FORBIDDEN);
        assert_eq!(
            err_403.user_message(),
            "Server refused download (HTTP 403)."
        );

        let err_404 = DownloadError::Http(StatusCode::NOT_FOUND);
        assert_eq!(
            err_404.user_message(),
            "File is no longer available on server."
        );

        let err_429 = DownloadError::Http(StatusCode::TOO_MANY_REQUESTS);
        assert_eq!(
            err_429.user_message(),
            "Server rate limit exceeded. Try again later."
        );

        let err_503 = DownloadError::Http(StatusCode::SERVICE_UNAVAILABLE);
        assert_eq!(
            err_503.user_message(),
            "Server error (HTTP 503). Try again later."
        );

        let err_incomplete = DownloadError::Incomplete {
            downloaded: 10 * 1024 * 1024,
            expected: 20 * 1024 * 1024,
        };
        assert_eq!(
            err_incomplete.user_message(),
            "Download stopped at 10.0 of 20.0 MB."
        );

        let err_paused = DownloadError::Paused;
        assert_eq!(err_paused.user_message(), "Download paused.");
    }

    #[tokio::test]
    async fn test_download_forwards_custom_headers_and_content_to_local_server() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        use tokio::net::TcpListener;

        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let url = format!("http://127.0.0.1:{port}/video.mp4");

        let server = tokio::spawn(async move {
            let (mut socket, _) = listener.accept().await.unwrap();
            let mut buf = [0u8; 1024];
            let n = socket.read(&mut buf).await.unwrap();
            let req = String::from_utf8_lossy(&buf[..n]);
            let lower = req.to_lowercase();
            assert!(lower.contains("user-agent: moviebox-custom-ua"));
            assert!(lower.contains("referer: https://custom.referer.test/"));
            assert!(lower.contains("x-auth-token: secret-token-123"));
            let body = b"test video binary chunk stream";
            let response = format!(
                "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: video/mp4\r\nConnection: close\r\n\r\n",
                body.len()
            );
            socket.write_all(response.as_bytes()).await.unwrap();
            socket.write_all(body).await.unwrap();
        });

        let temp_dir = std::env::temp_dir().join(format!("mbx_dl_test_{}", std::process::id()));
        tokio::fs::create_dir_all(&temp_dir).await.unwrap();
        let dest_file = temp_dir.join("test_video.mp4");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.insert(
            reqwest::header::USER_AGENT,
            "MovieBox-Custom-UA".parse().unwrap(),
        );
        headers.insert(
            reqwest::header::REFERER,
            "https://custom.referer.test/".parse().unwrap(),
        );
        headers.insert(
            reqwest::header::HeaderName::from_static("x-auth-token"),
            "secret-token-123".parse().unwrap(),
        );

        let client = crate::net::http_client_builder_base()
            .default_headers(headers)
            .build()
            .unwrap();

        let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
        let mut progress_count = 0usize;

        let res = download(&client, &url, &dest_file, cancel, |_prog| {
            progress_count += 1;
        })
        .await;

        server.await.unwrap();
        assert!(matches!(res, Ok(DownloadOutcome::Completed { .. })));
        assert!(dest_file.exists());
        let saved = tokio::fs::read(&dest_file).await.unwrap();
        assert_eq!(saved, b"test video binary chunk stream");
        assert!(progress_count > 0);

        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
    }

    #[tokio::test]
    async fn test_download_segmented_drops_fallback_to_sequential_download() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        use tokio::net::TcpListener;

        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let url = format!("http://127.0.0.1:{port}/stream.mp4");

        let server = tokio::spawn(async move {
            let total_size = 5 * 1024 * 1024;
            let mut request_num = 0;
            while request_num < 10 {
                let (mut socket, _) = match listener.accept().await {
                    Ok(s) => s,
                    Err(_) => break,
                };
                request_num += 1;
                let mut buf = [0u8; 1024];
                let n = socket.read(&mut buf).await.unwrap_or(0);
                let req = String::from_utf8_lossy(&buf[..n]);

                if req.contains("Range: bytes=0-0") {
                    let resp = format!(
                        "HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-0/{total_size}\r\nContent-Length: 1\r\nAccept-Ranges: bytes\r\n\r\n0"
                    );
                    let _ = socket.write_all(resp.as_bytes()).await;
                } else if req.contains("Range: bytes=") && request_num <= 4 {
                    let resp = "HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n";
                    let _ = socket.write_all(resp.as_bytes()).await;
                } else {
                    let chunk = vec![b'X'; total_size];
                    let resp = format!(
                        "HTTP/1.1 200 OK\r\nContent-Length: {total_size}\r\nAccept-Ranges: none\r\nConnection: close\r\n\r\n"
                    );
                    let _ = socket.write_all(resp.as_bytes()).await;
                    let _ = socket.write_all(&chunk).await;
                    break;
                }
            }
        });

        let temp_dir =
            std::env::temp_dir().join(format!("mbx_fallback_test_{}", std::process::id()));
        tokio::fs::create_dir_all(&temp_dir).await.unwrap();
        let dest_file = temp_dir.join("fallback_stream.mp4");

        let client = reqwest::Client::new();
        let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

        let res = download(&client, &url, &dest_file, cancel, |_| {}).await;
        let _ = server.await;

        assert!(matches!(res, Ok(DownloadOutcome::Completed { .. })));
        assert!(dest_file.exists());
        let meta = tokio::fs::metadata(&dest_file).await.unwrap();
        assert_eq!(meta.len(), 5 * 1024 * 1024);

        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
    }
}