Skip to content

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

22.4 KB
Raw Blame
use super::models::{MetaDetail, MetaItem, StreamItem};
use crate::providers::models::{
    CatalogItem, Episode, MediaDetails, MediaType, PlaybackSource, ProviderKind, ProviderMediaId,
    Release, Season, SourceMirror,
};
use std::collections::BTreeMap;

type SeasonEpisodeMap = BTreeMap<usize, BTreeMap<usize, (Option<String>, Option<String>)>>;

pub fn meta_to_catalog_item(item: &MetaItem) -> CatalogItem {
    let is_series = item.r#type.eq_ignore_ascii_case("series")
        || item.r#type.eq_ignore_ascii_case("tv")
        || item.r#type.eq_ignore_ascii_case("anime");
    let year: Option<String> = item
        .release_info
        .as_deref()
        .or(item.year.as_deref())
        .or(item.released.as_deref())
        .map(crate::providers::models::extract_4digit_year)
        .filter(|y| !y.is_empty());

    let title = if !item.name.trim().is_empty() {
        item.name.clone()
    } else {
        item.title.clone().unwrap_or_else(|| "Unknown".to_string())
    };

    let poster_url = item.poster.clone().or_else(|| item.cover.clone());

    let type_prefix = if is_series { "series" } else { "movie" };
    let composite_id = format!("{type_prefix}:{}", item.id);

    CatalogItem {
        id: ProviderMediaId {
            provider: ProviderKind::Addons,
            value: composite_id,
        },
        title,
        media_type: if is_series {
            MediaType::Series
        } else {
            MediaType::Movie
        },
        year,
        poster_url,
        season_count: None,
    }
}

pub fn meta_detail_to_media_details(detail: &MetaDetail) -> MediaDetails {
    let is_series = detail.r#type.eq_ignore_ascii_case("series")
        || detail.r#type.eq_ignore_ascii_case("tv")
        || detail.r#type.eq_ignore_ascii_case("anime")
        || !detail.videos.is_empty();

    let mut season_map: SeasonEpisodeMap = BTreeMap::new();
    for video in &detail.videos {
        let s = video.season.unwrap_or(1);
        let e = video.episode.or(video.number).unwrap_or(1);
        let ep_title = video.title.clone().or_else(|| video.name.clone());
        let ep_overview = video.overview.clone().or_else(|| video.description.clone());
        season_map
            .entry(s)
            .or_default()
            .entry(e)
            .or_insert((ep_title, ep_overview));
    }

    let seasons = season_map
        .into_iter()
        .map(|(season_num, eps)| Season {
            number: season_num,
            episodes: eps
                .into_iter()
                .map(|(ep_num, (ep_title, ep_overview))| Episode {
                    season: season_num,
                    number: ep_num,
                    title: ep_title,
                    overview: ep_overview,
                })
                .collect(),
        })
        .collect::<Vec<_>>();

    let year_raw = detail
        .release_info
        .as_deref()
        .or(detail.year.as_deref())
        .or(detail.released.as_deref())
        .unwrap_or_default();
    let year = crate::providers::models::extract_4digit_year(year_raw);
    let year = if !year.is_empty() {
        Some(year)
    } else if !year_raw.is_empty() {
        Some(year_raw.to_string())
    } else {
        None
    };

    let title = if !detail.name.trim().is_empty() {
        detail.name.clone()
    } else {
        detail
            .title
            .clone()
            .unwrap_or_else(|| "Unknown".to_string())
    };

    let poster_url = detail
        .poster
        .clone()
        .or_else(|| detail.cover.clone())
        .or_else(|| detail.background.clone());

    let description = detail
        .description
        .clone()
        .or_else(|| detail.overview.clone())
        .or_else(|| detail.synopsis.clone());

    let type_prefix = if is_series { "series" } else { "movie" };
    let composite_id = format!("{type_prefix}:{}", detail.id);

    MediaDetails {
        id: ProviderMediaId {
            provider: ProviderKind::Addons,
            value: composite_id,
        },
        title,
        media_type: if is_series {
            MediaType::Series
        } else {
            MediaType::Movie
        },
        year,
        description,
        tagline: None,
        imdb_rating: detail.imdb_rating.clone().or_else(|| detail.rating.clone()),
        director: if !detail.director.is_empty() {
            Some(detail.director.join(", "))
        } else if !detail.directors.is_empty() {
            Some(detail.directors.join(", "))
        } else if !detail.writers.is_empty() {
            Some(detail.writers.join(", "))
        } else if !detail.writer.is_empty() {
            Some(detail.writer.join(", "))
        } else {
            None
        },
        stars: if !detail.cast.is_empty() {
            Some(detail.cast.join(", "))
        } else if !detail.stars.is_empty() {
            Some(detail.stars.join(", "))
        } else {
            None
        },
        prints: None,
        audios: None,
        poster_url,
        duration: detail.runtime.clone(),
        genres: if !detail.genres.is_empty() {
            detail.genres.clone()
        } else {
            detail.genre.clone()
        },
        seasons,
        dubs: vec![],
    }
}

