Skip to content

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

26.3 KB
Raw Blame
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::fs;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WatchHistoryItem {
    pub provider: String,
    pub subject_id: String,
    pub title: String,
    pub cover_url: Option<String>,
    pub stype: i64,
    pub release_year: String,
    pub season: usize,
    pub episode: usize,
    pub timestamp: u64,
    #[serde(default)]
    pub duration_seconds: Option<u64>,
    #[serde(default)]
    pub progress_seconds: u64,
    #[serde(default)]
    pub completed: bool,
    #[serde(default)]
    pub stream_filename: Option<String>,
}

impl WatchHistoryItem {
    pub fn from_details(
        provider: &str,
        details: &crate::models::MediaDetails,
        season: usize,
        episode: usize,
    ) -> Self {
        let title = crate::providers::moviebox::clean_moviebox_title(&details.title);
        let title = if title.trim().is_empty() {
            details.title.clone()
        } else {
            title.to_string()
        };
        let stype = if details.is_series() { 2 } else { 1 };
        let release_year = details.year.clone().unwrap_or_default();
        let cover_url = details.cover_url().map(|s| s.to_string());
        let duration_seconds = details
            .duration
            .as_deref()
            .and_then(crate::tui::text::parse_duration_seconds);
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        Self {
            provider: provider.to_string(),
            subject_id: details.id.value.clone(),
            title,
            cover_url,
            stype,
            release_year,
            season,
            episode,
            timestamp,
            duration_seconds,
            progress_seconds: 0,
            completed: false,
            stream_filename: None,
        }
    }

