Skip to content

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

21.0 KB
Raw Blame
use super::client::FourKHdHubError;
use crate::providers::models::{
    CatalogItem, Episode, MediaDetails, MediaType, ProviderKind, ProviderMediaId, Release, Season,
    SourceMirror,
};
use reqwest::Url;
use scraper::{ElementRef, Html, Selector};
use std::collections::{BTreeMap, HashMap};
use std::sync::LazyLock;

static SEL_CARD: LazyLock<Selector> = LazyLock::new(|| Selector::parse("a.movie-card").unwrap());
static SEL_TITLE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".movie-card-title").unwrap());
static SEL_META: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".movie-card-meta").unwrap());
static SEL_IMG: LazyLock<Selector> = LazyLock::new(|| Selector::parse("img").unwrap());
static SEL_H1: LazyLock<Selector> = LazyLock::new(|| Selector::parse("h1").unwrap());
static SEL_CONTENT_DESC: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".content-section p.mt-4").unwrap());
static SEL_TAGLINE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".movie-tagline").unwrap());
static SEL_IMDB: LazyLock<Selector> = LazyLock::new(|| Selector::parse(".imdb-score").unwrap());
static SEL_BADGE_A: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".badge-outline a").unwrap());
static SEL_METADATA_ITEM: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".metadata-item").unwrap());
static SEL_METADATA_LABEL: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".metadata-label").unwrap());
static SEL_METADATA_VALUE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".metadata-value").unwrap());
static SEL_EPISODE_ITEM: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse("#episodes .episode-download-item").unwrap());
static SEL_DOWNLOAD_ITEM: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".download-item").unwrap());
static SEL_EPISODE_FILE_TITLE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".episode-file-title").unwrap());
static SEL_FILE_TITLE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".file-title").unwrap());
static SEL_LINK_HREF: LazyLock<Selector> = LazyLock::new(|| Selector::parse("a[href]").unwrap());
static SEL_BADGE_SIZE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse(".badge-size, .badge").unwrap());
static SEL_OG_IMAGE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse("meta[property=\"og:image\"]").unwrap());
static SEL_OG_TITLE: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse("meta[property=\"og:title\"]").unwrap());
static SEL_META_DESC: LazyLock<Selector> =
    LazyLock::new(|| Selector::parse("meta[name=\"description\"]").unwrap());

pub fn parse_search(base: &Url, html: &str) -> Result<Vec<CatalogItem>, FourKHdHubError> {
    let document = Html::parse_document(html);
    let mut items = Vec::new();

    for node in document.select(&SEL_CARD) {
        let Some(href) = node.value().attr("href") else {
            continue;
        };
        let Ok(url) = base.join(href) else { continue };
        if url.host_str() != base.host_str() {
            continue;
        }
        let item_title = text_of(node.select(&SEL_TITLE).next()).unwrap_or_default();
        if item_title.is_empty() {
            continue;
        }
        let meta_text = text_of(node.select(&SEL_META).next()).unwrap_or_default();
        let year = first_four_digit_year(&meta_text);
        let media_type = if href.contains("-series-") {
            MediaType::Series
        } else {
            MediaType::Movie
        };
        let poster_url = node
            .select(&SEL_IMG)
            .next()
            .and_then(|img| img.value().attr("src"))
            .map(str::to_string);
        items.push(CatalogItem {
            id: ProviderMediaId {
                provider: ProviderKind::FourKHdHub,
                value: url.path().to_string(),
            },
            title: item_title,
            media_type,
            year,
            poster_url,
            season_count: parse_season_count(&meta_text),
        });
    }
    Ok(items)
}

