Skip to content

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

8.5 KB
Raw Blame
use super::adapter::stream_item_to_release;
use super::client::AddonClient;
use super::models::InstalledAddon;
use crate::providers::models::Release;

pub fn clean_addon_subject_id(subject_id: &str) -> &str {
    subject_id
        .strip_prefix("series:")
        .or_else(|| subject_id.strip_prefix("movie:"))
        .unwrap_or(subject_id)
}

pub async fn aggregate_streams(
    client: &AddonClient,
    addons: &[InstalledAddon],
    subject_id: &str,
    season: usize,
    episode: usize,
    is_series: bool,
) -> (Vec<Release>, Vec<String>) {
    let stream_addons: Vec<&InstalledAddon> = addons
        .iter()
        .filter(|a| a.enabled && a.provides_stream)
        .collect();

    if stream_addons.is_empty() {
        return (Vec::new(), Vec::new());
    }

    let clean_id = clean_addon_subject_id(subject_id);
    let media_type = if is_series { "series" } else { "movie" };
    let stream_id = if is_series && episode > 0 {
        let suffix = format!(":{season}:{episode}");
        if clean_id.ends_with(&suffix) {
            clean_id.to_string()
        } else {
            format!("{clean_id}{suffix}")
        }
    } else {
        clean_id.to_string()
    };

    let mut tasks = Vec::new();
    for addon in stream_addons {
        let base_url = AddonClient::base_addon_url(&addon.manifest_url);
        let addon_name = addon.name.clone();
        let client_clone = client.clone();
        let id_clone = stream_id.clone();
        let m_type = media_type.to_string();

        tasks.push(async move {
            let streams_res = tokio::time::timeout(
                std::time::Duration::from_millis(5000),
                client_clone.fetch_streams(&base_url, &m_type, &id_clone),
            )
            .await;
            match streams_res {
                Ok(Ok(items)) => {
                    let mut releases = Vec::new();
                    for item in &items {
                        if let Some(rel) =
                            stream_item_to_release(&addon_name, item, season, episode)
                        {
                            releases.push(rel);
                        }
                    }
                    if !items.is_empty() && releases.is_empty() {
                        (releases, Some(addon_name))
                    } else {
                        (releases, None)
                    }
                }
                Ok(Err(err)) => {
                    log::warn!("addon {addon_name} failed to fetch streams: {err}");
                    (Vec::new(), None)
                }
                Err(_) => {
                    log::warn!("addon {addon_name} timed out fetching streams");
                    (Vec::new(), None)
                }
            }
        });
    }

    let results = futures::future::join_all(tasks).await;
    let mut all_releases = Vec::new();
    let mut blocked_addons = Vec::new();

    for res in results {
        all_releases.extend(res.0);
        if let Some(blocked) = res.1 {
            blocked_addons.push(blocked);
        }
    }

    let mut deduplicated: Vec<Release> = Vec::new();
    for rel in all_releases {
        let direct = rel.direct_url().unwrap_or("").to_string();
        if direct.is_empty() {
            deduplicated.push(rel);
            continue;
        }
        if let Some(existing) = deduplicated
            .iter_mut()
            .find(|r| r.direct_url() == Some(&direct))
        {
            for m in rel.mirrors {
                if !existing
                    .mirrors
                    .iter()
                    .any(|em| em.resolver_url == m.resolver_url && em.label == m.label)
                {
                    existing.mirrors.push(m);
                }
            }
        } else {
            deduplicated.push(rel);
        }
    }

    deduplicated.sort_by(|a, b| {
        let q_a = quality_score(a.quality.as_deref());
        let q_b = quality_score(b.quality.as_deref());
        match q_b.cmp(&q_a) {
            std::cmp::Ordering::Equal => {
                let size_a = a.size_bytes.unwrap_or(0);
                let size_b = b.size_bytes.unwrap_or(0);
                match size_b.cmp(&size_a) {
                    std::cmp::Ordering::Equal => {
                        let label_a = a.mirrors.first().map(|m| m.label.as_str()).unwrap_or("");
                        let label_b = b.mirrors.first().map(|m| m.label.as_str()).unwrap_or("");
                        label_a.cmp(label_b)
                    }
                    other => other,
                }
            }
            other => other,
        }
    });

    (deduplicated, blocked_addons)
}

