Skip to content

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

12.0 KB
Raw Blame
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::Path;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FavoriteItem {
    pub provider: String,
    pub subject_id: String,
    pub title: String,
    pub cover_url: Option<String>,
    pub stype: i64,
    pub release_year: String,
    pub added_at: u64,
}

impl FavoriteItem {
    pub fn from_details(provider: &str, details: &crate::models::MediaDetails) -> 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 now = 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,
            added_at: now,
        }
    }

    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: 0,
            episode: 1,
            provider: crate::models::ProviderKind::parse(&self.provider)
                .unwrap_or(crate::models::ProviderKind::MovieBox),
        }
    }

    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,
        }
    }
}

#[derive(Default, Clone, Serialize, Deserialize)]
pub struct FavoritesManager {
    #[serde(default)]
    pub items: Vec<FavoriteItem>,
    #[serde(skip)]
    id_index: std::collections::HashSet<String>,
}

impl FavoritesManager {
    pub fn new() -> Self {
        match crate::config::favorites_path() {
            Some(path) => Self::load_from_path(&path),
            None => Self::default(),
        }
    }

    pub fn load_from_path(path: &Path) -> Self {
        if path.exists() {
            match fs::read_to_string(path) {
                Ok(content) => match serde_json::from_str::<Self>(&content) {
                    Ok(mut manager) => {
                        manager.rebuild_index();
                        return manager;
                    }
                    Err(e) => {
                        crate::config::rotate_corrupt_file(path, &format!("favorites ({e})"));
                    }
                },
                Err(e) => {
                    log::warn!(
                        "failed to read favorites from {}: {e}",
                        crate::logging::sanitize_path(path)
                    );
                }
            }
        }
        Self::default()
    }

    pub fn save(&self) {
        if let Some(path) = crate::config::favorites_path() {
            self.save_to_path(&path);
        }
    }