pub fn parse_details(id: &str, html: &str) -> Result<MediaDetails, FourKHdHubError> {
    let document = Html::parse_document(html);
    let raw_title = document
        .select(&SEL_H1)
        .find_map(|node| text_of(Some(node)))
        .filter(|text| !text.is_empty())
        .or_else(|| meta_content(&document, &SEL_OG_TITLE))
        .ok_or_else(|| FourKHdHubError::Parse("title missing".into()))?;
    let title = strip_trailing_year(&raw_title);
    let media_type = if id.contains("-series-") {
        MediaType::Series
    } else {
        MediaType::Movie
    };
    let description = document
        .select(&SEL_CONTENT_DESC)
        .find_map(|node| text_of(Some(node)))
        .or_else(|| meta_content(&document, &SEL_META_DESC));
    let tagline = document
        .select(&SEL_TAGLINE)
        .find_map(|node| text_of(Some(node)));
    let imdb_rating = document
        .select(&SEL_IMDB)
        .find_map(|node| text_of(Some(node)));
    let poster_url = meta_content(&document, &SEL_OG_IMAGE);
    let year = find_metadata(&document, "Release:")
        .and_then(|value| first_four_digit_year(&value))
        .or_else(|| {
            find_metadata(&document, "Last Air:").and_then(|value| first_four_digit_year(&value))
        })
        .or_else(|| first_four_digit_year(&raw_title));
    let genres = document
        .select(&SEL_BADGE_A)
        .filter_map(|node| text_of(Some(node)))
        .filter(|value| is_genre(value))
        .collect();
    let seasons = parse_seasons(&document)?;

    Ok(MediaDetails {
        id: ProviderMediaId {
            provider: ProviderKind::FourKHdHub,
            value: id.to_string(),
        },
        title,
        media_type,
        year,
        description,
        tagline,
        imdb_rating,
        director: find_metadata(&document, "Director:"),
        stars: find_metadata(&document, "Stars:"),
        prints: find_metadata(&document, "Prints:").or_else(|| find_metadata(&document, "Print:")),
        audios: find_metadata(&document, "Audios:"),
        poster_url,
        duration: None,
        genres,
        seasons,
        dubs: vec![],
    })
}

pub fn parse_releases(
    html: &str,
    season: usize,
    episode: usize,
) -> Result<Vec<Release>, FourKHdHubError> {
    let document = Html::parse_document(html);
    let item_selector = if season > 0 {
        &*SEL_EPISODE_ITEM
    } else {
        &*SEL_DOWNLOAD_ITEM
    };
    let filename_selector = if season > 0 {
        &*SEL_EPISODE_FILE_TITLE
    } else {
        &*SEL_FILE_TITLE
    };
    let link_selector = &*SEL_LINK_HREF;
    let size_selector = &*SEL_BADGE_SIZE;
    let page_language =
        find_metadata(&document, "Audios:").and_then(|value| normalize_language_label(&value));
    let mut grouped: HashMap<String, Release> = HashMap::new();

    for item in document.select(item_selector) {
        let filename = text_of(item.select(filename_selector).next()).unwrap_or_default();
        if filename.is_empty() || is_archive(&filename) {
            continue;
        }
        let parsed_episode = parse_season_episode(&filename);
        if season > 0 && parsed_episode != Some((season, episode)) {
            continue;
        }
        let mirrors = item
            .select(link_selector)
            .filter_map(|link| {
                let href = link.value().attr("href")?;
                if !href.starts_with("https://") || href.contains("logout") {
                    return None;
                }
                let label = text_of(Some(link)).unwrap_or_else(|| "Source".into());
                Some(SourceMirror {
                    label,
                    resolver_url: href.to_string(),
                    headers: Vec::new(),
                    direct_file: !href.contains("hubcloud.")
                        && !href.contains("hubdrive.")
                        && !href.contains("greenmotors.")
                        && !href.contains("greenmountmotors."),
                })
            })
            .collect::<Vec<_>>();
        if mirrors.is_empty() {
            continue;
        }
        let size_text = item
            .select(size_selector)
            .filter_map(|node| text_of(Some(node)))
            .find(|text| crate::providers::models::parse_size_bytes(text).is_some());
        let key = normalize_filename(&filename);
        let release = grouped.entry(key).or_insert_with(|| Release {
            provider: ProviderKind::FourKHdHub,
            quality: detect_quality(&filename),
            codec: detect_codec(&filename),
            language: detect_language(&filename).or_else(|| page_language.clone()),
            size_bytes: size_text
                .as_deref()
                .and_then(crate::providers::models::parse_size_bytes),
            season: parsed_episode.map(|value| value.0),
            episode: parsed_episode.map(|value| value.1),
            filename: filename.clone(),
            mirrors: Vec::new(),
            resource_id: None,
        });
        for mirror in mirrors {
            if !release
                .mirrors
                .iter()
                .any(|existing| existing.resolver_url == mirror.resolver_url)
            {
                release.mirrors.push(mirror);
            }
        }
    }
    let mut releases = grouped.into_values().collect::<Vec<_>>();
    releases.sort_by(|left, right| {
        right
            .resolution_u64()
            .cmp(&left.resolution_u64())
            .then_with(|| right.size_bytes.cmp(&left.size_bytes))
    });
    Ok(releases)
}