fn quality_score(quality: Option<&str>) -> u32 {
    match quality {
        Some("2160p") => 40,
        Some("1080p") => 30,
        Some("720p") => 20,
        Some("480p") => 10,
        _ => 0,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};

    #[tokio::test]
    async fn test_aggregate_streams_merges_deduplicates_sorts_and_reports_blocked_torrents() {
        let listener1 = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr1 = listener1.local_addr().unwrap();
        tokio::spawn(async move {
            if let Ok((mut stream, _)) = listener1.accept().await {
                let mut buf = [0u8; 1024];
                let _ = stream.read(&mut buf).await;
                let body = r#"{"streams":[
                    {"name":"AddonA 720p","title":"Movie.720p.mp4\n💾 1.0 GB","url":"https://cdn.example.com/720p.mp4"},
                    {"name":"AddonA 4K","title":"Movie.2160p.HEVC.mkv\n💾 10.0 GB","url":"https://cdn.example.com/2160p.mkv"}
                ]}"#;
                let resp = format!(
                    "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
                    body.len(),
                    body
                );
                let _ = stream.write_all(resp.as_bytes()).await;
            }
        });

        let listener2 = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr2 = listener2.local_addr().unwrap();
        tokio::spawn(async move {
            if let Ok((mut stream, _)) = listener2.accept().await {
                let mut buf = [0u8; 1024];
                let _ = stream.read(&mut buf).await;
                let body = r#"{"streams":[
                    {"name":"TorrentOnly","title":"P2P Swarm","infoHash":"0123456789abcdef0123456789abcdef01234567"}
                ]}"#;
                let resp = format!(
                    "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
                    body.len(),
                    body
                );
                let _ = stream.write_all(resp.as_bytes()).await;
            }
        });

        let addons = vec![
            InstalledAddon {
                manifest_url: format!("http://{addr1}/manifest.json"),
                name: "HTTP Addon".to_string(),
                version: Some("1.0.0".to_string()),
                description: None,
                enabled: true,
                provides_catalog: false,
                provides_meta: false,
                provides_stream: true,
                id_prefixes: vec![],
                types: vec!["movie".to_string()],
            },
            InstalledAddon {
                manifest_url: format!("http://{addr2}/manifest.json"),
                name: "P2P Addon".to_string(),
                version: Some("1.0.0".to_string()),
                description: None,
                enabled: true,
                provides_catalog: false,
                provides_meta: false,
                provides_stream: true,
                id_prefixes: vec![],
                types: vec!["movie".to_string()],
            },
        ];

        let client = AddonClient::new();
        let (releases, blocked) =
            aggregate_streams(&client, &addons, "tt1234567", 0, 0, false).await;
        assert_eq!(blocked, vec!["P2P Addon".to_string()]);
        assert_eq!(releases.len(), 2);
        assert_eq!(releases[0].quality.as_deref(), Some("2160p"));
        assert_eq!(releases[1].quality.as_deref(), Some("720p"));
    }

    #[test]
    fn test_clean_addon_subject_id_preserves_namespaces() {
        assert_eq!(clean_addon_subject_id("series:kitsu:12345"), "kitsu:12345");
        assert_eq!(clean_addon_subject_id("movie:kitsu:999"), "kitsu:999");
        assert_eq!(clean_addon_subject_id("series:tt0903747"), "tt0903747");
        assert_eq!(clean_addon_subject_id("movie:tt1234567"), "tt1234567");
        assert_eq!(clean_addon_subject_id("tt1234567"), "tt1234567");
    }
}