Skip to content

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

17.7 KB
Raw Blame
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddonResource {
    Simple(String),
    Detailed {
        name: String,
        types: Option<Vec<String>>,
        #[serde(rename = "idPrefixes")]
        id_prefixes: Option<Vec<String>>,
    },
}

impl AddonResource {
    pub fn name(&self) -> &str {
        match self {
            Self::Simple(name) => name.as_str(),
            Self::Detailed { name, .. } => name.as_str(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CatalogExtra {
    pub name: String,
    #[serde(rename = "isRequired", default)]
    pub is_required: bool,
    pub options: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CatalogDefinition {
    #[serde(rename = "type")]
    pub r#type: String,
    pub id: String,
    pub name: Option<String>,
    #[serde(default)]
    pub extra: Vec<CatalogExtra>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddonManifest {
    pub id: String,
    pub name: String,
    pub version: Option<String>,
    pub description: Option<String>,
    #[serde(default)]
    pub resources: Vec<AddonResource>,
    #[serde(default)]
    pub types: Vec<String>,
    #[serde(default)]
    pub catalogs: Vec<CatalogDefinition>,
    #[serde(rename = "idPrefixes", default)]
    pub id_prefixes: Vec<String>,
    pub logo: Option<String>,
    pub background: Option<String>,
}

impl AddonManifest {
    pub fn provides_resource(&self, res_name: &str) -> bool {
        self.resources
            .iter()
            .any(|r| r.name().eq_ignore_ascii_case(res_name))
    }

    pub fn provides_stream(&self) -> bool {
        self.provides_resource("stream")
    }

    pub fn provides_meta(&self) -> bool {
        self.provides_resource("meta")
    }

    pub fn provides_catalog(&self) -> bool {
        self.provides_resource("catalog") || !self.catalogs.is_empty()
    }
}

fn de_opt_string_or_number<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct StringOrNumberVisitor;
    impl<'de> serde::de::Visitor<'de> for StringOrNumberVisitor {
        type Value = Option<String>;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a string, number, or null")
        }

        fn visit_none<E>(self) -> Result<Self::Value, E> {
            Ok(None)
        }

        fn visit_unit<E>(self) -> Result<Self::Value, E> {
            Ok(None)
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> {
            if v.trim().is_empty() {
                Ok(None)
            } else {
                Ok(Some(v.trim().to_string()))
            }
        }

        fn visit_string<E>(self, v: String) -> Result<Self::Value, E> {
            if v.trim().is_empty() {
                Ok(None)
            } else {
                Ok(Some(v.trim().to_string()))
            }
        }

        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> {
            Ok(Some(v.to_string()))
        }

        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> {
            Ok(Some(v.to_string()))
        }

        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> {
            Ok(Some(v.to_string()))
        }
    }

    deserializer.deserialize_any(StringOrNumberVisitor)
}

fn de_opt_usize_or_string<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct UsizeOrStringVisitor;
    impl<'de> serde::de::Visitor<'de> for UsizeOrStringVisitor {
        type Value = Option<usize>;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a usize, string, or null")
        }

        fn visit_none<E>(self) -> Result<Self::Value, E> {
            Ok(None)
        }

        fn visit_unit<E>(self) -> Result<Self::Value, E> {
            Ok(None)
        }

        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> {
            Ok(Some(v as usize))
        }

        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> {
            if v >= 0 {
                Ok(Some(v as usize))
            } else {
                Ok(None)
            }
        }

        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> {
            if v >= 0.0 {
                Ok(Some(v as usize))
            } else {
                Ok(None)
            }
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> {
            Ok(v.trim().parse::<usize>().ok())
        }

        fn visit_string<E>(self, v: String) -> Result<Self::Value, E> {
            Ok(v.trim().parse::<usize>().ok())
        }
    }

    deserializer.deserialize_any(UsizeOrStringVisitor)
}

fn de_string_or_vec<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct StringOrVecVisitor;

    impl<'de> serde::de::Visitor<'de> for StringOrVecVisitor {
        type Value = Vec<String>;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a string, sequence of strings, or sequence of objects")
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(v.split(',')
                .map(|s| s.trim().to_string())
                .filter(|s| !s.is_empty())
                .collect())
        }

        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(v.split(',')
                .map(|s| s.trim().to_string())
                .filter(|s| !s.is_empty())
                .collect())
        }

        fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
        where
            S: serde::de::SeqAccess<'de>,
        {
            let mut list = Vec::new();
            while let Some(val) = seq.next_element::<serde_json::Value>()? {
                if let Some(s) = val.as_str() {
                    let s_trim = s.trim();
                    if !s_trim.is_empty() {
                        list.push(s_trim.to_string());
                    }
                } else if let Some(name) = val.get("name").and_then(|n| n.as_str()) {
                    let n_trim = name.trim();
                    if !n_trim.is_empty() {
                        list.push(n_trim.to_string());
                    }
                }
            }
            Ok(list)
        }

        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(self)
        }

        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(vec![v.to_string()])
        }

        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(vec![v.to_string()])
        }

        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(vec![v.to_string()])
        }

        fn visit_none<E>(self) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(Vec::new())
        }

        fn visit_unit<E>(self) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            Ok(Vec::new())
        }
    }

    deserializer.deserialize_any(StringOrVecVisitor)
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MetaItem {
    pub id: String,
    #[serde(rename = "type", default)]
    pub r#type: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub title: Option<String>,
    pub poster: Option<String>,
    pub cover: Option<String>,
    pub description: Option<String>,
    pub overview: Option<String>,
    pub synopsis: Option<String>,
    #[serde(
        rename = "releaseInfo",
        default,
        deserialize_with = "de_opt_string_or_number"
    )]
    pub release_info: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub year: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub released: Option<String>,
    #[serde(
        rename = "imdbRating",
        default,
        deserialize_with = "de_opt_string_or_number"
    )]
    pub imdb_rating: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub rating: Option<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub genres: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub genre: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CatalogResponse {
    #[serde(default)]
    pub metas: Vec<MetaItem>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MetaVideo {
    #[serde(default)]
    pub id: Option<String>,
    pub title: Option<String>,
    pub name: Option<String>,
    #[serde(default, deserialize_with = "de_opt_usize_or_string")]
    pub season: Option<usize>,
    #[serde(default, deserialize_with = "de_opt_usize_or_string")]
    pub episode: Option<usize>,
    #[serde(default, deserialize_with = "de_opt_usize_or_string")]
    pub number: Option<usize>,
    pub released: Option<String>,
    pub thumbnail: Option<String>,
    pub overview: Option<String>,
    pub description: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MetaDetail {
    pub id: String,
    #[serde(rename = "type", default)]
    pub r#type: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub title: Option<String>,
    pub poster: Option<String>,
    pub cover: Option<String>,
    pub background: Option<String>,
    pub logo: Option<String>,
    pub description: Option<String>,
    pub overview: Option<String>,
    pub synopsis: Option<String>,
    #[serde(
        rename = "releaseInfo",
        default,
        deserialize_with = "de_opt_string_or_number"
    )]
    pub release_info: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub year: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub released: Option<String>,
    #[serde(
        rename = "imdbRating",
        default,
        deserialize_with = "de_opt_string_or_number"
    )]
    pub imdb_rating: Option<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub rating: Option<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub genres: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub genre: Vec<String>,
    #[serde(default, deserialize_with = "de_opt_string_or_number")]
    pub runtime: Option<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub cast: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub stars: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub director: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub directors: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub writer: Vec<String>,
    #[serde(default, deserialize_with = "de_string_or_vec")]
    pub writers: Vec<String>,
    #[serde(default)]
    pub videos: Vec<MetaVideo>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StreamBehaviorHints {
    #[serde(rename = "notWebReady", default)]
    pub not_web_ready: bool,
    #[serde(default)]
    pub headers: Option<HashMap<String, String>>,
    #[serde(rename = "videoSize")]
    pub video_size: Option<u64>,
    pub filename: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StreamItem {
    pub name: Option<String>,
    pub title: Option<String>,
    pub description: Option<String>,
    pub url: Option<String>,
    #[serde(rename = "behaviorHints")]
    pub behavior_hints: Option<StreamBehaviorHints>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InstalledAddon {
    pub manifest_url: String,
    pub name: String,
    pub version: Option<String>,
    pub description: Option<String>,
    pub enabled: bool,
    #[serde(default)]
    pub provides_catalog: bool,
    #[serde(default)]
    pub provides_meta: bool,
    #[serde(default)]
    pub provides_stream: bool,
    #[serde(default)]
    pub id_prefixes: Vec<String>,
    #[serde(default)]
    pub types: Vec<String>,
}

impl InstalledAddon {
    pub const CINEMETA_MANIFEST: &'static str = "https://v3-cinemeta.strem.io/manifest.json";

    pub fn cinemeta_default() -> Self {
        Self {
            manifest_url: Self::CINEMETA_MANIFEST.to_string(),
            name: "Cinemeta".to_string(),
            version: Some("3.0.14".to_string()),
            description: Some("Official Catalog and Metadata".to_string()),
            enabled: true,
            provides_catalog: true,
            provides_meta: true,
            provides_stream: false,
            id_prefixes: vec!["tt".to_string()],
            types: vec!["movie".to_string(), "series".to_string()],
        }
    }

    pub fn is_core(&self) -> bool {
        self.name.eq_ignore_ascii_case("cinemeta")
            || self.manifest_url.to_lowercase().contains("cinemeta")
    }

    pub fn from_manifest(manifest_url: String, manifest: &AddonManifest) -> Self {
        Self {
            manifest_url,
            name: manifest.name.clone(),
            version: manifest.version.clone(),
            description: manifest.description.clone(),
            enabled: true,
            provides_catalog: manifest.provides_catalog(),
            provides_meta: manifest.provides_meta(),
            provides_stream: manifest.provides_stream(),
            id_prefixes: manifest.id_prefixes.clone(),
            types: manifest.types.clone(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AddonCatalogTarget {
    pub label: String,
    pub addon_name: String,
    pub manifest_url: String,
    pub r#type: String,
    pub catalog_id: String,
}

pub fn curated_catalog_presets(addons: &[InstalledAddon]) -> Vec<AddonCatalogTarget> {
    let mut targets = Vec::new();
    let enabled_catalogs: Vec<&InstalledAddon> = addons
        .iter()
        .filter(|a| a.enabled && a.provides_catalog)
        .collect();

    let multi = enabled_catalogs.len() > 1;

    for addon in &enabled_catalogs {
        let suffix = if multi {
            format!(" ({})", addon.name)
        } else {
            String::new()
        };

        let has_movies =
            addon.types.is_empty() || addon.types.iter().any(|t| t.eq_ignore_ascii_case("movie"));
        let has_series =
            addon.types.is_empty() || addon.types.iter().any(|t| t.eq_ignore_ascii_case("series"));

        if has_movies {
            targets.push(AddonCatalogTarget {
                label: format!("Top Movies{suffix}"),
                addon_name: addon.name.clone(),
                manifest_url: addon.manifest_url.clone(),
                r#type: "movie".to_string(),
                catalog_id: "top".to_string(),
            });
        }
        if has_series {
            targets.push(AddonCatalogTarget {
                label: format!("Top Series{suffix}"),
                addon_name: addon.name.clone(),
                manifest_url: addon.manifest_url.clone(),
                r#type: "series".to_string(),
                catalog_id: "top".to_string(),
            });
        }
        if has_movies && addon.is_core() {
            targets.push(AddonCatalogTarget {
                label: format!("Top Rated Movies{suffix}"),
                addon_name: addon.name.clone(),
                manifest_url: addon.manifest_url.clone(),
                r#type: "movie".to_string(),
                catalog_id: "imdbRating".to_string(),
            });
        }
        if has_series && addon.is_core() {
            targets.push(AddonCatalogTarget {
                label: format!("Top Rated Series{suffix}"),
                addon_name: addon.name.clone(),
                manifest_url: addon.manifest_url.clone(),
                r#type: "series".to_string(),
                catalog_id: "imdbRating".to_string(),
            });
        }
        if targets.len() >= 6 {
            break;
        }
    }

    if targets.is_empty() {
        let cinemeta = InstalledAddon::cinemeta_default();
        targets.push(AddonCatalogTarget {
            label: "Top Movies".to_string(),
            addon_name: cinemeta.name.clone(),
            manifest_url: cinemeta.manifest_url.clone(),
            r#type: "movie".to_string(),
            catalog_id: "top".to_string(),
        });
        targets.push(AddonCatalogTarget {
            label: "Top Series".to_string(),
            addon_name: cinemeta.name.clone(),
            manifest_url: cinemeta.manifest_url.clone(),
            r#type: "series".to_string(),
            catalog_id: "top".to_string(),
        });
        targets.push(AddonCatalogTarget {
            label: "Top Rated Movies".to_string(),
            addon_name: cinemeta.name.clone(),
            manifest_url: cinemeta.manifest_url.clone(),
            r#type: "movie".to_string(),
            catalog_id: "imdbRating".to_string(),
        });
        targets.push(AddonCatalogTarget {
            label: "Top Rated Series".to_string(),
            addon_name: cinemeta.name.clone(),
            manifest_url: cinemeta.manifest_url.clone(),
            r#type: "series".to_string(),
            catalog_id: "imdbRating".to_string(),
        });
    }

    targets.truncate(6);
    targets
}