pub fn parse_quality(text: &str) -> Option<String> {
    let upper = text.to_ascii_uppercase();
    if upper.contains("2160P") || upper.contains("4K") || upper.contains("UHD") {
        Some("2160p".to_string())
    } else if upper.contains("1080P")
        || upper.contains("FHD")
        || upper.contains("FULL HD")
        || upper.contains("FULLHD")
    {
        Some("1080p".to_string())
    } else if upper.contains("720P")
        || upper
            .split(|c: char| !c.is_alphanumeric())
            .any(|w| w == "HD")
    {
        Some("720p".to_string())
    } else if upper.contains("480P")
        || upper
            .split(|c: char| !c.is_alphanumeric())
            .any(|w| w == "SD")
    {
        Some("480p".to_string())
    } else {
        None
    }
}

pub fn parse_codec(text: &str) -> Option<String> {
    let upper = text.to_ascii_uppercase();
    if upper.contains("HEVC")
        || upper.contains("X265")
        || upper.contains("H.265")
        || upper.contains("H265")
    {
        Some("HEVC/x265".to_string())
    } else if upper.contains("X264")
        || upper.contains("H.264")
        || upper.contains("H264")
        || upper.contains("AVC")
    {
        Some("AVC/x264".to_string())
    } else if upper.contains("AV1") {
        Some("AV1".to_string())
    } else {
        None
    }
}

pub fn parse_audio_tracks(text: &str) -> Option<String> {
    let upper = text.to_ascii_uppercase();
    let mut langs = Vec::new();
    let candidates = [
        ("HINDI", "Hindi"),
        ("ENGLISH", "English"),
        ("ENG", "English"),
        ("HIN", "Hindi"),
        ("TAMIL", "Tamil"),
        ("TELUGU", "Telugu"),
        ("BENGALI", "Bengali"),
        ("BEN", "Bengali"),
        ("MALAYALAM", "Malayalam"),
        ("KANNADA", "Kannada"),
        ("MARATHI", "Marathi"),
        ("PUNJABI", "Punjabi"),
        ("GUJARATI", "Gujarati"),
        ("URDU", "Urdu"),
        ("SPANISH", "Spanish"),
        ("FRENCH", "French"),
        ("GERMAN", "German"),
        ("ITALIAN", "Italian"),
        ("JAPANESE", "Japanese"),
        ("JAP", "Japanese"),
        ("KOREAN", "Korean"),
        ("KOR", "Korean"),
        ("RUSSIAN", "Russian"),
        ("CHINESE", "Chinese"),
        ("DUAL", "Dual Audio"),
        ("MULTI", "Multi Audio"),
    ];

    for (needle, label) in candidates {
        if upper.contains(needle) && !langs.contains(&label) {
            langs.push(label);
        }
    }

    if langs.is_empty() {
        None
    } else {
        Some(langs.join(" + "))
    }
}

fn extract_domain_label(url: &str) -> Option<String> {
    let url_clean = url.trim();
    let without_proto = url_clean
        .strip_prefix("https://")
        .or_else(|| url_clean.strip_prefix("http://"))
        .unwrap_or(url_clean);

    let host = without_proto.split(['/', ':', '?', '#']).next()?.trim();
    if host.is_empty() || host.parse::<std::net::IpAddr>().is_ok() {
        return None;
    }

    let parts: Vec<&str> = host.split('.').collect();
    if parts.len() < 2 {
        return None;
    }

    let main_part = if parts.len() >= 2 {
        if (parts[parts.len() - 2] == "co" || parts[parts.len() - 2] == "com") && parts.len() >= 3 {
            parts[parts.len() - 3]
        } else {
            parts[parts.len() - 2]
        }
    } else {
        parts[0]
    };

    if main_part.is_empty() || main_part == "www" || main_part == "api" || main_part == "cdn" {
        return None;
    }

    let capitalized = main_part
        .split(['-', '_'])
        .map(|word| {
            let mut c = word.chars();
            match c.next() {
                None => String::new(),
                Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
            }
        })
        .collect::<Vec<_>>()
        .join(" ");

    Some(capitalized)
}