fn parse_seasons(document: &Html) -> Result<Vec<Season>, FourKHdHubError> {
    let item = &*SEL_EPISODE_ITEM;
    let title = &*SEL_EPISODE_FILE_TITLE;
    let mut seasons: BTreeMap<usize, BTreeMap<usize, Episode>> = BTreeMap::new();
    for node in document.select(item) {
        let filename = text_of(node.select(title).next()).unwrap_or_default();
        let Some((season, episode)) = parse_season_episode(&filename) else {
            continue;
        };
        seasons
            .entry(season)
            .or_default()
            .entry(episode)
            .or_insert(Episode {
                season,
                number: episode,
                title: None,
                overview: None,
            });
    }
    Ok(seasons
        .into_iter()
        .map(|(number, episodes)| Season {
            number,
            episodes: episodes.into_values().collect(),
        })
        .collect())
}

fn text_of(node: Option<ElementRef<'_>>) -> Option<String> {
    node.map(|node| node.text().collect::<Vec<_>>().join(" "))
        .map(|text| text.split_whitespace().collect::<Vec<_>>().join(" "))
        .filter(|text| !text.is_empty())
}

fn meta_content(document: &Html, selector: &Selector) -> Option<String> {
    document
        .select(selector)
        .next()
        .and_then(|node| node.value().attr("content"))
        .map(str::to_string)
}

fn find_metadata(document: &Html, label: &str) -> Option<String> {
    document.select(&SEL_METADATA_ITEM).find_map(|node| {
        let current = text_of(node.select(&SEL_METADATA_LABEL).next())?;
        (current == label).then(|| text_of(node.select(&SEL_METADATA_VALUE).next()))?
    })
}

fn first_four_digit_year(value: &str) -> Option<String> {
    let year = crate::providers::models::extract_4digit_year(value);
    (!year.is_empty()).then_some(year)
}

fn is_genre(value: &str) -> bool {
    matches!(
        value.to_ascii_lowercase().as_str(),
        "action"
            | "adventure"
            | "animation"
            | "comedy"
            | "crime"
            | "documentary"
            | "drama"
            | "family"
            | "fantasy"
            | "history"
            | "horror"
            | "music"
            | "mystery"
            | "romance"
            | "science fiction"
            | "sci-fi"
            | "thriller"
            | "war"
            | "western"
    )
}

fn strip_trailing_year(value: &str) -> String {
    let trimmed = value.trim();
    let bytes = trimmed.as_bytes();
    let start = match bytes.len().checked_sub(6) {
        Some(index) if trimmed.is_char_boundary(index) => index,
        _ => return trimmed.to_string(),
    };
    let is_parenthesized_year = bytes[start] == b'('
        && bytes[bytes.len() - 1] == b')'
        && bytes[start + 1..bytes.len() - 1]
            .iter()
            .all(|byte| byte.is_ascii_digit());
    if is_parenthesized_year {
        trimmed[..start].trim_end().to_string()
    } else {
        trimmed.to_string()
    }
}

fn parse_season_count(value: &str) -> Option<usize> {
    let marker = value.find('S')?;
    let suffix = &value[marker..];
    suffix
        .split(['-', ' ', '•'])
        .filter_map(|part| part.strip_prefix('S')?.parse::<usize>().ok())
        .max()
}