    pub fn save_to_path(&self, path: &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 favorites: {error}");
            }
        }
    }

    pub fn rebuild_index(&mut self) {
        self.id_index.clear();
        for item in &self.items {
            let prov_canonical = crate::providers::models::ProviderKind::parse(&item.provider)
                .map(|p| p.cache_key().to_string())
                .unwrap_or_else(|| item.provider.trim().to_ascii_lowercase());
            self.id_index.insert(format!(
                "{}:{}:{}",
                prov_canonical, item.subject_id, item.stype
            ));
        }
    }

    pub fn is_favorite(&self, identity: &crate::models::SubjectIdentity<'_>) -> bool {
        if !identity.subject_id.is_empty() {
            let prov_canonical = crate::providers::models::ProviderKind::parse(identity.provider)
                .map(|p| p.cache_key().to_string())
                .unwrap_or_else(|| identity.provider.trim().to_ascii_lowercase());
            let key = format!(
                "{}:{}:{}",
                prov_canonical, identity.subject_id, identity.stype
            );
            if self.id_index.contains(key.as_str()) {
                return true;
            }
        }
        self.items
            .iter()
            .any(|item| item.identity().matches(identity))
    }
    pub fn toggle(&mut self, item: FavoriteItem) -> bool {
        let now_favorited = if let Some(pos) = self
            .items
            .iter()
            .position(|existing| existing.identity().matches(&item.identity()))
        {
            self.items.remove(pos);
            false
        } else {
            self.items.push(item);
            true
        };
        self.rebuild_index();
        self.save();
        now_favorited
    }

    pub fn remove(&mut self, identity: &crate::models::SubjectIdentity<'_>) {
        self.items.retain(|item| !item.identity().matches(identity));
        self.rebuild_index();
        self.save();
    }

    pub fn clear(&mut self) {
        self.items.clear();
        self.rebuild_index();
        self.save();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    fn dummy_item(
        provider: &str,
        subject_id: &str,
        title: &str,
        stype: i64,
        release_year: &str,
    ) -> FavoriteItem {
        FavoriteItem {
            provider: provider.to_string(),
            subject_id: subject_id.to_string(),
            title: title.to_string(),
            cover_url: None,
            stype,
            release_year: release_year.to_string(),
            added_at: 1700000000,
        }
    }

    #[test]
    fn test_toggle_idempotency() {
        let mut manager = FavoritesManager::default();
        let item = dummy_item("moviebox", "mb_1", "Dune", 1, "2021");

        assert!(manager.toggle(item.clone()));
        assert_eq!(manager.items.len(), 1);

        assert!(!manager.toggle(item.clone()));
        assert!(manager.items.is_empty());

        assert!(manager.toggle(item));
        assert_eq!(manager.items.len(), 1);
    }

    #[test]
    fn test_is_favorite_identity_dedup() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_1", "Breaking Bad", 2, "2008"));

        let target = crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "mb_1",
            title: "Breaking Bad",
            stype: 2,
            release_year: "2008",
        };
        assert!(manager.is_favorite(&target));

        let different_series = crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "mb_2",
            title: "Breaking Bad",
            stype: 1,
            release_year: "2008",
        };
        assert!(!manager.is_favorite(&different_series));
    }

    #[test]
    fn test_remakes_with_different_years_are_distinct() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "", "Halloween", 1, "1978"));

        let remake = crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "",
            title: "Halloween",
            stype: 1,
            release_year: "2018",
        };
        assert!(!manager.is_favorite(&remake));
    }

    #[test]
    fn test_movie_vs_series_same_title_distinct() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_home_1", "Home", 1, "2015"));

        let series = crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "mb_home_2",
            title: "Home",
            stype: 2,
            release_year: "2020",
        };
        assert!(!manager.is_favorite(&series));
    }

    #[test]
    fn test_same_title_across_providers_distinct() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_1", "Dune", 1, "2021"));

        let addon = crate::models::SubjectIdentity {
            provider: "addons",
            subject_id: "tt1160419",
            title: "Dune",
            stype: 1,
            release_year: "2021",
        };
        assert!(!manager.is_favorite(&addon));
    }

    #[test]
    fn test_empty_subject_id_fallback() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "", "Inception", 1, "2010"));

        let same = crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "",
            title: "Inception",
            stype: 1,
            release_year: "2010",
        };
        assert!(manager.is_favorite(&same));
    }

    #[test]
    fn test_unstar_removal() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_1", "Dune", 1, "2021"));
        manager
            .items
            .push(dummy_item("moviebox", "mb_2", "Arrival", 1, "2016"));

        manager.remove(&crate::models::SubjectIdentity {
            provider: "moviebox",
            subject_id: "mb_1",
            title: "Dune",
            stype: 1,
            release_year: "2021",
        });

        assert_eq!(manager.items.len(), 1);
        assert_eq!(manager.items[0].subject_id, "mb_2");
    }

    #[test]
    fn test_clear() {
        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_1", "Dune", 1, "2021"));
        manager.clear();
        assert!(manager.items.is_empty());
    }

    #[test]
    fn test_persistence_roundtrip() {
        let temp_dir = std::env::temp_dir().join(format!(
            "mb_test_favorites_{}_roundtrip",
            std::process::id()
        ));
        std::fs::create_dir_all(&temp_dir).unwrap();
        let path = temp_dir.join("favorites.json");

        let mut manager = FavoritesManager::default();
        manager
            .items
            .push(dummy_item("moviebox", "mb_1", "Dune", 1, "2021"));
        manager.save_to_path(&path);

        let loaded = FavoritesManager::load_from_path(&path);
        assert_eq!(loaded.items.len(), 1);
        assert_eq!(loaded.items[0].subject_id, "mb_1");

        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_corrupt_file_recovery() {
        let temp_dir =
            std::env::temp_dir().join(format!("mb_test_favorites_{}_corrupt", std::process::id()));
        std::fs::create_dir_all(&temp_dir).unwrap();
        let path = temp_dir.join("favorites.json");
        std::fs::write(&path, "not valid json").unwrap();

        let loaded = FavoritesManager::load_from_path(&path);
        assert!(loaded.items.is_empty());
        assert!(!path.exists());
        let corrupt_exists = std::fs::read_dir(&temp_dir)
            .unwrap()
            .flatten()
            .any(|e| e.file_name().to_string_lossy().contains("corrupt"));
        assert!(corrupt_exists, "expected .corrupt backup file");

        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_no_cap_on_favorites_count() {
        let mut manager = FavoritesManager::default();
        for i in 0..250 {
            manager.items.push(dummy_item(
                "moviebox",
                &format!("mb_{i}"),
                "Title",
                1,
                "2020",
            ));
        }
        assert_eq!(manager.items.len(), 250);
    }
}