pub fn detect_stream_host(
    addon_name: &str,
    stream_name: &str,
    _title: &str,
    _description: &str,
    url: &str,
) -> String {
    let mut detected_labels = Vec::new();

    for line in stream_name.lines() {
        let trimmed = line.trim().trim_matches(['[', ']', '(', ')', ' ']);
        if !trimmed.is_empty()
            && !trimmed.eq_ignore_ascii_case(addon_name)
            && !detected_labels.contains(&trimmed.to_string())
        {
            detected_labels.push(trimmed.to_string());
        }
    }

    if let Some(domain_label) = extract_domain_label(url) {
        if !domain_label.eq_ignore_ascii_case(addon_name)
            && !detected_labels
                .iter()
                .any(|l| l.eq_ignore_ascii_case(&domain_label))
        {
            detected_labels.push(domain_label);
        }
    }

    if let Some(first_tag) = detected_labels.first() {
        format!("{addon_name} · {first_tag}")
    } else {
        addon_name.to_string()
    }
}

pub fn parse_season_episode(text: &str) -> Option<(usize, usize)> {
    let bytes = text.as_bytes();
    let len = bytes.len();

    let mut i = 0;
    while i < len {
        if (bytes[i] == b'S' || bytes[i] == b's') && i + 1 < len && bytes[i + 1].is_ascii_digit() {
            if i == 0 || !bytes[i - 1].is_ascii_alphanumeric() {
                let s_start = i + 1;
                let mut s_end = s_start;
                while s_end < len && bytes[s_end].is_ascii_digit() {
                    s_end += 1;
                }
                if s_end < len && (s_end - s_start) <= 3 {
                    if let Ok(s_num) = text[s_start..s_end].parse::<usize>() {
                        let mut e_idx = s_end;
                        while e_idx < len
                            && (bytes[e_idx] == b'.'
                                || bytes[e_idx] == b' '
                                || bytes[e_idx] == b'_'
                                || bytes[e_idx] == b'-')
                        {
                            e_idx += 1;
                        }
                        if e_idx < len
                            && (bytes[e_idx] == b'E' || bytes[e_idx] == b'e')
                            && e_idx + 1 < len
                            && bytes[e_idx + 1].is_ascii_digit()
                        {
                            let e_start = e_idx + 1;
                            let mut e_end = e_start;
                            while e_end < len && bytes[e_end].is_ascii_digit() {
                                e_end += 1;
                            }
                            if (e_end - e_start) <= 4 {
                                if let Ok(e_num) = text[e_start..e_end].parse::<usize>() {
                                    return Some((s_num, e_num));
                                }
                            }
                        }
                    }
                }
            }
        }

        if (bytes[i] == b'x' || bytes[i] == b'X')
            && i > 0
            && bytes[i - 1].is_ascii_digit()
            && i + 1 < len
            && bytes[i + 1].is_ascii_digit()
        {
            let mut s_start = i - 1;
            while s_start > 0 && bytes[s_start - 1].is_ascii_digit() {
                s_start -= 1;
            }
            if s_start == 0 || !bytes[s_start - 1].is_ascii_alphanumeric() {
                let s_str = &text[s_start..i];
                let mut e_end = i + 1;
                while e_end < len && bytes[e_end].is_ascii_digit() {
                    e_end += 1;
                }
                let e_str = &text[i + 1..e_end];
                if s_str.len() <= 3 && e_str.len() <= 4 {
                    if let (Ok(s_num), Ok(e_num)) = (s_str.parse::<usize>(), e_str.parse::<usize>())
                    {
                        if s_num > 0 && s_num < 100 && e_num > 0 && e_num < 10000 {
                            return Some((s_num, e_num));
                        }
                    }
                }
            }
        }

        i += 1;
    }

    let upper = text.to_ascii_uppercase();
    if let Some(season_pos) = upper.find("SEASON ") {
        let after_season = &upper[season_pos + 7..];
        let s_digits: String = after_season
            .chars()
            .skip_while(|c| *c == ' ')
            .take_while(|c| c.is_ascii_digit())
            .collect();
        if let Ok(s_num) = s_digits.parse::<usize>() {
            if let Some(ep_pos) = upper.find("EPISODE ") {
                let after_ep = &upper[ep_pos + 8..];
                let e_digits: String = after_ep
                    .chars()
                    .skip_while(|c| *c == ' ')
                    .take_while(|c| c.is_ascii_digit())
                    .collect();
                if let Ok(e_num) = e_digits.parse::<usize>() {
                    return Some((s_num, e_num));
                }
            }
        }
    }

    if let Some(ep_pos) = upper.find("EPISODE ") {
        let after = &upper[ep_pos + 8..];
        let digits: String = after
            .chars()
            .skip_while(|c| *c == ' ')
            .take_while(|c| c.is_ascii_digit())
            .collect();
        if let Ok(e_num) = digits.parse::<usize>() {
            return Some((1, e_num));
        }
    }

    None
}