fn parse_season_episode(value: &str) -> Option<(usize, usize)> {
    let upper = value.to_ascii_uppercase();
    let bytes = upper.as_bytes();
    for index in 0..bytes.len().saturating_sub(4) {
        if bytes[index] != b'S' {
            continue;
        }
        let Some(season_end) = bytes[index + 1..]
            .iter()
            .position(|byte| !byte.is_ascii_digit())
            .map(|offset| index + 1 + offset)
        else {
            continue;
        };
        if season_end == index + 1 || bytes.get(season_end) != Some(&b'E') {
            continue;
        }
        let episode_end = bytes[season_end + 1..]
            .iter()
            .position(|byte| !byte.is_ascii_digit())
            .map(|offset| season_end + 1 + offset)
            .unwrap_or(bytes.len());
        if episode_end == season_end + 1 {
            continue;
        }
        if let (Ok(season), Ok(episode)) = (
            upper[index + 1..season_end].parse(),
            upper[season_end + 1..episode_end].parse(),
        ) {
            return Some((season, episode));
        }
    }
    None
}

fn detect_quality(value: &str) -> Option<String> {
    let lower = value.to_ascii_lowercase();
    if lower.contains("2160p")
        || lower.contains("2160")
        || lower.contains("4k")
        || lower.contains("uhd")
    {
        Some("2160p".to_string())
    } else if lower.contains("1080p") || lower.contains("1080") || lower.contains("fhd") {
        Some("1080p".to_string())
    } else if lower.contains("720p") || lower.contains("720") || lower.contains("hd") {
        Some("720p".to_string())
    } else if lower.contains("480p") || lower.contains("480") || lower.contains("sd") {
        Some("480p".to_string())
    } else {
        None
    }
}

fn detect_codec(value: &str) -> Option<String> {
    let lower = value.to_ascii_lowercase();
    if lower.contains("av1") {
        Some("AV1".into())
    } else if lower.contains("h.265") || lower.contains("h265") || lower.contains("x265") {
        Some("H.265".into())
    } else if lower.contains("hevc") {
        Some("HEVC".into())
    } else if lower.contains("h.264") || lower.contains("h264") || lower.contains("x264") {
        Some("H.264".into())
    } else if lower.contains("remux") {
        Some("REMUX".into())
    } else {
        None
    }
}

fn detect_language(value: &str) -> Option<String> {
    let lower = value.to_ascii_lowercase();

    let lang_patterns: &[(&[&str], &str)] = &[
        (&["hindi", "hin"], "Hindi"),
        (&["english", "eng"], "English"),
        (&["tamil", "tam"], "Tamil"),
        (&["telugu", "tel"], "Telugu"),
        (&["kannada", "kan"], "Kannada"),
        (&["malayalam", "mal"], "Malayalam"),
        (&["bengali", "ben", "bangla"], "Bengali"),
        (&["marathi", "mar"], "Marathi"),
        (&["punjabi", "pan", "pun"], "Punjabi"),
        (&["gujarati", "guj"], "Gujarati"),
        (&["urdu", "urd"], "Urdu"),
        (&["japanese", "jap", "jpn"], "Japanese"),
        (&["korean", "kor"], "Korean"),
        (&["chinese", "chi", "mandarin", "cantonese"], "Chinese"),
        (&["spanish", "spa", "esp", "castilian"], "Spanish"),
        (&["french", "fre", "fra"], "French"),
        (&["german", "ger", "deu"], "German"),
        (&["italian", "ita"], "Italian"),
        (&["portuguese", "por"], "Portuguese"),
        (&["russian", "rus"], "Russian"),
        (&["arabic", "ara"], "Arabic"),
        (&["turkish", "tur"], "Turkish"),
        (&["thai"], "Thai"),
        (&["indonesian", "ind"], "Indonesian"),
        (&["vietnamese", "vie"], "Vietnamese"),
        (&["polish", "pol"], "Polish"),
        (&["dutch", "dut", "nld"], "Dutch"),
        (&["swedish", "swe"], "Swedish"),
        (&["danish", "dan"], "Danish"),
        (&["norwegian", "nor"], "Norwegian"),
        (&["finnish", "fin"], "Finnish"),
    ];

    let mut found_langs: Vec<(usize, &str)> = Vec::new();

    for (patterns, lang_name) in lang_patterns {
        for pattern in *patterns {
            let mut search_idx = 0;
            while let Some(pos) = lower[search_idx..].find(pattern) {
                let actual_pos = search_idx + pos;
                let end_pos = actual_pos + pattern.len();

                let prev_ok = actual_pos == 0
                    || lower
                        .get(..actual_pos)
                        .and_then(|s| s.chars().last())
                        .is_none_or(|c| !c.is_alphabetic());
                let next_ok = end_pos >= lower.len()
                    || lower
                        .get(end_pos..)
                        .and_then(|s| s.chars().next())
                        .is_none_or(|c| !c.is_alphabetic());

                if prev_ok && next_ok {
                    if !found_langs.iter().any(|(_, name)| *name == *lang_name) {
                        found_langs.push((actual_pos, lang_name));
                    }
                    break;
                }
                search_idx = actual_pos + 1;
            }
        }
    }

    if !found_langs.is_empty() {
        found_langs.sort_by_key(|(pos, _)| *pos);
        let joined = found_langs
            .into_iter()
            .map(|(_, name)| name)
            .collect::<Vec<_>>()
            .join(", ");
        return Some(joined);
    }

    if lower.contains("multi audio") || lower.contains("multi-audio") {
        Some("Multi Audio".into())
    } else if lower.contains("dual audio") || lower.contains("dual-audio") {
        Some("Dual Audio".into())
    } else {
        None
    }
}

