/*
    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
    Copyright (C) 2025 metamuffin <metamuffin.org>
*/
#![feature(array_try_map)]
pub mod api;
pub mod config;
pub mod helpers;
pub mod r#impl;
pub mod jhls;
pub mod seek_index;
pub mod stream;
pub mod user;

pub use chrono;

use bincode::{Decode, Encode};
use serde::{Deserialize, Serialize};
use std::{
    collections::{BTreeMap, BTreeSet},
    path::PathBuf,
};

#[derive(Clone, Copy, Debug, Encode, Decode, PartialEq, Eq, PartialOrd, Ord)]
pub struct NodeID(pub [u8; 32]);

pub enum NodeIDOrSlug {
    ID(NodeID),
    Slug(String),
}

#[derive(Debug, Clone, Deserialize, Serialize, Default, Encode, Decode)]
pub struct Node {
    #[serde(default)]
    pub slug: String,
    #[serde(default)]
    pub parents: BTreeSet<NodeID>,
    pub kind: NodeKind,
    pub poster: Option<Asset>,
    pub backdrop: Option<Asset>,
    pub title: Option<String>,
    pub subtitle: Option<String>,
    pub tagline: Option<String>,
    pub description: Option<String>,
    pub release_date: Option<i64>, // in unix millis
    pub index: Option<usize>,
    pub media: Option<MediaInfo>,
    #[serde(default)]
    pub ratings: BTreeMap<Rating, f64>,
    pub federated: Option<String>,
    #[serde(default)]
    pub tags: BTreeSet<String>,
    #[serde(default)]
    pub people: BTreeMap<PeopleGroup, Vec<Appearance>>,
    #[serde(default)]
    pub external_ids: BTreeMap<String, String>,
    #[serde(default)]
    pub visibility: Visibility,
    #[serde(default)]
    pub storage_size: u64,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Encode, Decode)]
pub struct Asset(pub String);

#[derive(Debug, Clone, Deserialize, Serialize, Default, Encode, Decode)]
pub struct Appearance {
    #[serde(default)]
    pub jobs: Vec<String>,
    #[serde(default)]
    pub characters: Vec<String>,
    pub person: Person,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default, Encode, Decode)]
pub struct Person {
    pub name: String,
    pub headshot: Option<Asset>,
    pub ids: ObjectIds,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default, Encode, Decode)]
pub struct ObjectIds {
    pub trakt: Option<u64>,
    pub slug: Option<String>,
    pub imdb: Option<String>,
    pub tmdb: Option<u64>,
    pub omdb: Option<u64>,
    pub tvdb: Option<u64>,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Encode, Decode)]
#[serde(rename_all = "snake_case")]
pub enum PeopleGroup {
    Cast,
    Writing,
    Directing,
    Art,
    Sound,
    Camera,
    Lighting,
    Crew,
    Editing,
    Production,
    Vfx,
    CostumeMakeup,
    CreatedBy,
}

#[derive(
    Debug,
    Clone,
    Copy,
    Deserialize,
    Serialize,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Encode,
    Decode,
    Default,
)]
#[serde(rename_all = "snake_case")]
pub enum Visibility {
    Hidden,
    Reduced,
    #[default]
    Visible,
}

#[derive(
    Debug,
    Clone,
    Copy,
    Deserialize,
    Serialize,
    PartialEq,
    Eq,
    Default,
    Encode,
    Decode,
    PartialOrd,
    Ord,
)]
#[serde(rename_all = "snake_case")]
pub enum NodeKind {
    #[default]
    Unknown,
    Movie,
    Video,
    Music,
    ShortFormVideo,
    Collection,
    Channel,
    Show,
    Series,
    Season,
    Episode,
}

#[derive(Debug, Clone, Deserialize, Serialize, Encode, Decode)]
#[serde(rename_all = "snake_case")]
pub enum TrackSource {
    Local(Asset),
    Remote(usize),
}

pub type TrackID = usize;

#[derive(Debug, Clone, Deserialize, Serialize, Hash, Encode, Decode)]
pub struct LocalTrack {
    pub path: PathBuf,
    pub track: TrackID,
    pub codec_private: Option<Vec<u8>>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Encode, Decode)]
pub struct MediaInfo {
    pub duration: f64, // in seconds
    pub tracks: Vec<SourceTrack>,
    #[serde(default)]
    pub chapters: Vec<Chapter>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default, Encode, Decode)]
pub struct Chapter {
    pub time_start: Option<f64>,
    pub time_end: Option<f64>,
    pub labels: Vec<(String, String)>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Encode, Decode)]
pub struct SourceTrack {
    pub source: TrackSource,
    pub kind: SourceTrackKind,
    pub name: String,
    pub codec: String,
    pub language: String,
    pub default_duration: Option<u64>,
    pub seek_pre_roll: u64,
    pub codec_delay: u64,
    pub flag_lacing: u64,
    #[serde(default)]
    pub federated: Vec<String>,
}

#[derive(
    Debug, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash, Encode, Decode,
)]
#[serde(rename_all = "snake_case")]
pub enum Rating {
    Imdb,
    Tmdb,
    RottenTomatoes,
    Metacritic,
    YoutubeViews,
    YoutubeLikes,
    YoutubeFollowers,
    Trakt,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Encode, Decode)]
#[serde(rename_all = "snake_case")]
pub enum SourceTrackKind {
    Video {
        width: u64,
        height: u64,
        display_width: Option<u64>,
        display_height: Option<u64>,
        display_unit: u64,
        fps: Option<f64>,
    },
    Audio {
        channels: usize,
        sample_rate: f64,
        bit_depth: Option<usize>,
    },
    Subtitles,
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Encode, Decode)]
#[serde(rename_all = "snake_case")]
pub enum TraktKind {
    Movie,
    Show,
    Season,
    Episode,
    Person,
    User,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum TmdbKind {
    Tv,
    Movie,
}