pub fn stream_item_to_release(
    addon_name: &str,
    stream: &StreamItem,
    season: usize,
    episode: usize,
) -> Option<Release> {
    let url = stream.url.as_ref()?.trim();
    if !crate::net::is_http_url(url) {
        return None;
    }

    let stream_name_str = stream.name.as_deref().unwrap_or_default();
    let title_str = stream.title.as_deref().unwrap_or_default();
    let desc_str = stream.description.as_deref().unwrap_or_default();

    let combined_text = format!("{stream_name_str} {title_str} {desc_str}");

    if season > 0 && episode > 0 {
        if let Some((stream_s, stream_e)) = parse_season_episode(&combined_text) {
            if stream_s != season || stream_e != episode {
                return None;
            }
        }
    }

    let quality = parse_quality(&combined_text);
    let codec = parse_codec(&combined_text);
    let language = parse_audio_tracks(&combined_text);

    let size_bytes = stream
        .behavior_hints
        .as_ref()
        .and_then(|h| h.video_size)
        .or_else(|| crate::providers::models::parse_size_bytes(&combined_text));

    let raw_filename = stream
        .title
        .as_ref()
        .or(stream.description.as_ref())
        .or(stream.name.as_ref())
        .map(|s| s.lines().next().unwrap_or(s).trim().to_string())
        .filter(|s| !s.is_empty())
        .unwrap_or_else(|| format!("{addon_name} Stream"));

    let filename = crate::providers::models::clean_stream_text(&raw_filename);
    let raw_source_label =
        detect_stream_host(addon_name, stream_name_str, title_str, desc_str, url);
    let source_label = crate::providers::models::clean_stream_text(&raw_source_label);
    let language = language.map(|l| crate::providers::models::clean_stream_text(&l));

    let mut headers = Vec::new();
    if let Some(hints) = &stream.behavior_hints
        && let Some(hdr_map) = &hints.headers
    {
        const ALLOWED_HEADERS: &[&str] = &[
            "user-agent",
            "referer",
            "origin",
            "range",
            "x-forwarded-for",
            "accept",
            "accept-language",
        ];
        for (k, v) in hdr_map {
            if ALLOWED_HEADERS.contains(&k.to_ascii_lowercase().as_str()) {
                headers.push((k.clone(), v.clone()));
            }
        }
    }

    Some(Release {
        provider: ProviderKind::Addons,
        filename,
        quality,
        codec,
        language,
        size_bytes,
        season: if season > 0 { Some(season) } else { None },
        episode: if episode > 0 { Some(episode) } else { None },
        mirrors: vec![SourceMirror {
            label: source_label,
            resolver_url: url.to_string(),
            headers,
            direct_file: true,
        }],
        resource_id: None,
    })
}

