Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use super::models::*;
use crate::providers::models::{
AudioTrackOption, CatalogItem, Episode, MediaDetails, MediaType, ProviderError, ProviderKind,
ProviderMediaId, Release, Season, SourceMirror,
};
use reqwest::Client;
use std::time::Duration;
const DEFAULT_BASE_URL: &str = "https://api.nodeobjects.com/";
const IMAGE_CDN_BASE: &str = "https://static.nodeobjects.com/thumbnail/";
fn encode_param(s: &str) -> String {
percent_encoding::utf8_percent_encode(s, percent_encoding::NON_ALPHANUMERIC).to_string()
}
#[derive(Debug, thiserror::Error)]
pub enum DramachiError {
#[error("Network request failed: {0}")]
Network(#[from] reqwest::Error),
#[error("Failed to parse Dramachi response: {0}")]
Parsing(String),
#[error("Item not found")]
NotFound,
}
impl From<DramachiError> for ProviderError {
fn from(err: DramachiError) -> Self {
match err {
DramachiError::Network(e) => ProviderError::Network(e.to_string()),
DramachiError::Parsing(e) => ProviderError::Parsing(e),
DramachiError::NotFound => ProviderError::NotFound,
}
}
}
type TitleCache = std::sync::Arc<
std::sync::Mutex<Option<(String, std::time::Instant, DramachiTitleDetailsResponse)>>,
>;
type EpListCache = std::sync::Arc<
std::sync::Mutex<
std::collections::HashMap<(String, String), (std::time::Instant, Vec<DramachiEpisodeItem>)>,
>,
>;
#[derive(Debug, Clone)]
pub struct DramachiClient {
client: Client,
base_url: String,
title_cache: TitleCache,
eplist_cache: EpListCache,
}
impl Default for DramachiClient {
fn default() -> Self {
Self::new()
}
}
impl DramachiClient {
pub fn new() -> Self {
Self::with_base_url(DEFAULT_BASE_URL)
}
pub fn with_base_url(base_url: impl Into<String>) -> Self {
let client = crate::net::http_client_builder()
.timeout(Duration::from_secs(15))
.build()
.unwrap_or_default();
Self {
client,
base_url: base_url.into(),
title_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
eplist_cache: std::sync::Arc::new(std::sync::Mutex::new(
std::collections::HashMap::new(),
)),
}
}
async fn fetch_title_details(
&self,
title_id: &str,
) -> Result<DramachiTitleDetailsResponse, DramachiError> {
if let Ok(lock) = self.title_cache.lock()
&& let Some((cached_id, ts, data)) = lock.as_ref()
&& cached_id == title_id
&& ts.elapsed() < Duration::from_secs(60)
{
return Ok(data.clone());
}
let url = format!(
"{}?interface=title_v2&id={}",
self.base_url,
encode_param(title_id)
);
let resp = self.client.get(&url).send().await?.error_for_status()?;
let data: DramachiTitleDetailsResponse = resp
.json()
.await
.map_err(|e| DramachiError::Parsing(format!("failed to parse title details: {e}")))?;
if let Ok(mut lock) = self.title_cache.lock() {
*lock = Some((
title_id.to_string(),
std::time::Instant::now(),
data.clone(),
));
}
Ok(data)
}
pub async fn search(
&self,
query: &str,
page: usize,
) -> Result<Vec<CatalogItem>, DramachiError> {
let trimmed = query.trim();
if trimmed.is_empty() {
return Ok(Vec::new());
}
let url = format!(
"{}?interface=search&q={}&filter=all&page={}",
self.base_url,
encode_param(trimmed),
page.max(1)
);
let resp = self.client.get(&url).send().await?.error_for_status()?;
let data: DramachiSearchResponse = resp
.json()
.await
.map_err(|e| DramachiError::Parsing(format!("failed to parse search response: {e}")))?;
let items = data.data.unwrap_or_default();
let mut results = Vec::with_capacity(items.len());
for item in items {
let is_movie = item
.content
.as_deref()
.map(|c| c.eq_ignore_ascii_case("movies") || c.eq_ignore_ascii_case("movie"))
.unwrap_or(false);
let media_type = if is_movie {
MediaType::Movie
} else {
MediaType::Series
};
let poster_url = item
.thumb
.filter(|t| !t.trim().is_empty())
.map(|t| format!("{IMAGE_CDN_BASE}{}", t.trim()));
results.push(CatalogItem {
id: ProviderMediaId {
provider: ProviderKind::Dramachi,
value: item.id,
},
title: item.title,
media_type,
year: item.year.filter(|y| !y.trim().is_empty()),
poster_url,
season_count: None,
});
}
Ok(results)
}
pub async fn details(&self, id: &str) -> Result<MediaDetails, DramachiError> {
let (title_id, target_dub_rip) = match id.split_once("::") {
Some((t_id, rip)) => (t_id.trim(), Some(rip.trim())),
None => (id.trim(), None),
};
if title_id.is_empty() {
return Err(DramachiError::NotFound);
}
let data = self.fetch_title_details(title_id).await?;
let album = data
.album
.as_ref()
.and_then(|a| a.first())
.ok_or(DramachiError::NotFound)?;
let is_movie = album
.content
.as_deref()
.map(|c| c.eq_ignore_ascii_case("movies") || c.eq_ignore_ascii_case("movie"))
.unwrap_or(false);
let media_type = if is_movie {
MediaType::Movie
} else {
MediaType::Series
};
let poster_url = album
.thumb
.as_deref()
.filter(|t| !t.trim().is_empty())
.map(|t| format!("{IMAGE_CDN_BASE}{}", t.trim()));
let genres: Vec<String> = album
.genres
.as_deref()
.map(|g| {
g.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
})
.unwrap_or_default();
let stars: Vec<String> = data
.cast
.unwrap_or_default()
.into_iter()
.map(|c| c.name)
.filter(|n| !n.trim().is_empty())
.collect();
let mut sorted_season_keys: Vec<String> = data
.seasons
.as_ref()
.map(|m| m.keys().cloned().collect())
.unwrap_or_default();
sorted_season_keys.sort_by_key(|k| extract_leading_season_number(k).unwrap_or(usize::MAX));
let mut seasons_vec = Vec::new();
let mut dubs_vec = Vec::new();
if let Some(seasons_map) = data.seasons {
for (season_key, group) in &seasons_map {
if let Some(versions) = &group.versions {
for version in versions {
let label = if seasons_map.len() > 1 {
format!("{}: {}", season_key, version.version_name)
} else {
version.version_name.clone()
};
let composite_subject_id = format!("{}::{}", title_id, version.rip);
dubs_vec.push(AudioTrackOption {
subject_id: composite_subject_id,
language: version.version_name.clone(),
label,
});
}
}
}
dubs_vec.sort_by(|a, b| {
let priority = |s: &str| -> usize {
let l = s.to_ascii_lowercase();
if l.contains("original") || l == "orig" {
0
} else if l.contains("english") || l.contains("eng") {
1
} else if l.contains("dub") {
2
} else {
3
}
};
priority(&a.language).cmp(&priority(&b.language))
});
if media_type == MediaType::Series {
let mut season_rips = Vec::new();
for key in &sorted_season_keys {
let rip_for_season = seasons_map
.get(key)
.and_then(|g| g.versions.as_ref())
.and_then(|versions| {
if let Some(target) = target_dub_rip {
versions
.iter()
.find(|v| v.rip == target)
.map(|v| v.rip.clone())
} else {
None
}
.or_else(|| versions.first().map(|v| v.rip.clone()))
})
.unwrap_or_else(|| key.clone());
let season_num = extract_leading_season_number(key).unwrap_or(1);
season_rips.push((season_num, rip_for_season));
}
let season_futures: Vec<_> = season_rips
.into_iter()
.map(|(season_num, rip)| {
let rip_clone = rip.clone();
async move {
let episodes = self
.fetch_episodes(title_id, &rip_clone)
.await
.unwrap_or_default();
let eps_models = if !episodes.is_empty() {
let mut seen_ep_numbers = std::collections::HashSet::new();
let mut unique_eps = Vec::new();
for (idx, ep) in episodes.iter().enumerate() {
let ep_num =
parse_episode_number(&ep.f_title).unwrap_or(idx + 1);
if seen_ep_numbers.insert(ep_num) {
let clean_title = clean_episode_title(&ep.f_title);
unique_eps.push(Episode {
season: season_num,
number: ep_num,
title: Some(clean_title),
overview: None,
});
}
}
unique_eps.sort_by_key(|e| e.number);
unique_eps
} else {
vec![Episode {
season: season_num,
number: 1,
title: None,
overview: None,
}]
};
Season {
number: season_num,
episodes: eps_models,
}
}
})
.collect();
seasons_vec = futures::future::join_all(season_futures).await;
}
}
let primary_id = target_dub_rip
.map(|rip| format!("{title_id}::{rip}"))
.unwrap_or_else(|| title_id.to_string());
Ok(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::Dramachi,
value: primary_id,
},
title: album.title.clone(),
media_type,
year: album.year.clone().filter(|y| !y.trim().is_empty()),
description: album.storyline.clone().filter(|s| !s.trim().is_empty()),
tagline: None,
imdb_rating: None,
director: album.director.clone().filter(|d| !d.trim().is_empty()),
stars: if stars.is_empty() {
None
} else {
Some(stars.join(", "))
},
prints: None,
audios: None,
poster_url,
duration: None,
genres,
seasons: seasons_vec,
dubs: dubs_vec,
})
}
pub async fn fetch_episodes(
&self,
title_id: &str,
rip: &str,
) -> Result<Vec<DramachiEpisodeItem>, DramachiError> {
let key = (title_id.to_string(), rip.to_string());
if let Ok(lock) = self.eplist_cache.lock()
&& let Some((ts, cached)) = lock.get(&key)
&& ts.elapsed() < Duration::from_secs(60)
{
return Ok(cached.clone());
}
let url = format!(
"{}?interface=eplist&season={}&id={}",
self.base_url,
encode_param(rip),
encode_param(title_id)
);
let resp = self.client.get(&url).send().await?.error_for_status()?;
let data: DramachiEpisodeListResponse = resp
.json()
.await
.map_err(|e| DramachiError::Parsing(format!("failed to parse episode list: {e}")))?;
let mut episodes = data.episode_list.unwrap_or_default();
episodes.sort_by_key(|ep| parse_episode_number(&ep.f_title).unwrap_or(usize::MAX));
if let Ok(mut lock) = self.eplist_cache.lock() {
if lock.len() >= 16 {
lock.clear();
}
lock.insert(key, (std::time::Instant::now(), episodes.clone()));
}
Ok(episodes)
}
pub async fn fetch_file_stream(
&self,
fid: &str,
disk: &str,
) -> Result<(String, String), DramachiError> {
let url = format!(
"{}?interface=getFile&fid={}&findex={}",
self.base_url,
encode_param(fid),
encode_param(disk)
);
let resp = self.client.get(&url).send().await?;
let data: DramachiFileInfoResponse = resp.json().await.map_err(|e| {
DramachiError::Parsing(format!("failed to parse getFile response: {e}"))
})?;
let host_info = data
.host_info
.ok_or_else(|| DramachiError::Parsing("missing hostInfo in getFile".to_string()))?;
let file_info = data
.file_info
.as_ref()
.and_then(|f| f.first())
.ok_or(DramachiError::NotFound)?;
let raw_url = file_info
.url
.as_deref()
.ok_or_else(|| DramachiError::Parsing("missing url in fileInfo".to_string()))?;
let filename = file_info
.filename
.clone()
.or_else(|| file_info.f_title.clone())
.unwrap_or_else(|| format!("{fid}.mkv"));
let stream_url = format!(
"https://{}/cdn/{}",
host_info.host.trim_end_matches('/'),
raw_url.trim_start_matches('/')
);
Ok((stream_url, filename))
}
pub async fn episode_streams(
&self,
id: &str,
season: usize,
episode: usize,
) -> Result<Vec<Release>, DramachiError> {
let (title_id, target_rip) = match id.split_once("::") {
Some((t_id, rip)) => (t_id.trim(), Some(rip.trim())),
None => (id.trim(), None),
};
if title_id.is_empty() {
return Err(DramachiError::NotFound);
}
let rip_to_query = if let Some(rip) = target_rip {
rip.to_string()
} else {
let data = self.fetch_title_details(title_id).await?;
let mut resolved_rip = None;
if let Some(seasons_map) = &data.seasons {
if season > 0 {
let target_season_key = format!("Season {:02}", season);
if let Some(group) = seasons_map.get(&target_season_key) {
resolved_rip = group
.versions
.as_ref()
.and_then(|v| v.first())
.map(|v| v.rip.clone());
}
}
if resolved_rip.is_none() {
resolved_rip = seasons_map
.values()
.next()
.and_then(|g| g.versions.as_ref())
.and_then(|v| v.first())
.map(|v| v.rip.clone());
}
}
resolved_rip.unwrap_or_else(|| {
if season > 0 {
format!("Season {:02}", season)
} else {
"hd Rip".to_string()
}
})
};
let episodes = self.fetch_episodes(title_id, &rip_to_query).await?;
if episodes.is_empty() {
return Ok(Vec::new());
}
let matched_items: Vec<&DramachiEpisodeItem> = if season == 0 && episode == 0 {
episodes.iter().collect()
} else {
let exact = episodes
.iter()
.filter(|ep| parse_episode_number(&ep.f_title) == Some(episode))
.collect::<Vec<_>>();
if !exact.is_empty() {
exact
} else if episode > 0 && episode <= episodes.len() {
vec![&episodes[episode - 1]]
} else {
Vec::new()
}
};
let stream_futs: Vec<_> = matched_items
.into_iter()
.filter(|ep| !ep.fid.is_empty() && !ep.disk.is_empty())
.map(|ep| {
let ep_fid = ep.fid.clone();
let ep_disk = ep.disk.clone();
let ep_quality = ep.quality.clone();
let ep_size = ep.size.clone();
async move {
match self.fetch_file_stream(&ep_fid, &ep_disk).await {
Ok((stream_url, filename)) => {
let quality = ep_quality.filter(|q| !q.is_empty());
let size_bytes = crate::providers::models::parse_size_bytes(
ep_size.as_deref().unwrap_or_default(),
);
Some(Release {
provider: ProviderKind::Dramachi,
filename,
quality,
codec: None,
language: None,
size_bytes,
season: if season > 0 { Some(season) } else { None },
episode: if episode > 0 { Some(episode) } else { None },
mirrors: vec![SourceMirror {
label: "Dramachi CDN".to_string(),
resolver_url: stream_url,
headers: vec![],
direct_file: true,
}],
resource_id: Some(ep_fid),
})
}
Err(err) => {
log::warn!("failed to resolve Dramachi stream for fid {ep_fid}: {err}");
None
}
}
}
})
.collect();
let mut releases: Vec<Release> = futures::future::join_all(stream_futs)
.await
.into_iter()
.flatten()
.collect();
releases.sort_by_key(|r| std::cmp::Reverse(r.resolution_i64()));
Ok(releases)
}
}
fn extract_leading_season_number(name: &str) -> Option<usize> {
let lower = name.to_ascii_lowercase();
let after_season = lower.strip_prefix("season")?.trim();
let num_str: String = after_season
.chars()
.take_while(|c| c.is_ascii_digit())
.collect();
num_str.parse::<usize>().ok()
}
fn parse_episode_number(f_title: &str) -> Option<usize> {
let cleaned = clean_episode_title(f_title);
let upper = cleaned.to_ascii_uppercase();
for prefix in ["EPISODE", "EP.", "EP", "E"] {
let mut search_from = 0;
while let Some(rel_pos) = upper[search_from..].find(prefix) {
let pos = search_from + rel_pos;
let prev_char = upper[..pos].chars().next_back();
let valid_boundary = match prev_char {
None => true,
Some(ch) => !ch.is_alphabetic() || (prefix == "E" && ch.is_ascii_digit()),
};
let after = &upper[pos + prefix.len()..];
let after_trimmed = after.trim_start_matches([' ', '-', '.', '_']);
let num_str: String = after_trimmed
.chars()
.take_while(|c| c.is_ascii_digit())
.collect();
if valid_boundary
&& !num_str.is_empty()
&& let Ok(num) = num_str.parse::<usize>()
{
return Some(num);
}
search_from = pos + prefix.len();
}
}
if let Some(last_token) = cleaned.split_whitespace().last()
&& let Ok(num) = last_token.parse::<usize>()
{
return Some(num);
}
None
}
fn clean_episode_title(f_title: &str) -> String {
let mut title = f_title.trim();
for suffix in &[
" 720p",
" 1080p",
" 540p",
" 480p",
" 360p",
" DUB",
" hi DUB",
" ENG Subbed Full",
] {
if let Some(stripped) = title.strip_suffix(suffix) {
title = stripped;
}
}
title.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_episode_number_formats() {
assert_eq!(parse_episode_number("Queen of Tears S01E16"), Some(16));
assert_eq!(parse_episode_number("Squid Game S02E07 DUB"), Some(7));
assert_eq!(parse_episode_number("Parasite 2019 001"), Some(1));
assert_eq!(parse_episode_number("Parasite 2019 002"), Some(2));
assert_eq!(parse_episode_number("The Mentalist S07E12"), Some(12));
}
#[test]
fn test_extract_leading_season_number() {
assert_eq!(extract_leading_season_number("Season 01"), Some(1));
assert_eq!(extract_leading_season_number("Season 2"), Some(2));
assert_eq!(extract_leading_season_number("Season 07"), Some(7));
assert_eq!(extract_leading_season_number("hd Rip"), None);
}
#[test]
fn test_parse_size_to_bytes() {
assert_eq!(
crate::providers::models::parse_size_bytes("218.32 MB"),
Some(228925112)
);
assert_eq!(
crate::providers::models::parse_size_bytes("1.5 GB"),
Some(1610612736)
);
assert_eq!(crate::providers::models::parse_size_bytes(""), None);
}
}