fn normalize_language_label(value: &str) -> Option<String> {
    if let Some(detected) = detect_language(value) {
        return Some(detected);
    }
    let value = value
        .split(['|', '/', '+', ','])
        .map(str::trim)
        .filter(|part| !part.is_empty())
        .collect::<Vec<_>>()
        .join(", ");
    if value.is_empty()
        || value.len() > 80
        || matches!(
            value.to_ascii_lowercase().as_str(),
            "n/a" | "na" | "unknown"
        )
    {
        None
    } else {
        Some(value)
    }
}

fn is_archive(value: &str) -> bool {
    let lower = value.to_ascii_lowercase();
    lower.ends_with(".zip") || lower.contains("complete season") || lower.contains("season pack")
}

fn normalize_filename(value: &str) -> String {
    value
        .to_ascii_lowercase()
        .chars()
        .filter(|character| character.is_ascii_alphanumeric())
        .collect()
}

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

    #[test]
    fn strips_parenthesized_year() {
        assert_eq!(strip_trailing_year("Movie Name (2024)"), "Movie Name");
        assert_eq!(strip_trailing_year("  X (1999)  "), "X");
    }

    #[test]
    fn keeps_non_year_suffixes() {
        assert_eq!(
            strip_trailing_year("Not A Year (20x4)"),
            "Not A Year (20x4)"
        );
        assert_eq!(strip_trailing_year("Season (Part 2)"), "Season (Part 2)");
        assert_eq!(strip_trailing_year("Short"), "Short");
    }

    #[test]
    fn never_panics_on_multibyte_titles() {
        assert_eq!(strip_trailing_year("英雄éé"), "英雄éé");
        assert_eq!(strip_trailing_year("英雄éé(2020)"), "英雄éé");
        assert_eq!(strip_trailing_year("Ünïcödé 🎬"), "Ünïcödé 🎬");
        assert_eq!(
            strip_trailing_year("アニメ タイトル (2023)"),
            "アニメ タイトル"
        );
    }

    #[test]
    fn handles_short_and_empty_input() {
        assert_eq!(strip_trailing_year(""), "");
        assert_eq!(strip_trailing_year("(2024)"), "");
        assert_eq!(strip_trailing_year("12345"), "12345");
        assert_eq!(strip_trailing_year("123456"), "123456");
    }
    #[test]
    fn test_detect_quality_tokens() {
        use super::detect_quality;
        assert_eq!(
            detect_quality("Inception (2010) 4K UHD BluRay REMUX").as_deref(),
            Some("2160p")
        );
        assert_eq!(
            detect_quality("Movie.2160p.HDR.x265").as_deref(),
            Some("2160p")
        );
        assert_eq!(
            detect_quality("Show.S01E01.FHD.1080p.mkv").as_deref(),
            Some("1080p")
        );
        assert_eq!(
            detect_quality("Video.1080.WEB-DL").as_deref(),
            Some("1080p")
        );
        assert_eq!(detect_quality("Film.720p.HD.x264").as_deref(), Some("720p"));
        assert_eq!(detect_quality("Old.Show.480p.SD").as_deref(), Some("480p"));
        assert_eq!(detect_quality("Unknown.Release.Title"), None);
    }
}