From e6803195411efe2a1bc01672234bf6df7ef40ea0 Mon Sep 17 00:00:00 2001
From: Simon <simon.huenecke@gmail.com>
Date: Fri, 3 Apr 2026 18:01:03 +0000
Subject: [PATCH] pornhub

---
 src/providers/mod.rs     |  100 +++-
 src/providers/pornhub.rs | 1032 ++++++++++++++++++++++++++++++--------
 2 files changed, 925 insertions(+), 207 deletions(-)

diff --git a/src/providers/mod.rs b/src/providers/mod.rs
index 2c99d47..8cef800 100644
--- a/src/providers/mod.rs
+++ b/src/providers/mod.rs
@@ -11,7 +11,9 @@ use std::time::{Duration, Instant};
 use crate::{
     DbPool,
     api::ClientVersion,
-    status::{Channel, ChannelGroup, ChannelView, FilterOption, Status, StatusResponse},
+    status::{
+        Channel, ChannelGroup, ChannelOption, ChannelView, FilterOption, Status, StatusResponse,
+    },
     uploaders::UploaderProfile,
     util::{cache::VideoCache, discord::send_discord_error_report, requester::Requester},
     videos::{FlexibleNumber, ServerOptions, VideoItem, VideosRequest},
@@ -756,6 +758,25 @@ fn channel_group_order(group_id: &str) -> usize {
     }
 }
 