    pub fn identity(&self) -> crate::models::SubjectIdentity<'_> {
        crate::models::SubjectIdentity {
            provider: &self.provider,
            subject_id: &self.subject_id,
            title: &self.title,
            stype: self.stype,
            release_year: &self.release_year,
        }
    }

    pub fn is_in_progress(&self) -> bool {
        if self.completed {
            return false;
        }
        if self.progress_seconds < 30 {
            return false;
        }
        let Some(dur) = self.duration_seconds else {
            return false;
        };
        if dur == 0 || self.progress_seconds >= (dur as f64 * 0.90) as u64 {
            return false;
        }
        true
    }

    pub fn progress_percentage(&self) -> Option<f32> {
        self.duration_seconds
            .filter(|&d| d > 0)
            .map(|d| ((self.progress_seconds as f32 / d as f32) * 100.0).clamp(0.0, 100.0))
    }

    pub fn progress_bar_parts(&self, width: usize) -> (String, String) {
        let pct = self.progress_percentage().unwrap_or(0.0) / 100.0;
        let filled = if pct > 0.0 {
            ((width as f32 * pct).round() as usize).max(1).min(width)
        } else {
            0
        };
        let empty = width.saturating_sub(filled);
        ("━".repeat(filled), "─".repeat(empty))
    }

    pub fn progress_bar(&self, width: usize) -> String {
        let (filled, empty) = self.progress_bar_parts(width);
        format!("{filled}{empty}")
    }

    pub fn formatted_progress(&self) -> String {
        let pos = crate::tui::text::format_duration(self.progress_seconds);
        if let Some(dur) = self.duration_seconds {
            if dur > 0 {
                return format!("{} / {}", pos, crate::tui::text::format_duration(dur));
            }
        }
        pos
    }

    pub fn formatted_remaining(&self) -> Option<String> {
        let dur = self.duration_seconds?;
        if dur <= self.progress_seconds {
            return None;
        }
        let remaining = dur.saturating_sub(self.progress_seconds);
        if remaining < 60 {
            Some("< 1m left".to_string())
        } else if remaining < 3600 {
            Some(format!("{}m left", remaining / 60))
        } else {
            let h = remaining / 3600;
            let m = (remaining % 3600) / 60;
            if m == 0 {
                Some(format!("{h}h left"))
            } else {
                Some(format!("{h}h {m}m left"))
            }
        }
    }

    pub fn formatted_relative_time(&self) -> String {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        if self.timestamp == 0 || now < self.timestamp {
            return "recently".to_string();
        }
        let delta = now - self.timestamp;
        if delta < 60 {
            "just now".to_string()
        } else if delta < 3600 {
            format!("{}m ago", delta / 60)
        } else if delta < 86400 {
            format!("{}h ago", delta / 3600)
        } else if delta < 172800 {
            "Yesterday".to_string()
        } else if delta < 604800 {
            format!("{}d ago", delta / 86400)
        } else {
            format!("{}w ago", delta / 604800)
        }
    }

    pub fn to_search_result(&self) -> crate::models::SearchResult {
        crate::models::SearchResult {
            id: self.subject_id.clone(),
            title: self.title.clone(),
            stype: self.stype,
            release_year: self.release_year.clone(),
            cover_url: self.cover_url.clone(),
            season: self.season,
            episode: self.episode.max(1),
            provider: crate::models::ProviderKind::parse(&self.provider)
                .unwrap_or(crate::models::ProviderKind::MovieBox),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PendingPlaybackState {
    pub provider: String,
    pub subject_id: String,
    pub season: usize,
    pub episode: usize,
    pub progress_seconds: u64,
    pub duration_seconds: Option<u64>,
    pub completed: bool,
    pub timestamp: u64,
    #[serde(default)]
    pub title: Option<String>,
    #[serde(default)]
    pub cover_url: Option<String>,
    #[serde(default)]
    pub stype: Option<i64>,
    #[serde(default)]
    pub release_year: Option<String>,
    #[serde(default)]
    pub stream_filename: Option<String>,
}

impl PendingPlaybackState {
    pub fn from_item(
        item: &WatchHistoryItem,
        progress: u64,
        duration: Option<u64>,
        completed: bool,
    ) -> Self {
        Self {
            provider: item.provider.clone(),
            subject_id: item.subject_id.clone(),
            season: item.season,
            episode: item.episode,
            progress_seconds: progress,
            duration_seconds: duration,
            completed,
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs(),
            title: Some(item.title.clone()),
            cover_url: item.cover_url.clone(),
            stype: Some(item.stype),
            release_year: Some(item.release_year.clone()),
            stream_filename: item.stream_filename.clone(),
        }
    }
}

#[derive(Default, Clone, Serialize, Deserialize)]
pub struct HistoryManager {
    #[serde(default)]
    watched: HashSet<String>,
    #[serde(default)]
    pub recent: Vec<WatchHistoryItem>,
}

impl HistoryManager {
    pub fn new() -> Self {
        let mut history = if let Some(path) = crate::config::history_path() {
            if path.exists() {
                if let Ok(content) = fs::read_to_string(&path) {
                    if let Ok(mut hist) = serde_json::from_str::<Self>(&content) {
                        hist.hydrate_watched_index();
                        hist
                    } else {
                        crate::config::rotate_corrupt_file(&path, "watch history");
                        Self::default()
                    }
                } else {
                    Self::default()
                }
            } else {
                Self::default()
            }
        } else {
            Self::default()
        };

        history.reconcile_pending_playback_states();
        history
    }

    pub fn save(&self) {
        if let Some(path) = crate::config::history_path() {
            if let Ok(content) = serde_json::to_string(self) {
                if let Err(error) = crate::cache::atomic_write_file(&path, content.as_bytes()) {
                    log::warn!("failed to save watch history: {error}");
                }
            }
        }
    }

    fn same_provider(a: &str, b: &str) -> bool {
        crate::providers::models::ProviderKind::parse(a)
            .zip(crate::providers::models::ProviderKind::parse(b))
            .map_or_else(
                || a.trim().eq_ignore_ascii_case(b.trim()),
                |(p1, p2)| p1 == p2,
            )
    }

    fn key(provider: &str, subject_id: &str, season: usize, episode: usize) -> String {
        let canon_provider = crate::providers::models::ProviderKind::parse(provider)
            .map(|p| p.cache_key())
            .unwrap_or(provider);
        format!("{canon_provider}::{subject_id}::{season}::{episode}")
    }

    pub fn is_same_show(a: &WatchHistoryItem, b: &WatchHistoryItem) -> bool {
        a.identity().matches(&b.identity())
    }

    fn hydrate_watched_index(&mut self) {
        if self.watched.is_empty() {
            self.watched = self
                .recent
                .iter()
                .filter(|item| item.completed)
                .map(|item| Self::key(&item.provider, &item.subject_id, item.season, item.episode))
                .collect();
        } else {
            for item in &mut self.recent {
                let key = Self::key(&item.provider, &item.subject_id, item.season, item.episode);
                if self.watched.contains(&key) {
                    item.completed = true;
                } else if item.completed {
                    self.watched.insert(key);
                }
            }
        }
        self.consolidate_recent();
    }

    fn consolidate_recent(&mut self) {
        let original_len = self.recent.len();
        let mut consolidated: Vec<WatchHistoryItem> = Vec::new();

        let mut sorted = self.recent.clone();
        sorted.sort_by_key(|item| item.timestamp);

        for item in sorted {
            if let Some(existing) = consolidated
                .iter_mut()
                .find(|e| Self::is_same_show(e, &item))
            {
                if item.timestamp >= existing.timestamp {
                    let cover = item
                        .cover_url
                        .clone()
                        .or_else(|| existing.cover_url.clone());
                    *existing = item;
                    existing.cover_url = cover;
                } else if existing.cover_url.is_none() && item.cover_url.is_some() {
                    existing.cover_url = item.cover_url.clone();
                }
            } else {
                consolidated.push(item);
            }
        }

        self.recent = consolidated;
        if self.recent.len() != original_len {
            self.save();
        }
    }

    pub fn get_item(
        &self,
        provider: &str,
        subject_id: &str,
        season: usize,
        episode: usize,
        title: Option<&str>,
    ) -> Option<&WatchHistoryItem> {
        self.recent.iter().find(|i| {
            let same_provider = Self::same_provider(&i.provider, provider);

            if same_provider && i.subject_id == subject_id {
                if i.stype == 1 {
                    return true;
                }
                if i.season == season && i.episode == episode {
                    return true;
                }
            }

            if let Some(t) = title {
                let clean_i = crate::providers::moviebox::clean_moviebox_title(&i.title);
                let clean_t = crate::providers::moviebox::clean_moviebox_title(t);
                if !clean_i.is_empty() && clean_i.eq_ignore_ascii_case(clean_t) {
                    if i.stype == 1 {
                        return true;
                    }
                    if i.season == season && i.episode == episode {
                        return true;
                    }
                }
            }

            false
        })
    }

    pub fn mark_watched(&mut self, mut item: WatchHistoryItem) {
        item.completed = true;
        let key = Self::key(&item.provider, &item.subject_id, item.season, item.episode);
        self.watched.insert(key);

        if item.cover_url.is_none() {
            if let Some(existing) = self
                .recent
                .iter()
                .find(|i| Self::is_same_show(i, &item))
                .and_then(|i| i.cover_url.clone())
            {
                item.cover_url = Some(existing);
            }
        }

        self.recent.retain(|i| !Self::is_same_show(i, &item));
        self.recent.push(item);

        if self.recent.len() > 100 {
            let excess = self.recent.len() - 100;
            self.recent.drain(0..excess);
        }
        self.save();
    }

    pub fn update_progress(
        &mut self,
        mut item: WatchHistoryItem,
        progress: u64,
        duration: Option<u64>,
        completed: bool,
    ) {
        item.progress_seconds = progress;
        item.duration_seconds = duration;
        item.completed = completed;
        item.timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        let key = Self::key(&item.provider, &item.subject_id, item.season, item.episode);
        if completed {
            self.watched.insert(key);
        } else {
            self.watched.remove(&key);
        }

        if let Some(existing) = self.recent.iter().find(|i| Self::is_same_show(i, &item)) {
            if item.cover_url.is_none() {
                item.cover_url = existing.cover_url.clone();
            }
            if existing.season == item.season
                && existing.episode == item.episode
                && existing.progress_seconds >= progress
                && (existing.timestamp >= item.timestamp
                    || item.timestamp.saturating_sub(existing.timestamp) < 60)
            {
                return;
            }
        }

        self.recent.retain(|i| !Self::is_same_show(i, &item));
        self.recent.push(item);

        if self.recent.len() > 100 {
            let excess = self.recent.len() - 100;
            self.recent.drain(0..excess);
        }
        self.save();
    }
    pub fn record_start(&mut self, item: &WatchHistoryItem, start_pos: u64) {
        let mut new_item = item.clone();
        if let Some(existing) = self.recent.iter().find(|i| Self::is_same_show(i, item)) {
            if new_item.cover_url.is_none() {
                new_item.cover_url = existing.cover_url.clone();
            }
            if existing.season == new_item.season && existing.episode == new_item.episode {
                new_item.progress_seconds = existing.progress_seconds.max(start_pos);
                new_item.duration_seconds = existing.duration_seconds.or(new_item.duration_seconds);
                new_item.completed = existing.completed;
            } else {
                new_item.progress_seconds = start_pos;
            }
        } else {
            new_item.progress_seconds = start_pos;
        }
        new_item.timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        self.recent.retain(|i| !Self::is_same_show(i, &new_item));
        self.recent.push(new_item);

        if self.recent.len() > 100 {
            let excess = self.recent.len() - 100;
            self.recent.drain(0..excess);
        }
        self.save();
    }

    pub fn remove(&mut self, provider: &str, subject_id: &str, season: usize, episode: usize) {
        let key = Self::key(provider, subject_id, season, episode);
        self.watched.remove(&key);
        self.recent.retain(|i| {
            let same_provider = Self::same_provider(&i.provider, provider);
            !(same_provider
                && i.subject_id == subject_id
                && i.season == season
                && i.episode == episode)
        });
        self.save();
    }

    pub fn clear(&mut self) {
        self.watched.clear();
        self.recent.clear();
        self.save();
    }

    pub fn update_cover_url(&mut self, subject_id: &str, cover_url: &str) {
        let mut modified = false;
        for item in &mut self.recent {
            if item.subject_id == subject_id && item.cover_url.is_none() {
                item.cover_url = Some(cover_url.to_string());
                modified = true;
            }
        }
        if modified {
            self.save();
        }
    }

    pub fn is_watched(
        &self,
        provider: &str,
        subject_id: &str,
        season: usize,
        episode: usize,
    ) -> bool {
        let key = Self::key(provider, subject_id, season, episode);
        if self.watched.contains(&key) {
            return true;
        }
        if let Some(item) = self.get_item(provider, subject_id, season, episode, None) {
            return item.completed;
        }
        false
    }

    pub fn reconcile_pending_playback_states(&mut self) {
        if let Some(dir) = crate::config::playback_state_dir() {
            if self.reconcile_from_dir(&dir) {
                self.save();
            }
        }
    }

    pub fn reconcile_from_dir(&mut self, dir: &std::path::Path) -> bool {
        let Ok(entries) = fs::read_dir(dir) else {
            return false;
        };

        let mut pending_files = Vec::new();
        for entry in entries.flatten() {
            let path = entry.path();
            if path.extension().and_then(|e| e.to_str()) == Some("json") {
                if let Ok(content) = fs::read_to_string(&path) {
                    if let Ok(state) = serde_json::from_str::<PendingPlaybackState>(&content) {
                        pending_files.push((path, state));
                    }
                }
            }
        }

        pending_files.sort_by_key(|(_, s)| s.timestamp);

        let mut modified = false;
        for (path, state) in pending_files {
            let key = Self::key(
                &state.provider,
                &state.subject_id,
                state.season,
                state.episode,
            );

            if state.completed {
                if self.watched.insert(key.clone()) {
                    modified = true;
                }
            }

            if let Some(existing) = self.recent.iter_mut().find(|i| {
                let same_provider = Self::same_provider(&i.provider, &state.provider);
                if !same_provider {
                    return false;
                }
                if i.subject_id == state.subject_id {
                    if i.stype == 1 {
                        return true;
                    }
                    return i.season == state.season && i.episode == state.episode;
                }
                false
            }) {
                existing.progress_seconds = state.progress_seconds;
                existing.duration_seconds = state.duration_seconds;
                existing.completed = state.completed;
                existing.timestamp = state.timestamp;
                if state.stream_filename.is_some() {
                    existing.stream_filename = state.stream_filename.clone();
                }
                if !existing.completed {
                    self.watched.remove(&key);
                }
                modified = true;
            } else if let Some(existing_series) = self.recent.iter_mut().find(|i| {
                let same_provider = Self::same_provider(&i.provider, &state.provider);
                same_provider && i.stype == 2 && i.subject_id == state.subject_id
            }) {
                if (state.season, state.episode)
                    >= (existing_series.season, existing_series.episode)
                    && state.timestamp >= existing_series.timestamp
                {
                    existing_series.season = state.season;
                    existing_series.episode = state.episode;
                    existing_series.progress_seconds = state.progress_seconds;
                    existing_series.duration_seconds = state.duration_seconds;
                    existing_series.completed = state.completed;
                    existing_series.timestamp = state.timestamp;
                    if state.stream_filename.is_some() {
                        existing_series.stream_filename = state.stream_filename.clone();
                    }
                    if !existing_series.completed {
                        self.watched.remove(&key);
                    }
                    modified = true;
                }
            } else if let Some(title) = state.title.filter(|t| !t.trim().is_empty()) {
                let new_item = WatchHistoryItem {
                    provider: state.provider.clone(),
                    subject_id: state.subject_id.clone(),
                    title,
                    cover_url: state.cover_url,
                    stype: state
                        .stype
                        .unwrap_or(if state.season > 0 || state.episode > 0 {
                            2
                        } else {
                            1
                        }),
                    release_year: state.release_year.unwrap_or_default(),
                    season: state.season,
                    episode: state.episode,
                    timestamp: state.timestamp,
                    duration_seconds: state.duration_seconds,
                    progress_seconds: state.progress_seconds,
                    completed: state.completed,
                    stream_filename: state.stream_filename,
                };
                if new_item.completed {
                    self.watched.insert(key);
                }
                self.recent.retain(|i| !Self::is_same_show(i, &new_item));
                self.recent.push(new_item);
                if self.recent.len() > 100 {
                    let excess = self.recent.len() - 100;
                    self.recent.drain(0..excess);
                }
                modified = true;
            }
            let _ = fs::remove_file(&path);
        }

        modified
    }
}

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

    fn dummy_item(
        provider: &str,
        subject_id: &str,
        title: &str,
        stype: i64,
        release_year: &str,
        season: usize,
        episode: usize,
    ) -> WatchHistoryItem {
        WatchHistoryItem {
            provider: provider.to_string(),
            subject_id: subject_id.to_string(),
            title: title.to_string(),
            cover_url: None,
            stype,
            release_year: release_year.to_string(),
            season,
            episode,
            timestamp: 1000,
            duration_seconds: Some(3600),
            progress_seconds: 1800,
            completed: false,
            stream_filename: None,
        }
    }

    #[test]
    fn test_is_same_show_canonical_identity() {
        let ep1 = dummy_item("moviebox", "mb_100", "Breaking Bad", 2, "2008", 1, 1);
        let ep2 = dummy_item("moviebox", "mb_100", "Breaking Bad", 2, "2008", 1, 2);
        assert!(HistoryManager::is_same_show(&ep1, &ep2));
    }

    #[test]
    fn test_is_same_show_movie_vs_series_differentiation() {
        let movie = dummy_item("moviebox", "mb_1", "Home", 1, "2015", 0, 0);
        let series = dummy_item("moviebox", "mb_2", "Home", 2, "2020", 1, 1);
        assert!(!HistoryManager::is_same_show(&movie, &series));
    }

    #[test]
    fn test_is_same_show_remakes_with_different_years() {
        let classic = dummy_item("moviebox", "mb_old", "Halloween", 1, "1978", 0, 0);
        let remake = dummy_item("moviebox", "mb_new", "Halloween", 1, "2018", 0, 0);
        assert!(!HistoryManager::is_same_show(&classic, &remake));
    }

    #[test]
    fn test_is_same_show_different_providers() {
        let mb = dummy_item("moviebox", "mb_1", "Dune", 1, "2021", 0, 0);
        let addon = dummy_item("addons", "tt1160419", "Dune", 1, "2021", 0, 0);
        assert!(!HistoryManager::is_same_show(&mb, &addon));
    }

    #[test]
    fn test_is_same_show_fallback_when_id_empty() {
        let a = dummy_item("moviebox", "", "Inception", 1, "2010", 0, 0);
        let b = dummy_item("moviebox", "", "Inception", 1, "2010", 0, 0);
        assert!(HistoryManager::is_same_show(&a, &b));

        let c = dummy_item("moviebox", "", "Inception", 1, "2020", 0, 0);
        assert!(!HistoryManager::is_same_show(&a, &c));
    }

    #[test]
    fn test_reconciliation_preserves_completed_episodes_when_recent_advanced() {
        let mut manager = HistoryManager {
            recent: vec![dummy_item("moviebox", "mb_series", "Show", 2, "2024", 1, 2)],
            watched: HashSet::new(),
        };

        let temp_dir = std::env::temp_dir().join(format!("mb_test_hist_{}", std::process::id()));
        std::fs::create_dir_all(&temp_dir).unwrap();

        let state_file = temp_dir.join("moviebox_mb_series_1_1.json");
        let state = PendingPlaybackState {
            provider: "moviebox".to_string(),
            subject_id: "mb_series".to_string(),
            season: 1,
            episode: 1,
            progress_seconds: 3600,
            duration_seconds: Some(3600),
            completed: true,
            timestamp: 2000,
            title: None,
            cover_url: None,
            stype: None,
            release_year: None,
            stream_filename: None,
        };
        std::fs::write(&state_file, serde_json::to_string(&state).unwrap()).unwrap();

        let modified = manager.reconcile_from_dir(&temp_dir);
        assert!(modified);
        assert!(manager.is_watched("moviebox", "mb_series", 1, 1));
        assert_eq!(manager.recent.first().unwrap().episode, 2);
        assert!(!state_file.exists());

        let _ = std::fs::remove_dir_all(&temp_dir);
    }
    #[test]
    fn test_history_item_live_stream_without_duration_not_in_progress() {
        let mut item = dummy_item("tv", "live_1", "BBC News", 1, "", 0, 0);
        item.duration_seconds = None;
        item.progress_seconds = 600;
        assert!(!item.is_in_progress());

        item.duration_seconds = Some(0);
        assert!(!item.is_in_progress());

        item.duration_seconds = Some(3600);
        assert!(item.is_in_progress());
    }
}