pub fn release_to_playback_source(release: &Release) -> Option<PlaybackSource> {
    let mirror = release.mirrors.first()?;
    Some(PlaybackSource {
        provider: ProviderKind::Addons,
        url: mirror.resolver_url.clone(),
        headers: mirror.headers.clone(),
        subtitle: None,
        source_label: mirror.label.clone(),
        max_height: None,
    })
}

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

    #[test]
    fn test_meta_to_catalog_item() {
        let item = MetaItem {
            id: "tt1234".to_string(),
            r#type: "movie".to_string(),
            name: "Test Movie".to_string(),
            title: None,
            poster: Some("https://example.com/poster.jpg".to_string()),
            cover: None,
            description: Some("Description".to_string()),
            overview: None,
            synopsis: None,
            release_info: Some("2022".to_string()),
            year: None,
            released: None,
            imdb_rating: Some("7.5".to_string()),
            rating: None,
            genres: vec!["Action".to_string()],
            genre: Vec::new(),
        };

        let catalog = meta_to_catalog_item(&item);
        assert_eq!(catalog.id.value, "movie:tt1234");
        assert_eq!(catalog.title, "Test Movie");
        assert_eq!(catalog.media_type, MediaType::Movie);
        assert_eq!(catalog.year.as_deref(), Some("2022"));
        assert_eq!(
            catalog.poster_url.as_deref(),
            Some("https://example.com/poster.jpg")
        );
    }

    #[test]
    fn test_meta_detail_to_media_details() {
        let detail = MetaDetail {
            id: "tt5678".to_string(),
            r#type: "series".to_string(),
            name: "Test Series".to_string(),
            title: None,
            poster: Some("https://example.com/series.jpg".to_string()),
            cover: None,
            background: None,
            logo: None,
            description: Some("Series description".to_string()),
            overview: None,
            synopsis: None,
            release_info: Some("2021".to_string()),
            year: None,
            released: None,
            imdb_rating: Some("8.2".to_string()),
            rating: None,
            genres: vec!["Drama".to_string()],
            genre: Vec::new(),
            runtime: Some("45m".to_string()),
            cast: vec!["Actor One".to_string(), "Actor Two".to_string()],
            stars: Vec::new(),
            director: vec!["Director Name".to_string()],
            directors: Vec::new(),
            writer: Vec::new(),
            writers: Vec::new(),
            videos: vec![
                super::super::models::MetaVideo {
                    id: Some("ep1".to_string()),
                    title: Some("Pilot".to_string()),
                    name: None,
                    season: Some(1),
                    episode: Some(1),
                    number: None,
                    released: None,
                    thumbnail: None,
                    overview: Some("Pilot episode overview".to_string()),
                    description: None,
                },
                super::super::models::MetaVideo {
                    id: Some("ep2".to_string()),
                    title: Some("Episode 2".to_string()),
                    name: None,
                    season: Some(1),
                    episode: Some(2),
                    number: None,
                    released: None,
                    thumbnail: None,
                    overview: None,
                    description: None,
                },
            ],
        };

        let media = meta_detail_to_media_details(&detail);
        assert_eq!(media.id.value, "series:tt5678");
        assert_eq!(media.title, "Test Series");
        assert_eq!(media.media_type, MediaType::Series);
        assert_eq!(media.year.as_deref(), Some("2021"));
        assert_eq!(media.director.as_deref(), Some("Director Name"));
        assert_eq!(media.stars.as_deref(), Some("Actor One, Actor Two"));
        assert_eq!(media.seasons.len(), 1);
        assert_eq!(media.seasons[0].number, 1);
        assert_eq!(media.seasons[0].episodes.len(), 2);
        assert_eq!(
            media.seasons[0].episodes[0].overview.as_deref(),
            Some("Pilot episode overview")
        );
        assert_eq!(media.seasons[0].episodes[0].title.as_deref(), Some("Pilot"));
    }

    #[test]
    fn test_meta_detail_movie_composite_id() {
        let detail = MetaDetail {
            id: "tt9999".to_string(),
            r#type: "movie".to_string(),
            name: "Test Movie".to_string(),
            title: None,
            poster: Some("https://example.com/movie.jpg".to_string()),
            cover: None,
            background: None,
            logo: None,
            description: Some("Movie description".to_string()),
            overview: None,
            synopsis: None,
            release_info: Some("2020".to_string()),
            year: None,
            released: None,
            imdb_rating: Some("7.9".to_string()),
            rating: None,
            genres: vec!["Sci-Fi".to_string()],
            genre: Vec::new(),
            runtime: Some("120m".to_string()),
            cast: Vec::new(),
            stars: Vec::new(),
            director: Vec::new(),
            directors: Vec::new(),
            writer: Vec::new(),
            writers: Vec::new(),
            videos: Vec::new(),
        };

        let media = meta_detail_to_media_details(&detail);
        assert_eq!(media.id.value, "movie:tt9999");
        assert_eq!(media.title, "Test Movie");
        assert_eq!(media.media_type, MediaType::Movie);
        assert!(media.seasons.is_empty());
    }
}