+fn should_hide_status_option(option: &ChannelOption) -> bool {
+    let id = option.id.trim().to_ascii_lowercase();
+    let title = option.title.trim().to_ascii_lowercase();
+
+    matches!(id.as_str(), "stars" | "networks" | "categories")
+        || title.contains("models")
+        || title.contains("pornstars")
+        || title.contains("genres")
+        || title.contains("networks")
+        || (id == "filter" && title.contains("tags"))
+}
+
+fn sanitize_status_options(options: Vec<ChannelOption>) -> Vec<ChannelOption> {
+    options
+        .into_iter()
+        .filter(|option| !should_hide_status_option(option))
+        .collect()
+}
+
 pub fn decorate_channel(channel: Channel) -> ChannelView {
     let metadata = channel_metadata_for(&channel.id);
     let runtime_status = current_provider_channel_status(&channel.id);
@@ -770,8 +791,8 @@ pub fn decorate_channel(channel: Channel) -> ChannelView {
         premium: channel.premium,
         favicon: channel.favicon,
         status: runtime_status.unwrap_or(channel.status),
-        categories: channel.categories,
-        options: channel.options,
+        categories: vec![],
+        options: sanitize_status_options(channel.options),
         nsfw: channel.nsfw,
         groupKey: metadata.map(|value| value.group_id.to_string()),
         sortOrder: None,
@@ -987,6 +1008,79 @@ mod tests {
         }
     }
 
+    #[test]
+    fn decorate_channel_strips_heavy_status_filters() {
+        let mut channel = base_channel("status-clean");
+        channel.categories = vec!["Drama".to_string(), "Action".to_string()];
+        channel.options = vec![
+            ChannelOption {
+                id: "sort".to_string(),
+                title: "Sort".to_string(),
+                description: String::new(),
+                systemImage: "arrow.up.arrow.down".to_string(),
+                colorName: "blue".to_string(),
+                options: vec![FilterOption {
+                    id: "new".to_string(),
+                    title: "Newest".to_string(),
+                }],
+                multiSelect: false,
+            },
+            ChannelOption {
+                id: "categories".to_string(),
+                title: "Genres".to_string(),
+                description: String::new(),
+                systemImage: "square.grid.2x2".to_string(),
+                colorName: "orange".to_string(),
+                options: vec![FilterOption {
+                    id: "drama".to_string(),
+                    title: "Drama".to_string(),
+                }],
+                multiSelect: true,
+            },
+            ChannelOption {
+                id: "filter".to_string(),
+                title: "Tags".to_string(),
+                description: String::new(),
+                systemImage: "tag".to_string(),
+                colorName: "green".to_string(),
+                options: vec![FilterOption {
+                    id: "tag".to_string(),
+                    title: "Tag".to_string(),
+                }],
+                multiSelect: true,
+            },
+            ChannelOption {
+                id: "stars".to_string(),
+                title: "Models".to_string(),
+                description: String::new(),
+                systemImage: "person.2".to_string(),
+                colorName: "pink".to_string(),
+                options: vec![FilterOption {
+                    id: "model".to_string(),
+                    title: "Model".to_string(),
+                }],
+                multiSelect: true,
+            },
+            ChannelOption {
+                id: "networks".to_string(),
+                title: "Networks".to_string(),
+                description: String::new(),
+                systemImage: "network".to_string(),
+                colorName: "purple".to_string(),
+                options: vec![FilterOption {
+                    id: "network".to_string(),
+                    title: "Network".to_string(),
+                }],
+                multiSelect: true,
+            },
+        ];
+
+        let decorated = decorate_channel(channel);
+        assert!(decorated.categories.is_empty());
+        assert_eq!(decorated.options.len(), 1);
+        assert_eq!(decorated.options[0].id, "sort");
+    }
+
     fn test_db_pool() -> DbPool {
         let unique = SystemTime::now()
             .duration_since(UNIX_EPOCH)
diff --git a/src/providers/pornhub.rs b/src/providers/pornhub.rs
index d433ebc..c883f6e 100644
--- a/src/providers/pornhub.rs
+++ b/src/providers/pornhub.rs
@@ -1,16 +1,24 @@
 use crate::DbPool;
 use crate::api::ClientVersion;
-use crate::providers::Provider;
+use crate::providers::{
+    Provider, report_provider_error, report_provider_error_background, requester_or_default,
+};
 use crate::status::*;
 use crate::util::cache::VideoCache;
 use crate::util::parse_abbreviated_number;
 use crate::util::time::parse_time_to_seconds;
-use crate::videos::{ServerOptions, VideoItem};
+use crate::videos::{ServerOptions, VideoFormat, VideoItem};
 
 use async_trait::async_trait;
+use chrono::{DateTime, NaiveDate, Utc};
 use error_chain::error_chain;
+use futures::stream::{self, StreamExt};
 use htmlentity::entity::{ICodedDataTrait, decode};
-use std::vec;
+use regex::Regex;
+use scraper::{ElementRef, Html, Selector};
+use serde_json::Value;
+use std::collections::HashSet;
+use url::Url;
 
 pub const CHANNEL_METADATA: crate::providers::ProviderChannelMetadata =
     crate::providers::ProviderChannelMetadata {
@@ -18,10 +26,16 @@ pub const CHANNEL_METADATA: crate::providers::ProviderChannelMetadata =
         tags: &["mainstream", "studio", "general"],
     };
 
+const BASE_URL: &str = "https://www.pornhub.com";
+const CHANNEL_ID: &str = "pornhub";
+const DETAIL_ENRICH_LIMIT: usize = 12;
+
 error_chain! {
     foreign_links {
         Io(std::io::Error);
         HttpRequest(wreq::Error);
+        Json(serde_json::Error);
+        Url(url::ParseError);
     }
     errors {
         Parse(msg: String) {
@@ -36,18 +50,51 @@ pub struct PornhubProvider {
     url: String,
 }
 
+#[derive(Debug, Clone, Copy)]
+enum ListingScope {
+    Browse,
+    Search,
+    Creator,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum QueryTargetKind {
+    Channel,
+    Pornstar,
+    Model,
+    User,
+}
+
+#[derive(Debug, Clone)]
+struct QueryTarget {
+    kind: QueryTargetKind,
+    slug: String,
+}
+
+impl QueryTargetKind {
+    fn path_segment(self) -> &'static str {
+        match self {
+            Self::Channel => "channels",
+            Self::Pornstar => "pornstar",
+            Self::Model => "model",
+            Self::User => "users",
+        }
+    }
+}
+
 impl PornhubProvider {
     pub fn new() -> Self {
         Self {
-            url: "https://www.pornhub.com".to_string(),
+            url: BASE_URL.to_string(),
         }
     }
 
     fn build_channel(&self, _clientversion: ClientVersion) -> Channel {
         Channel {
-            id: "pornhub".to_string(),
+            id: CHANNEL_ID.to_string(),
             name: "Pornhub".to_string(),
-            description: "Pornhub Free Videos".to_string(),
+            description: "Pornhub listings with creator queries and direct HLS playback links."
+                .to_string(),
             premium: false,
             favicon: "https://www.google.com/s2/favicons?sz=64&domain=pornhub.com".to_string(),
             status: "active".to_string(),
@@ -55,13 +102,13 @@ impl PornhubProvider {
             options: vec![ChannelOption {
                 id: "sort".to_string(),
                 title: "Sort".to_string(),
-                description: "Sort the Videos".to_string(),
+                description: "Browse Pornhub charts by sort order.".to_string(),
                 systemImage: "list.number".to_string(),
                 colorName: "blue".to_string(),
                 options: vec![
                     FilterOption {
                         id: "mr".to_string(),
-                        title: "Most Recent".to_string(),
+                        title: "Featured Recently".to_string(),
                     },
                     FilterOption {
                         id: "mv".to_string(),
@@ -71,6 +118,10 @@ impl PornhubProvider {
                         id: "tr".to_string(),
                         title: "Top Rated".to_string(),
                     },
+                    FilterOption {
+                        id: "ht".to_string(),
+                        title: "Hottest".to_string(),
+                    },
                     FilterOption {
                         id: "lg".to_string(),
                         title: "Longest".to_string(),
@@ -87,225 +138,679 @@ impl PornhubProvider {
         }
     }
 
-    async fn get(
-        &self,
-        cache: VideoCache,
-        page: u8,
-        sort: &str,
-        options: ServerOptions,
-    ) -> Result<Vec<VideoItem>> {
-        let video_url = format!("{}/video?o={}&page={}", self.url, sort, page);
+    fn selector(value: &str) -> Result<Selector> {
+        Selector::parse(value)
+            .map_err(|error| ErrorKind::Parse(format!("selector parse failed for {value}: {error}")).into())
+    }
 
-        let old_items = match cache.get(&video_url) {
-            Some((time, items)) if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 => {
-                return Ok(items.clone());
-            }
-            Some((_, items)) => items.clone(),
-            None => vec![],
-        };
+    fn regex(value: &str) -> Result<Regex> {
+        Regex::new(value)
+            .map_err(|error| ErrorKind::Parse(format!("regex parse failed for {value}: {error}")).into())
+    }
 
-        let mut requester = match options.requester.clone() {
-            Some(r) => r,
-            None => return Ok(old_items),
-        };
+    fn text_of(element: &ElementRef<'_>) -> String {
+        element
+            .text()
+            .collect::<Vec<_>>()
+            .join(" ")
+            .split_whitespace()
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
 
-        let text = match requester.get(&video_url, None).await {
-            Ok(t) => t,
-            Err(_) => return Ok(old_items),
-        };
+    fn decode_html(value: &str) -> String {
+        decode(value.as_bytes())
+            .to_string()
+            .unwrap_or_else(|_| value.to_string())
+    }
 
-        let video_items = self.get_video_items_from_html(text, "<ul id=\"video");
+    fn normalize_url(&self, value: &str) -> String {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            return String::new();
+        }
+        if let Ok(url) = Url::parse(trimmed) {
+            return url.to_string();
+        }
+        Url::parse(BASE_URL)
+            .and_then(|base| base.join(trimmed))
+            .map(|value| value.to_string())
+            .unwrap_or_default()
+    }
 
-        if video_items.is_empty() {
-            Ok(old_items)
-        } else {
-            cache.remove(&video_url);
-            cache.insert(video_url.clone(), video_items.clone());
-            Ok(video_items)
+    fn normalize_sort(sort: &str) -> &'static str {
+        match sort.trim().to_ascii_lowercase().as_str() {
+            "mv" => "mv",
+            "tr" => "tr",
+            "ht" => "ht",
+            "lg" => "lg",
+            "cm" => "cm",
+            "mr" | "new" => "mr",
+            value if value.contains("date") => "mr",
+            _ => "mr",
         }
     }
 
-    async fn query(
-        &self,
-        cache: VideoCache,
-        page: u8,
-        query: &str,
-        sort: &str,
-        options: ServerOptions,
-    ) -> Result<Vec<VideoItem>> {
-        let mut split_string = "<ul id=\"video";
-        let search_string = query.to_lowercase().trim().replace(' ', "+");
+    fn parse_query_target(query: &str) -> Option<QueryTarget> {
+        let trimmed = query.trim();
+        let trimmed = trimmed.strip_prefix('@')?;
+        let (kind, raw_slug) = trimmed.split_once(':')?;
+        let slug = raw_slug
+            .trim()
+            .trim_matches('/')
+            .replace(' ', "-")
+            .to_ascii_lowercase();
+        if slug.is_empty() {
+            return None;
+        }
 
-        let mut video_url = format!(
-            "{}/video/search?search={}&page={}",
-            self.url, search_string, page
+        let kind = match kind.trim().to_ascii_lowercase().as_str() {
+            "channel" | "channels" => QueryTargetKind::Channel,
+            "pornstar" | "pornstars" => QueryTargetKind::Pornstar,
+            "model" | "models" => QueryTargetKind::Model,
+            "user" | "users" => QueryTargetKind::User,
+            _ => return None,
+        };
+
+        Some(QueryTarget { kind, slug })
+    }
+
+    fn build_browse_url(&self, page: u8, sort: &str) -> String {
+        let order = Self::normalize_sort(sort);
+        if order == "mr" {
+            format!("{}/video?page={page}", self.url)
+        } else {
+            format!("{}/video?o={order}&page={page}", self.url)
+        }
+    }
+
+    fn build_creator_url(&self, page: u8, sort: &str, target: &QueryTarget) -> String {
+        let mut url = format!(
+            "{}/{}/{}/videos?page={page}",
+            self.url,
+            target.kind.path_segment(),
+            target.slug
         );
 
-        if query.starts_with('@') {
-            let mut parts = query[1..].split(':');
-            let a = parts.next().unwrap_or("");
-            let b = parts.next().unwrap_or("");
-            video_url = format!(
-                "{}/{}/{}/videos?page={}",
-                self.url,
-                a,
-                b.replace(' ', "-"),
-                page
-            );
+        let mapped_sort = match target.kind {
+            QueryTargetKind::Channel => match Self::normalize_sort(sort) {
+                "mv" => Some("vi"),
+                "tr" => Some("ra"),
+                _ => None,
+            },
+            _ => match Self::normalize_sort(sort) {
+                "mv" => Some("mv"),
+                "tr" => Some("tr"),
+                "lg" => Some("lg"),
+                _ => None,
+            },
+        };
 
-            if query.contains("@model") || query.contains("@pornstar") {
-                split_string = "mostRecentVideosSection";
-            }
-            if query.contains("@channels") {
-                split_string = "<ul class=\"videos row-5-thumbs";
-            }
+        if let Some(order) = mapped_sort {
+            url.push_str("&o=");
+            url.push_str(order);
         }
 
-        video_url.push_str(match (query.contains("@channels"), sort) {
-            (true, "mv") => "&o=vi",
-            (true, "tr") => "&o=ra",
-            (false, "mv") => "&o=mv",
-            (false, "tr") => "&o=tr",
-            (false, "lg") => "&o=lg",
-            _ => "",
-        });
+        url
+    }
 
-        let old_items = match cache.get(&video_url) {
-            Some((time, items)) if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 => {
-                return Ok(items.clone());
+    fn build_listing_request(&self, page: u8, sort: &str, query: Option<&str>) -> (String, ListingScope) {
+        match query.map(str::trim).filter(|value| !value.is_empty()) {
+            Some(query) => {
+                if let Some(target) = Self::parse_query_target(query) {
+                    (self.build_creator_url(page, sort, &target), ListingScope::Creator)
+                } else {
+                    let encoded = query.to_ascii_lowercase().replace(' ', "+");
+                    (
+                        format!("{}/video/search?search={encoded}&page={page}", self.url),
+                        ListingScope::Search,
+                    )
+                }
             }
-            Some((_, items)) => items.clone(),
-            None => vec![],
-        };
-
-        let mut requester = match options.requester.clone() {
-            Some(r) => r,
-            None => return Ok(old_items),
-        };
-
-        let text = match requester.get(&video_url, None).await {
-            Ok(t) => t,
-            Err(_) => return Ok(old_items),
-        };
-
-        let video_items = self.get_video_items_from_html(text, split_string);
-
-        if video_items.is_empty() {
-            Ok(old_items)
-        } else {
-            cache.remove(&video_url);
-            cache.insert(video_url.clone(), video_items.clone());
-            Ok(video_items)
+            None => (self.build_browse_url(page, sort), ListingScope::Browse),
         }
     }
 
-    fn get_video_items_from_html(&self, html: String, split_string: &str) -> Vec<VideoItem> {
-        let content = match html.split(split_string).nth(1) {
-            Some(c) => c,
-            None => return vec![],
+    fn parse_listing_page(&self, html: &str, scope: ListingScope) -> Result<Vec<VideoItem>> {
+        let document = Html::parse_document(html);
+        let item_selector = Self::selector("li.pcVideoListItem")?;
+
+        let container_selectors = match scope {
+            ListingScope::Browse => vec!["#videoCategory"],
+            ListingScope::Search => vec!["#videoSearchResult"],
+            ListingScope::Creator => vec!["#showAllChanelVideos", "#mostRecentVideosSection"],
         };
 
-        let content = content.split("Porn in German").next().unwrap_or("");
+        for selector_text in container_selectors {
+            let container_selector = Self::selector(selector_text)?;
+            if let Some(container) = document.select(&container_selector).next() {
+                if container.select(&item_selector).next().is_some() {
+                    return self.parse_listing_items(container);
+                }
+            }
+        }
+
+        Err(ErrorKind::Parse(format!("missing listing container for scope {scope:?}")).into())
+    }
+
+    fn parse_listing_items(&self, container: ElementRef<'_>) -> Result<Vec<VideoItem>> {
+        let item_selector = Self::selector("li.pcVideoListItem")?;
+        let link_selector = Self::selector("a[href*=\"/view_video.php\"]")?;
+        let title_selector = Self::selector(".title a, .thumbnailTitle, span.title a")?;
+        let image_selector = Self::selector("img")?;
+        let duration_selector = Self::selector(".duration")?;
+        let views_selector = Self::selector(".views var")?;
+        let uploader_selector = Self::selector(
+            ".videoUploaderBlock a[href], .usernameWrap a[href], .usernameWrapper a[href]",
+        )?;
+        let verified_selector = Self::selector(".verified-icon, .channel-icon")?;
 
         let mut items = Vec::new();
+        let mut seen_ids = HashSet::new();
 
-        for seg in content
-            .split("class=\"pcVideoListItem ")
-            .skip(1)
-            .filter(|s| !s.contains("wrapVideoBlock"))
-        {
-            let url_part = seg
-                .split("<a href=\"")
-                .nth(1)
-                .or_else(|| seg.split("data-video-vkey=\"").nth(1))
-                .and_then(|s| s.split('"').next());
-
-            let video_url = match url_part {
-                Some(u) if !u.is_empty() && u != "javascript:void(0)" => {
-                    format!("{}{}", self.url, u)
-                }
-                _ => continue,
+        for card in container.select(&item_selector) {
+            let Some(link) = card.select(&link_selector).next() else {
+                continue;
             };
 
-            let mut title = seg
-                .split("\" title=\"")
-                .nth(1)
-                .and_then(|s| s.split('"').next())
-                .unwrap_or("")
-                .to_string();
+            let href = link.value().attr("href").unwrap_or_default();
+            let page_url = self.normalize_url(href);
+            if page_url.is_empty() || !page_url.contains("/view_video.php") {
+                continue;
+            }
 
-            title = decode(title.as_bytes()).to_string().unwrap_or(title);
-
-            let id = match seg
-                .split("data-video-id=\"")
-                .nth(1)
-                .and_then(|s| s.split('"').next())
-            {
-                Some(id) => id.to_string(),
-                None => continue,
+            let id = card
+                .value()
+                .attr("data-video-vkey")
+                .filter(|value| !value.trim().is_empty())
+                .map(ToOwned::to_owned)
+                .or_else(|| Self::viewkey_from_url(&page_url))
+                .or_else(|| {
+                    card.value()
+                        .attr("data-video-id")
+                        .filter(|value| !value.trim().is_empty())
+                        .map(ToOwned::to_owned)
+                });
+            let Some(id) = id else {
+                continue;
             };
+            if !seen_ids.insert(id.clone()) {
+                continue;
+            }
 
-            let raw_duration = seg
-                .split("duration")
-                .nth(1)
-                .and_then(|s| s.split('>').nth(1))
-                .and_then(|s| s.split('<').next())
-                .unwrap_or("0:00");
+            let title = link
+                .value()
+                .attr("title")
+                .filter(|value| !value.trim().is_empty())
+                .map(Self::decode_html)
+                .or_else(|| {
+                    card.select(&title_selector)
+                        .next()
+                        .map(|value| Self::decode_html(&Self::text_of(&value)))
+                })
+                .unwrap_or_default();
+            if title.is_empty() {
+                continue;
+            }
 
-            let duration = parse_time_to_seconds(raw_duration).unwrap_or(0) as u32;
+            let image = card.select(&image_selector).next();
+            let thumb = image
+                .as_ref()
+                .and_then(|value| {
+                    value
+                        .value()
+                        .attr("src")
+                        .or_else(|| value.value().attr("data-mediumthumb"))
+                })
+                .map(|value| self.normalize_url(value))
+                .unwrap_or_default();
 
-            let views = seg
-                .split("iews\">")
-                .filter_map(|p| p.split("<var>").nth(1))
+            let duration = card
+                .select(&duration_selector)
                 .next()
-                .and_then(|v| v.split('<').next())
-                .and_then(|v| parse_abbreviated_number(v))
-                .unwrap_or(0);
+                .map(|value| Self::text_of(&value))
+                .and_then(|value| parse_time_to_seconds(&value))
+                .unwrap_or(0) as u32;
 
-            let thumb = seg
-                .split("src=\"")
-                .nth(1)
-                .and_then(|s| s.split('"').next())
-                .unwrap_or("")
-                .to_string();
+            let views = card
+                .select(&views_selector)
+                .next()
+                .and_then(|value| parse_abbreviated_number(&Self::text_of(&value)));
 
-            let (tag, uploader) = if seg.contains("videoUploaderBlock") {
-                let href = seg
-                    .split("videoUploaderBlock")
-                    .nth(1)
-                    .and_then(|s| s.split("href=\"").nth(1))
-                    .and_then(|s| s.split('"').next())
-                    .unwrap_or("");
+            let uploader_link = card.select(&uploader_selector).next();
+            let uploader = uploader_link
+                .as_ref()
+                .map(|value| Self::decode_html(&Self::text_of(value)))
+                .filter(|value| !value.is_empty());
+            let uploader_url = uploader_link
+                .and_then(|value| value.value().attr("href"))
+                .map(|value| self.normalize_url(value))
+                .filter(|value| !value.is_empty());
 
-                let parts: Vec<&str> = href.split('/').collect();
-                if let (Some(kind), Some(name)) = (parts.get(1), parts.get(2)) {
-                    (
-                        Some(format!("@{}:{}", kind, name.replace('-', " "))),
-                        Some((*name).to_string()),
-                    )
-                } else {
-                    (None, None)
-                }
-            } else {
-                (None, None)
-            };
+            let mut item = VideoItem::new(
+                id,
+                title,
+                page_url,
+                CHANNEL_ID.to_string(),
+                thumb,
+                duration,
+            );
+            item.views = views;
+            item.preview = image
+                .and_then(|value| value.value().attr("data-mediabook"))
+                .map(|value| self.normalize_url(value))
+                .filter(|value| !value.is_empty());
+            item.verified = card
+                .select(&verified_selector)
+                .next()
+                .map(|_| true);
+            item.uploader = uploader.clone();
+            item.uploaderUrl = uploader_url.clone();
+            item.uploaderId = uploader_url
+                .as_deref()
+                .and_then(Self::uploader_identity_from_url);
 
-            let mut item = VideoItem::new(id, title, video_url, "pornhub".into(), thumb, duration);
-
-            if views > 0 {
-                item = item.views(views);
+            let mut tags = Vec::new();
+            if let Some(tag) = uploader_url
+                .as_deref()
+                .and_then(Self::query_tag_from_uploader_url)
+            {
+                tags.push(tag);
             }
-            if let Some(t) = tag {
-                item = item.tags(vec![t]);
-            }
-            if let Some(u) = uploader {
-                item = item.uploader(u);
+            if !tags.is_empty() {
+                item.tags = Some(tags);
             }
 
             items.push(item);
         }
 
-        items
+        Ok(items)
+    }
+
+    fn viewkey_from_url(url: &str) -> Option<String> {
+        let parsed = Url::parse(url).ok()?;
+        parsed
+            .query_pairs()
+            .find(|(key, _)| key == "viewkey")
+            .map(|(_, value)| value.into_owned())
+    }
+
+    fn uploader_identity_from_url(url: &str) -> Option<String> {
+        let parsed = Url::parse(url).ok()?;
+        let mut segments = parsed.path_segments()?;
+        let kind = segments.next()?.trim_matches('/');
+        let slug = segments.next()?.trim_matches('/');
+        if kind.is_empty() || slug.is_empty() {
+            return None;
+        }
+        Some(format!("{CHANNEL_ID}:{kind}:{slug}"))
+    }
+
+    fn query_tag_from_uploader_url(url: &str) -> Option<String> {
+        let parsed = Url::parse(url).ok()?;
+        let mut segments = parsed.path_segments()?;
+        let kind = segments.next()?.trim_matches('/');
+        let slug = segments.next()?.trim_matches('/');
+        if kind.is_empty() || slug.is_empty() {
+            return None;
+        }
+        Some(format!("@{kind}:{}", slug.replace('-', " ")))
+    }
+
+    fn push_unique(values: &mut Vec<String>, value: String) {
+        let normalized = value.trim();
+        if normalized.is_empty() {
+            return;
+        }
+        if values.iter().any(|existing| existing.eq_ignore_ascii_case(normalized)) {
+            return;
+        }
+        values.push(normalized.to_string());
+    }
+
+    fn collect_named_links(&self, document: &Html, selector_text: &str) -> Result<Vec<String>> {
+        let selector = Self::selector(selector_text)?;
+        let mut values = Vec::new();
+        for element in document.select(&selector) {
+            Self::push_unique(&mut values, Self::decode_html(&Self::text_of(&element)));
+        }
+        Ok(values)
+    }
+
+    fn parse_upload_date(value: &str) -> Option<u64> {
+        if let Ok(parsed) = DateTime::parse_from_rfc3339(value.trim()) {
+            return Some(parsed.timestamp() as u64);
+        }
+
+        NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d")
+            .ok()
+            .and_then(|date| date.and_hms_opt(0, 0, 0))
+            .map(|date| DateTime::<Utc>::from_naive_utc_and_offset(date, Utc).timestamp() as u64)
+    }
+
+    fn json_string(value: Option<&Value>) -> Option<String> {
+        value.and_then(|value| match value {
+            Value::String(value) => Some(value.to_string()),
+            Value::Number(value) => Some(value.to_string()),
+            _ => None,
+        })
+    }
+
+    fn json_u32(value: Option<&Value>) -> Option<u32> {
+        match value {
+            Some(Value::Number(value)) => value.as_u64().and_then(|value| u32::try_from(value).ok()),
+            Some(Value::String(value)) => value.parse::<u32>().ok(),
+            _ => None,
+        }
+    }
+
+    fn extract_flashvars(&self, html: &str) -> Result<Option<Value>> {
+        let regex = Self::regex(r#"(?s)var\s+flashvars_\d+\s*=\s*(\{.*?\});"#)?;
+        let Some(raw) = regex
+            .captures(html)
+            .and_then(|captures| captures.get(1))
+            .map(|value| value.as_str())
+        else {
+            return Ok(None);
+        };
+
+        Ok(Some(serde_json::from_str::<Value>(raw)?))
+    }
+
+    fn extract_ld_video_object(&self, document: &Html) -> Result<Option<Value>> {
+        let script_selector = Self::selector("script[type=\"application/ld+json\"]")?;
+        for script in document.select(&script_selector) {
+            let raw = script.inner_html();
+            let Ok(value) = serde_json::from_str::<Value>(&raw) else {
+                continue;
+            };
+
+            if Self::is_video_object(&value) {
+                return Ok(Some(value));
+            }
+
+            if let Some(array) = value.as_array() {
+                for entry in array {
+                    if Self::is_video_object(entry) {
+                        return Ok(Some(entry.clone()));
+                    }
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn is_video_object(value: &Value) -> bool {
+        value
+            .get("@type")
+            .and_then(|value| value.as_str())
+            .is_some_and(|value| value.eq_ignore_ascii_case("VideoObject"))
+    }
+
+    fn build_formats_from_flashvars(&self, flashvars: &Value) -> Vec<VideoFormat> {
+        let mut entries = flashvars
+            .get("mediaDefinitions")
+            .and_then(|value| value.as_array())
+            .into_iter()
+            .flatten()
+            .filter_map(|entry| {
+                let format = entry
+                    .get("format")
+                    .and_then(|value| value.as_str())
+                    .unwrap_or_default()
+                    .to_ascii_lowercase();
+                if format != "hls" {
+                    return None;
+                }
+
+                let url = entry
+                    .get("videoUrl")
+                    .and_then(|value| value.as_str())
+                    .map(|value| self.normalize_url(value))
+                    .filter(|value| !value.is_empty())?;
+
+                let quality = entry
+                    .get("quality")
+                    .and_then(|value| value.as_str())
+                    .unwrap_or("auto");
+                let label = match quality {
+                    "auto" => "auto".to_string(),
+                    value if value.ends_with('p') => value.to_string(),
+                    value => format!("{value}p"),
+                };
+
+                let rank = if label == "auto" {
+                    0
+                } else {
+                    label
+                        .trim_end_matches('p')
+                        .parse::<u32>()
+                        .unwrap_or(0)
+                };
+
+                Some((rank, label, url))
+            })
+            .collect::<Vec<_>>();
+
+        entries.sort_by_key(|(rank, _, _)| *rank);
+        entries.dedup_by(|a, b| a.2 == b.2);
+
+        entries
+            .into_iter()
+            .map(|(_, label, url)| {
+                VideoFormat::new(url, label.clone(), "m3u8".to_string())
+                    .format_id(label.clone())
+                    .format_note(label)
+            })
+            .collect()
+    }
+
+    fn apply_detail_video(&self, mut item: VideoItem, html: &str) -> Result<VideoItem> {
+        let document = Html::parse_document(html);
+
+        if let Some(flashvars) = self.extract_flashvars(html)? {
+            if let Some(title) = Self::json_string(flashvars.get("video_title")) {
+                let decoded = Self::decode_html(&title);
+                if !decoded.is_empty() {
+                    item.title = decoded;
+                }
+            }
+
+            if let Some(thumb) = Self::json_string(flashvars.get("image_url")) {
+                let normalized = self.normalize_url(&thumb);
+                if !normalized.is_empty() {
+                    item.thumb = normalized;
+                }
+            }
+
+            if let Some(duration) = Self::json_u32(flashvars.get("video_duration")) {
+                item.duration = duration;
+            }
+
+            if let Some(link_url) = Self::json_string(flashvars.get("link_url")) {
+                let normalized = self.normalize_url(&link_url);
+                if !normalized.is_empty() {
+                    item.url = normalized;
+                }
+            }
+
+            let formats = self.build_formats_from_flashvars(&flashvars);
+            if !formats.is_empty() {
+                item.formats = Some(formats);
+            }
+        }
+
+        if let Some(ld_video) = self.extract_ld_video_object(&document)? {
+            if let Some(thumb) = ld_video
+                .get("thumbnailUrl")
+                .and_then(|value| match value {
+                    Value::String(value) => Some(value.to_string()),
+                    Value::Array(values) => values
+                        .iter()
+                        .find_map(|entry| entry.as_str().map(ToOwned::to_owned)),
+                    _ => None,
+                })
+            {
+                let normalized = self.normalize_url(&thumb);
+                if !normalized.is_empty() {
+                    item.thumb = normalized;
+                }
+            }
+
+            if let Some(uploaded_at) = ld_video
+                .get("uploadDate")
+                .and_then(|value| value.as_str())
+                .and_then(Self::parse_upload_date)
+            {
+                item.uploadedAt = Some(uploaded_at);
+            }
+
+            if item.views.is_none() {
+                item.views = Self::json_string(ld_video.get("interactionCount"))
+                    .and_then(|value| value.parse::<u32>().ok());
+            }
+
+            if item.uploader.is_none() {
+                item.uploader = ld_video
+                    .get("author")
+                    .and_then(|value| match value {
+                        Value::String(value) => Some(value.to_string()),
+                        Value::Object(values) => values
+                            .get("name")
+                            .and_then(|value| value.as_str())
+                            .map(ToOwned::to_owned),
+                        _ => None,
+                    })
+                    .filter(|value| !value.trim().is_empty());
+            }
+        }
+
+        let mut tags = item.tags.clone().unwrap_or_default();
+        for value in self.collect_named_links(
+            &document,
+            ".categoriesWrapper a.item, .categoriesWrapper a[href*=\"/categories/\"]",
+        )? {
+            Self::push_unique(&mut tags, value);
+        }
+        for value in self.collect_named_links(
+            &document,
+            ".tagsWrapper a.item, .tagsWrapper a[href*=\"/video/search\"]",
+        )? {
+            Self::push_unique(&mut tags, value);
+        }
+        for value in self.collect_named_links(
+            &document,
+            ".pornstarsWrapper a.item, .pornstarsWrapper a[href*=\"/pornstar/\"], a[href*=\"/pornstar/\"]",
+        )? {
+            Self::push_unique(&mut tags, value);
+        }
+        for value in self.collect_named_links(
+            &document,
+            ".modelsWrapper a.item, .modelsWrapper a[href*=\"/model/\"], a[href*=\"/model/\"]",
+        )? {
+            Self::push_unique(&mut tags, value);
+        }
+        if !tags.is_empty() {
+            item.tags = Some(tags);
+        }
+
+        Ok(item)
+    }
+
+    async fn enrich_listing_items(&self, items: Vec<VideoItem>, options: &ServerOptions) -> Vec<VideoItem> {
+        let requester = requester_or_default(options, CHANNEL_ID, "enrich_listing_items.requester");
+        let mut enriched = stream::iter(items.into_iter().enumerate().map(|(index, item)| {
+            let provider = self.clone();
+            let requester = requester.clone();
+            async move {
+                if index >= DETAIL_ENRICH_LIMIT || item.url.is_empty() {
+                    return (index, item);
+                }
+
+                let fallback = item.clone();
+                let enriched = match provider.fetch_detail(item, requester).await {
+                    Ok(value) => value,
+                    Err(error) => {
+                        report_provider_error_background(
+                            CHANNEL_ID,
+                            "enrich_listing_items.detail",
+                            &format!("url={}; error={error}", fallback.url),
+                        );
+                        fallback
+                    }
+                };
+                (index, enriched)
+            }
+        }))
+        .buffer_unordered(4)
+        .collect::<Vec<_>>()
+        .await;
+
+        enriched.sort_by_key(|(index, _)| *index);
+        enriched.into_iter().map(|(_, item)| item).collect()
+    }
+
+    async fn fetch_detail(&self, item: VideoItem, mut requester: crate::util::requester::Requester) -> Result<VideoItem> {
+        let html = requester
+            .get(&item.url, None)
+            .await
+            .map_err(|error| ErrorKind::Parse(format!("detail request failed: {error}")))?;
+        self.apply_detail_video(item, &html)
+    }
+
+    async fn fetch_listing(
+        &self,
+        cache: VideoCache,
+        page: u8,
+        sort: &str,
+        query: Option<&str>,
+        options: ServerOptions,
+    ) -> Result<Vec<VideoItem>> {
+        let (video_url, scope) = self.build_listing_request(page, sort, query);
+        let old_items = match cache.get(&video_url) {
+            Some((time, items)) if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 => {
+                return Ok(items.clone());
+            }
+            Some((_, items)) => items.clone(),
+            None => vec![],
+        };
+
+        let mut requester = requester_or_default(&options, CHANNEL_ID, "fetch_listing.requester");
+        let text = match requester.get(&video_url, None).await {
+            Ok(text) => text,
+            Err(error) => {
+                report_provider_error(
+                    CHANNEL_ID,
+                    "fetch_listing.request",
+                    &format!("url={video_url}; error={error}"),
+                )
+                .await;
+                return Ok(old_items);
+            }
+        };
+
+        let items = match self.parse_listing_page(&text, scope) {
+            Ok(items) => items,
+            Err(error) => {
+                report_provider_error(
+                    CHANNEL_ID,
+                    "fetch_listing.parse",
+                    &format!("url={video_url}; error={error}"),
+                )
+                .await;
+                return Ok(old_items);
+            }
+        };
+
+        if items.is_empty() {
+            return Ok(old_items);
+        }
+
+        let items = self.enrich_listing_items(items, &options).await;
+        cache.remove(&video_url);
+        cache.insert(video_url, items.clone());
+        Ok(items)
     }
 }
 
@@ -325,29 +830,148 @@ impl Provider for PornhubProvider {
         let _ = per_page;
 
         let page = page.parse::<u8>().unwrap_or(1);
-        let mut sort = match sort.as_str() {
-            "mv" => "mv",
-            "tr" => "tr",
-            "cm" => "cm",
-            "lg" => "lg",
-            _ => "mr",
-        };
-        if sort.contains("date") {
-            sort = "mr".into();
+        let sort = Self::normalize_sort(&sort).to_string();
+
+        match self
+            .fetch_listing(cache, page, &sort, query.as_deref(), options)
+            .await
+        {
+            Ok(items) => items,
+            Err(error) => {
+                report_provider_error(CHANNEL_ID, "get_videos", &error.to_string()).await;
+                vec![]
+            }
         }
-
-        let res = match query {
-            Some(q) => self.query(cache, page, &q, &sort, options).await,
-            None => self.get(cache, page, &sort, options).await,
-        };
-
-        res.unwrap_or_else(|e| {
-            eprintln!("PornhubProvider error: {e}");
-            vec![]
-        })
     }
 
     fn get_channel(&self, clientversion: ClientVersion) -> Option<Channel> {
         Some(self.build_channel(clientversion))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_creator_queries() {
+        let target = PornhubProvider::parse_query_target("@channels:Brazzers")
+            .expect("channel target should parse");
+        assert!(matches!(target.kind, QueryTargetKind::Channel));
+        assert_eq!(target.slug, "brazzers");
+
+        let target = PornhubProvider::parse_query_target("@pornstar:Alex Mack")
+            .expect("pornstar target should parse");
+        assert!(matches!(target.kind, QueryTargetKind::Pornstar));
+        assert_eq!(target.slug, "alex-mack");
+
+        assert!(PornhubProvider::parse_query_target("teacher").is_none());
+    }
+
+    #[test]
+    fn parses_browse_listing_cards() {
+        let provider = PornhubProvider::new();
+        let html = r#"
+        <ul id="videoCategory" class="nf-videos videos search-video-thumbs">
+          <li class="sniperModeEngaged"></li>
+          <li class="pcVideoListItem js-pop videoblock videoBox withKebabMenu"
+              data-video-id="466705435"
+              data-video-vkey="67ed937c986b1">
+            <a href="/view_video.php?viewkey=67ed937c986b1" title="Black asian teen"></a>
+            <img src="https://example.com/thumb.jpg"
+                 data-mediabook="https://example.com/preview.webm" />
+            <div class="marker-overlays"><var class="duration">12:18</var></div>
+            <div class="videoUploaderBlock">
+              <div class="usernameWrap">
+                <a href="/model/honeycore">Honeycore</a>
+              </div>
+            </div>
+            <div class="videoDetailsBlock">
+              <span class="views"><var>199K</var> views</span>
+            </div>
+          </li>
+        </ul>
+        "#;
+
+        let items = provider
+            .parse_listing_page(html, ListingScope::Browse)
+            .expect("browse listing should parse");
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].id, "67ed937c986b1");
+        assert_eq!(items[0].uploader.as_deref(), Some("Honeycore"));
+        assert_eq!(
+            items[0].uploaderUrl.as_deref(),
+            Some("https://www.pornhub.com/model/honeycore")
+        );
+        assert_eq!(items[0].views, Some(199000));
+        assert_eq!(items[0].duration, 738);
+        assert_eq!(
+            items[0].preview.as_deref(),
+            Some("https://example.com/preview.webm")
+        );
+        assert!(items[0]
+            .tags
+            .as_ref()
+            .is_some_and(|values| values.iter().any(|value| value == "@model:honeycore")));
+    }
+
+    #[test]
+    fn applies_detail_video_metadata() {
+        let provider = PornhubProvider::new();
+        let item = VideoItem::new(
+            "69cfa159b1377".to_string(),
+            "placeholder".to_string(),
+            "https://www.pornhub.com/view_video.php?viewkey=69cfa159b1377".to_string(),
+            CHANNEL_ID.to_string(),
+            "https://example.com/thumb.jpg".to_string(),
+            0,
+        );
+        let html = r#"
+        <script>
+          var flashvars_482929735 = {
+            "video_title":"Brazzers Detail Title",
+            "image_url":"https://example.com/detail.jpg",
+            "video_duration":"930",
+            "link_url":"https://www.pornhub.com/view_video.php?viewkey=69cfa159b1377",
+            "mediaDefinitions":[
+              {"format":"hls","quality":"240","videoUrl":"https://cdn.example.com/master-240.m3u8"},
+              {"format":"hls","quality":"720","videoUrl":"https://cdn.example.com/master-720.m3u8"},
+              {"format":"mp4","quality":"720","videoUrl":"https://cdn.example.com/video.mp4","remote":true}
+            ]
+          };
+        </script>
+        <script type="application/ld+json">
+          {
+            "@type":"VideoObject",
+            "thumbnailUrl":"https://example.com/ld-thumb.jpg",
+            "uploadDate":"2026-04-03T00:00:00+00:00",
+            "interactionCount":"5700",
+            "author":{"name":"Brazzers"}
+          }
+        </script>
+        <div class="categoriesWrapper">
+          <a class="item" href="/categories/big-tits">Big Tits</a>
+        </div>
+        <div class="tagsWrapper">
+          <a class="item" href="/video/search?search=maid">Maid</a>
+        </div>
+        "#;
+
+        let item = provider
+            .apply_detail_video(item, html)
+            .expect("detail page should enrich item");
+        assert_eq!(item.title, "Brazzers Detail Title");
+        assert_eq!(item.thumb, "https://example.com/ld-thumb.jpg");
+        assert_eq!(item.duration, 930);
+        assert_eq!(item.views, Some(5700));
+        assert_eq!(item.uploader.as_deref(), Some("Brazzers"));
+        assert!(item.uploadedAt.is_some());
+        assert_eq!(item.formats.as_ref().map(|values| values.len()), Some(2));
+        assert!(item.tags.as_ref().is_some_and(|values| values
+            .iter()
+            .any(|value| value == "Big Tits")));
+        assert!(item.tags.as_ref().is_some_and(|values| values
+            .iter()
+            .any(|value| value == "Maid")));
+    }
+}