Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use super::models::Channel;
use std::path::PathBuf;
use std::time::SystemTime;
pub struct M3UParser {
cache_dir: PathBuf,
client: reqwest::Client,
}
impl Default for M3UParser {
fn default() -> Self {
Self::new()
}
}
const MAX_PLAYLIST_BYTES: usize = 15 * 1024 * 1024;
impl M3UParser {
pub fn new() -> Self {
let cache_dir = crate::config::cache_dir().join("tv_playlists");
std::fs::create_dir_all(&cache_dir).ok();
let client = crate::net::http_client_builder()
.connect_timeout(std::time::Duration::from_secs(10))
.timeout(std::time::Duration::from_secs(30))
.build()
.unwrap_or_default();
Self { cache_dir, client }
}
pub async fn fetch_playlist(
&self,
url: &str,
) -> Result<Vec<Channel>, Box<dyn std::error::Error + Send + Sync>> {
let trimmed = url.trim().trim_matches(|c| c == '"' || c == '\'').trim();
let is_remote = crate::net::is_http_url(trimmed);
let content = if is_remote {
let file_path = self.cache_dir.join(cache_filename(trimmed));
let mut needs_download = true;
if tokio::fs::try_exists(&file_path).await.unwrap_or(false) {
if let Ok(metadata) = tokio::fs::metadata(&file_path).await {
if let Ok(modified) = metadata.modified() {
if let Ok(duration) = SystemTime::now().duration_since(modified) {
if duration.as_secs() < 24 * 3600 {
needs_download = false;
}
}
}
}
}
if needs_download {
let resp = self.client.get(trimmed).send().await?.error_for_status()?;
if let Some(cl) = resp.content_length() {
if cl as usize > MAX_PLAYLIST_BYTES {
return Err("remote playlist exceeds maximum 15MB size limit".into());
}
}
let res = resp.text().await?;
if res.len() > MAX_PLAYLIST_BYTES {
return Err("remote playlist exceeds maximum 15MB size limit".into());
}
let _ = crate::cache::atomic_write_file_async(&file_path, res.as_bytes()).await;
res
} else {
match tokio::fs::read_to_string(&file_path).await {
Ok(content) => content,
Err(_) => {
let _ = tokio::fs::remove_file(&file_path).await;
self.client
.get(trimmed)
.send()
.await?
.error_for_status()?
.text()
.await?
}
}
}
} else {
let path = if let Some(stripped) = trimmed
.strip_prefix("~/")
.or_else(|| trimmed.strip_prefix("~\\"))
{
dirs::home_dir()
.map(|h| h.join(stripped))
.unwrap_or_else(|| std::path::PathBuf::from(trimmed))
} else if trimmed == "~" {
dirs::home_dir().unwrap_or_else(|| std::path::PathBuf::from(trimmed))
} else {
std::path::PathBuf::from(trimmed)
};
let metadata = tokio::fs::metadata(&path)
.await
.map_err(|error| format!("failed to read playlist file {}: {error}", trimmed))?;
if metadata.len() as usize > MAX_PLAYLIST_BYTES {
return Err("local playlist exceeds maximum 15MB size limit".into());
}
tokio::fs::read_to_string(&path)
.await
.map_err(|error| format!("failed to read playlist file {}: {error}", trimmed))?
};
let channels = self.parse_m3u(&content);
if is_remote && channels.is_empty() {
let file_path = self.cache_dir.join(cache_filename(trimmed));
let _ = tokio::fs::remove_file(&file_path).await;
let resp = self.client.get(trimmed).send().await?.error_for_status()?;
if let Some(cl) = resp.content_length() {
if cl as usize > MAX_PLAYLIST_BYTES {
return Err("remote playlist exceeds maximum 15MB size limit".into());
}
}
let fresh = resp.text().await?;
if fresh.len() > MAX_PLAYLIST_BYTES {
return Err("remote playlist exceeds maximum 15MB size limit".into());
}
let fresh_channels = self.parse_m3u(&fresh);
if fresh_channels.is_empty() {
return Ok(fresh_channels);
}
let _ = crate::cache::atomic_write_file_async(&file_path, fresh.as_bytes()).await;
return Ok(fresh_channels);
}
Ok(channels)
}
pub fn parse_m3u(&self, content: &str) -> Vec<Channel> {
let estimated = content.as_bytes().iter().filter(|&&b| b == b'\n').count() / 2;
let mut channels = Vec::with_capacity(estimated.max(16));
let mut current_channel = Channel::default();
for line in content.lines() {
let line = line.trim().trim_start_matches('\u{feff}');
if line.is_empty() {
continue;
}
if line.starts_with("#EXTINF:") {
let tvg_id = extract_attr_slice(line, "tvg-id");
if !tvg_id.is_empty() {
current_channel.id = tvg_id.to_string();
}
let tvg_logo = extract_attr_slice(line, "tvg-logo");
if !tvg_logo.is_empty() {
current_channel.logo = tvg_logo.to_string();
}
let group_title = extract_attr_slice(line, "group-title");
if !group_title.is_empty() {
current_channel.group = group_title.to_string();
}
if let Some(idx) = find_extinf_title_comma(line) {
current_channel.name = line[idx + 1..].trim().to_string();
}
} else if !line.starts_with('#') {
current_channel.stream_url = line.to_string();
if current_channel.id.is_empty() {
current_channel.id = current_channel.name.clone();
}
channels.push(std::mem::take(&mut current_channel));
}
}
channels
}
}
fn extract_attr_slice<'a>(line: &'a str, attr_name: &str) -> &'a str {
let bytes = line.as_bytes();
let name_bytes = attr_name.as_bytes();
let mut i = 0;
while i + name_bytes.len() + 2 <= bytes.len() {
if &bytes[i..i + name_bytes.len()] == name_bytes {
let next_byte = bytes[i + name_bytes.len()];
if next_byte == b'=' {
let quote = bytes[i + name_bytes.len() + 1];
if quote == b'"' || quote == b'\'' {
let start = i + name_bytes.len() + 2;
if let Some(end_rel) = bytes[start..].iter().position(|&b| b == quote) {
return &line[start..start + end_rel];
}
}
}
}
i += 1;
}
""
}
fn find_extinf_title_comma(line: &str) -> Option<usize> {
let mut in_quote: Option<char> = None;
for (idx, ch) in line.char_indices() {
match in_quote {
Some(quote) if ch == quote => in_quote = None,
None if ch == '"' || ch == '\'' => in_quote = Some(ch),
None if ch == ',' => return Some(idx),
_ => {}
}
}
line.find(',')
}
fn cache_filename(raw: &str) -> String {
format!("{}.m3u", crate::cache::md5_hex(raw))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_m3u_double_and_single_quotes() {
let parser = M3UParser::new();
let content = r#"#EXTM3U
#EXTINF:-1 tvg-id="cnn.us" tvg-logo="http://logo.png/cnn.png" group-title="News",CNN HD
http://example.com/cnn.m3u8
#EXTINF:-1 tvg-id='bbc.uk' tvg-logo='http://logo.png/bbc.png' group-title='News',BBC World News
http://example.com/bbc.m3u8
#EXTINF:-1,Discovery Channel
http://example.com/discovery.m3u8
"#;
let channels = parser.parse_m3u(content);
assert_eq!(channels.len(), 3);
assert_eq!(channels[0].id, "cnn.us");
assert_eq!(channels[0].name, "CNN HD");
assert_eq!(channels[0].logo, "http://logo.png/cnn.png");
assert_eq!(channels[0].group, "News");
assert_eq!(channels[0].stream_url, "http://example.com/cnn.m3u8");
assert_eq!(channels[1].id, "bbc.uk");
assert_eq!(channels[1].name, "BBC World News");
assert_eq!(channels[1].logo, "http://logo.png/bbc.png");
assert_eq!(channels[1].group, "News");
assert_eq!(channels[1].stream_url, "http://example.com/bbc.m3u8");
assert_eq!(channels[2].id, "Discovery Channel");
assert_eq!(channels[2].name, "Discovery Channel");
assert_eq!(channels[2].group, "");
assert_eq!(channels[2].stream_url, "http://example.com/discovery.m3u8");
}
#[test]
fn test_parse_m3u_title_with_commas_and_quoted_attributes() {
let parser = M3UParser::new();
let content = r#"#EXTM3U
#EXTINF:-1 tvg-id="cnn.us" group-title="News, International",CNN, The Worldwide News Leader
http://example.com/cnn.m3u8
#EXTINF:0,Movie Channel, HD (US), 24/7
http://example.com/movie.m3u8
"#;
let channels = parser.parse_m3u(content);
assert_eq!(channels.len(), 2);
assert_eq!(channels[0].name, "CNN, The Worldwide News Leader");
assert_eq!(channels[0].group, "News, International");
assert_eq!(channels[1].name, "Movie Channel, HD (US), 24/7");
}
#[tokio::test]
async fn test_load_channels_local_file_size_limit() {
let temp_dir = std::env::temp_dir().join(format!("mb_test_m3u_{}", std::process::id()));
std::fs::create_dir_all(&temp_dir).unwrap();
let file_path = temp_dir.join("oversized.m3u");
let file = std::fs::File::create(&file_path).unwrap();
file.set_len((MAX_PLAYLIST_BYTES + 1) as u64).unwrap();
let parser = M3UParser::new();
let result = parser.fetch_playlist(file_path.to_str().unwrap()).await;
assert!(result.is_err());
assert!(
result
.unwrap_err()
.to_string()
.contains("maximum 15MB size limit")
);
let _ = std::fs::remove_dir_all(&temp_dir);
}
#[test]
fn test_parse_m3u_handles_utf8_bom_and_stream_inf_headers() {
let parser = M3UParser::new();
let content = "\u{feff}#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=2500000\n#EXTINF:-1 tvg-id=\"sp1\" group-title=\"Sports\",Sports Live\n#EXTVLCOPT:http-user-agent=CustomUA\nhttps://live.example.com/sports.m3u8\n";
let channels = parser.parse_m3u(content);
assert_eq!(channels.len(), 1);
assert_eq!(channels[0].id, "sp1");
assert_eq!(channels[0].name, "Sports Live");
assert_eq!(channels[0].group, "Sports");
assert_eq!(
channels[0].stream_url,
"https://live.example.com/sports.m3u8"
);
}
}