Skip to content

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

17.2 KB
Raw Blame
use ratatui::{
    style::{Modifier, Style},
    text::Span,
};

use crate::providers::models::ProviderKind;
use crate::tui::theme::Theme;

pub fn resolution_label(resolution: i64) -> &'static str {
    match resolution {
        -1 => "Multi",
        2160 | 4320 => "4K",
        1080 => "1080p",
        720 => "720p",
        540 => "540p",
        480 | 576 => "480p",
        360 => "360p",
        _ if resolution > 0 => "HD",
        _ => "SD",
    }
}

pub fn resolution_badge_spans<'a>(
    resolution: i64,
    theme: &'a Theme,
    basic_terminal: bool,
    modal_active: bool,
    is_selected: bool,
) -> Vec<Span<'a>> {
    if modal_active {
        if basic_terminal {
            let label = match resolution {
                -1 => "[Multi]",
                2160 | 4320 => "[4K]",
                1080 => "[1080p]",
                720 => "[720p]",
                480 | 540 | 576 => "[480p]",
                360 => "[360p]",
                _ if resolution > 0 => "[HD]",
                _ => "[SD]",
            };
            return vec![
                Span::styled(format!("{:<7}", label), theme.muted),
                Span::raw(" "),
            ];
        }

        let label = match resolution {
            -1 => " Multi ",
            2160 | 4320 => "  4K   ",
            1080 => " 1080p ",
            720 => " 720p  ",
            480 | 540 | 576 => " 480p  ",
            360 => " 360p  ",
            _ if resolution > 0 => "  HD   ",
            _ => "  SD   ",
        };
        let badge_bg = theme.surface0_color();
        let contrast_fg = theme.muted.fg.unwrap_or(theme.base);
        return vec![
            Span::styled(label, Style::default().bg(badge_bg).fg(contrast_fg)),
            Span::raw(" "),
        ];
    }

    if basic_terminal {
        let (label, style) = match resolution {
            -1 => ("[Multi]", theme.lavender.add_modifier(Modifier::BOLD)),
            2160 | 4320 => ("[4K]", theme.rating.add_modifier(Modifier::BOLD)),
            1080 => ("[1080p]", theme.highlight.add_modifier(Modifier::BOLD)),
            720 => ("[720p]", theme.teal.add_modifier(Modifier::BOLD)),
            480 | 540 | 576 => ("[480p]", theme.text_dim.add_modifier(Modifier::BOLD)),
            360 => ("[360p]", theme.text_dim.add_modifier(Modifier::BOLD)),
            _ if resolution > 0 => ("[HD]", theme.text.add_modifier(Modifier::BOLD)),
            _ => ("[SD]", theme.text_dim),
        };
        return vec![Span::styled(format!("{:<7}", label), style), Span::raw(" ")];
    }

    let is_light = theme.is_light;
    let selected_fg = theme.crust_color();
    let (badge_bg, contrast_fg, label) = match resolution {
        -1 => {
            let accent_color = theme.lavender.fg.unwrap_or(theme.base);
            if is_selected {
                (accent_color, selected_fg, " Multi ")
            } else if is_light {
                (theme.surface2_color(), accent_color, " Multi ")
            } else {
                (theme.surface1_color(), accent_color, " Multi ")
            }
        }
        2160 | 4320 => {
            let accent_color = theme.rating.fg.unwrap_or(theme.base);
            if is_selected {
                (accent_color, selected_fg, "  4K   ")
            } else if is_light {
                (theme.surface2_color(), accent_color, "  4K   ")
            } else {
                (theme.surface1_color(), accent_color, "  4K   ")
            }
        }
        1080 => {
            let accent_color = theme.sapphire.fg.unwrap_or(theme.base);
            if is_selected {
                (accent_color, selected_fg, " 1080p ")
            } else if is_light {
                (theme.surface2_color(), accent_color, " 1080p ")
            } else {
                (theme.surface1_color(), accent_color, " 1080p ")
            }
        }
        720 => {
            let accent_color = theme.teal.fg.unwrap_or(theme.base);
            if is_selected {
                (accent_color, selected_fg, " 720p  ")
            } else if is_light {
                (theme.surface2_color(), accent_color, " 720p  ")
            } else {
                (theme.surface1_color(), accent_color, " 720p  ")
            }
        }
        480 | 540 | 576 => (
            theme.surface2_color(),
            theme.text.fg.unwrap_or(theme.base),
            " 480p  ",
        ),
        360 => (
            theme.surface2_color(),
            theme.text.fg.unwrap_or(theme.base),
            " 360p  ",
        ),
        _ if resolution > 0 => (
            theme.surface2_color(),
            theme.text.fg.unwrap_or(theme.base),
            "  HD   ",
        ),
        _ => (
            theme.surface2_color(),
            theme.text_dim.fg.unwrap_or(theme.base),
            "  SD   ",
        ),
    };
    vec![
        Span::styled(
            label,
            Style::default()
                .bg(badge_bg)
                .fg(contrast_fg)
                .add_modifier(Modifier::BOLD),
        ),
        Span::raw(" "),
    ]
}

pub fn provider_origin_tag(provider: ProviderKind) -> &'static str {
    match provider {
        ProviderKind::MovieBox => "[MovieBox]",
        ProviderKind::FourKHdHub => "[4KHD]",
        ProviderKind::BdixCircleFtp => "[CircleFTP]",
        ProviderKind::BdixDhakaFlix => "[DhakaFlix]",
        ProviderKind::Addons => "[Addon]",
        ProviderKind::Dramachi => "[Dramachi]",
    }
}

pub fn provider_badge_span<'a>(
    provider: ProviderKind,
    theme: &'a Theme,
    basic_terminal: bool,
    modal_active: bool,
) -> Span<'a> {
    let tag = provider_origin_tag(provider);
    if modal_active {
        Span::styled(tag, theme.muted)
    } else if basic_terminal {
        Span::styled(tag, theme.text_dim)
    } else {
        let style = match provider {
            ProviderKind::MovieBox => theme.lavender,
            ProviderKind::FourKHdHub => theme.rating,
            ProviderKind::BdixCircleFtp => theme.teal,
            ProviderKind::BdixDhakaFlix => theme.sapphire,
            ProviderKind::Addons => theme.accent,
            ProviderKind::Dramachi => theme.rosewater,
        };
        Span::styled(tag, style)
    }
}

pub fn extract_resolution(title: &str, quality: Option<&str>) -> Option<i64> {
    if let Some(q) = quality {
        let q_lower = q.trim().to_ascii_lowercase();
        if q_lower.contains("2160") || q_lower.contains("4k") || q_lower.contains("uhd") {
            return Some(2160);
        } else if q_lower.contains("1080") || q_lower.contains("fhd") {
            return Some(1080);
        } else if q_lower.contains("720") || q_lower.contains("hd") {
            return Some(720);
        } else if q_lower.contains("540") {
            return Some(540);
        } else if q_lower.contains("480") || q_lower.contains("sd") {
            return Some(480);
        } else if q_lower.contains("576") {
            return Some(576);
        } else if q_lower.contains("360") {
            return Some(360);
        }
    }

    let title_lower = title.to_ascii_lowercase();
    if title_lower.contains("2160p")
        || title_lower.contains("2160")
        || title_lower.contains("4k")
        || title_lower.contains("uhd")
    {
        Some(2160)
    } else if title_lower.contains("1080p")
        || title_lower.contains("1080")
        || title_lower.contains("fhd")
    {
        Some(1080)
    } else if title_lower.contains("720p") || title_lower.contains("720") {
        Some(720)
    } else if title_lower.contains("480p") || title_lower.contains("480") {
        Some(480)
    } else if title_lower.contains("576p") || title_lower.contains("576") {
        Some(576)
    } else if title_lower.contains("360p") || title_lower.contains("360") {
        Some(360)
    } else {
        None
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MediaTags {
    pub hdr: Option<&'static str>,
    pub audio: Option<&'static str>,
    pub codec: Option<&'static str>,
    pub source: Option<&'static str>,
}

pub fn extract_media_tags(title: &str, codec_name: &str) -> MediaTags {
    let lower_title = title.to_ascii_lowercase();
    let lower_codec = codec_name.to_ascii_lowercase();

    let hdr = if lower_title.contains("hdr10+") || lower_title.contains("hdr10plus") {
        Some("HDR10+")
    } else if lower_title.contains("dovi")
        || lower_title.contains("dolby vision")
        || lower_title.contains("dolbyvision")
        || lower_title.contains(".dv.")
        || lower_title.contains(" dv ")
        || lower_title.contains("-dv")
    {
        Some("DV")
    } else if lower_title.contains("hdr") {
        Some("HDR")
    } else {
        None
    };

    let audio = if lower_title.contains("atmos") {
        Some("ATMOS")
    } else if lower_title.contains("7.1") {
        Some("7.1")
    } else if lower_title.contains("5.1")
        || lower_title.contains("ddp5.1")
        || lower_title.contains("dd5.1")
        || lower_title.contains("ac3")
    {
        Some("5.1")
    } else {
        None
    };

    let codec = if lower_codec.contains("hevc")
        || lower_codec.contains("x265")
        || lower_codec.contains("h265")
        || lower_title.contains("hevc")
        || lower_title.contains("x265")
        || lower_title.contains("h.265")
        || lower_title.contains("h265")
    {
        Some("HEVC")
    } else if lower_codec.contains("av1") || lower_title.contains("av1") {
        Some("AV1")
    } else if lower_codec.contains("h264")
        || lower_codec.contains("x264")
        || lower_codec.contains("avc")
        || lower_title.contains("x264")
        || lower_title.contains("h.264")
        || lower_title.contains("h264")
        || lower_title.contains("avc")
    {
        Some("H.264")
    } else {
        None
    };

    let source = if lower_title.contains("remux") {
        Some("REMUX")
    } else if lower_title.contains("bluray")
        || lower_title.contains("bdrip")
        || lower_title.contains("brrip")
    {
        Some("BluRay")
    } else if lower_title.contains("web-dl")
        || lower_title.contains("webdl")
        || lower_title.contains("webrip")
    {
        Some("WEB-DL")
    } else {
        None
    };

    MediaTags {
        hdr,
        audio,
        codec,
        source,
    }
}

pub fn render_media_tag_spans<'a>(
    tags: &MediaTags,
    theme: &'a Theme,
    basic_terminal: bool,
    modal_active: bool,
) -> Vec<Span<'a>> {
    let mut tag_items = Vec::new();

    if let Some(hdr) = tags.hdr {
        let style = if modal_active {
            theme.muted
        } else {
            theme.rating.add_modifier(Modifier::BOLD)
        };
        tag_items.push(Span::styled(hdr, style));
    }

    if let Some(audio) = tags.audio {
        let style = if modal_active {
            theme.muted
        } else {
            theme.sapphire.add_modifier(Modifier::BOLD)
        };
        tag_items.push(Span::styled(audio, style));
    }

    if let Some(codec) = tags.codec {
        let style = if modal_active {
            theme.muted
        } else {
            theme.teal.add_modifier(Modifier::BOLD)
        };
        tag_items.push(Span::styled(codec, style));
    }

    if let Some(source) = tags.source {
        let style = if modal_active {
            theme.muted
        } else {
            theme.lavender.add_modifier(Modifier::BOLD)
        };
        tag_items.push(Span::styled(source, style));
    }

    if tag_items.is_empty() {
        return Vec::new();
    }

    let mut spans = Vec::new();
    let sep = if basic_terminal { " - " } else { " · " };
    let sep_style = if modal_active {
        theme.muted
    } else {
        theme.text_dim
    };

    for (i, tag_span) in tag_items.into_iter().enumerate() {
        if i > 0 {
            spans.push(Span::styled(sep, sep_style));
        }
        spans.push(tag_span);
    }
    spans.push(Span::raw("  "));

    spans
}

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

    #[test]
    fn test_extract_media_tags() {
        let tags = extract_media_tags(
            "Dune.Part.Two.2024.2160p.UHD.BluRay.x265.Atmos.TrueHD.7.1.DV.HDR",
            "hevc",
        );
        assert_eq!(tags.hdr, Some("DV"));
        assert_eq!(tags.audio, Some("ATMOS"));
        assert_eq!(tags.codec, Some("HEVC"));
        assert_eq!(tags.source, Some("BluRay"));

        let tags_web = extract_media_tags(
            "Movie.Title.2023.1080p.HDR10Plus.WEB-DL.DDP5.1.H.264",
            "H264",
        );
        assert_eq!(tags_web.hdr, Some("HDR10+"));
        assert_eq!(tags_web.audio, Some("5.1"));
        assert_eq!(tags_web.codec, Some("H.264"));
        assert_eq!(tags_web.source, Some("WEB-DL"));
    }

    #[test]
    fn test_resolution_badge_spans() {
        let theme = Theme::default();
        let spans_4k = resolution_badge_spans(2160, &theme, false, false, false);
        assert_eq!(spans_4k[0].content, "  4K   ");

        let spans_1080 = resolution_badge_spans(1080, &theme, false, false, false);
        assert_eq!(spans_1080[0].content, " 1080p ");

        let spans_720 = resolution_badge_spans(720, &theme, false, false, false);
        assert_eq!(spans_720[0].content, " 720p  ");

        let spans_sd = resolution_badge_spans(480, &theme, false, false, false);
        assert_eq!(spans_sd[0].content, " 480p  ");

        let spans_multi = resolution_badge_spans(-1, &theme, false, false, false);
        assert_eq!(spans_multi[0].content, " Multi ");

        let basic_4k = resolution_badge_spans(2160, &theme, true, false, false);
        assert_eq!(basic_4k[0].content.trim(), "[4K]");
        let basic_multi = resolution_badge_spans(-1, &theme, true, false, false);
        assert_eq!(basic_multi[0].content.trim(), "[Multi]");

        let muted_multi = resolution_badge_spans(-1, &theme, false, true, false);
        assert_eq!(muted_multi[0].style.fg, theme.muted.fg);
        let muted_basic = resolution_badge_spans(-1, &theme, true, true, false);
        assert_eq!(muted_basic[0].style.fg, theme.muted.fg);
    }

    #[test]
    fn test_all_themes_badge_readability() {
        for theme_name in crate::tui::theme::AVAILABLE_THEMES {
            let kind = crate::tui::theme::ThemeKind::parse(theme_name);
            let theme = crate::tui::theme::Theme::from_kind(kind);
            for res in [-1, 2160, 1080, 720, 480] {
                let unselected = resolution_badge_spans(res, &theme, false, false, false);
                let selected = resolution_badge_spans(res, &theme, false, false, true);
                assert!(unselected[0].style.bg.is_some());
                assert!(unselected[0].style.fg.is_some());
                assert!(selected[0].style.bg.is_some());
                assert!(selected[0].style.fg.is_some());
                assert_ne!(
                    unselected[0].style.bg, unselected[0].style.fg,
                    "Theme {theme_name} res {res} has identical fg and bg!"
                );
                assert_ne!(
                    selected[0].style.bg, selected[0].style.fg,
                    "Theme {theme_name} selected res {res} has identical fg and bg!"
                );
            }
        }
    }

    #[test]
    fn test_resolution_label() {
        assert_eq!(resolution_label(-1), "Multi");
        assert_eq!(resolution_label(4320), "4K");
        assert_eq!(resolution_label(2160), "4K");
        assert_eq!(resolution_label(1080), "1080p");
        assert_eq!(resolution_label(720), "720p");
        assert_eq!(resolution_label(480), "480p");
        assert_eq!(resolution_label(576), "480p");
        assert_eq!(resolution_label(360), "360p");
        assert_eq!(resolution_label(0), "SD");
    }
    #[test]
    fn test_render_media_tag_spans() {
        let theme = Theme::default();
        let tags = MediaTags {
            hdr: Some("HDR"),
            audio: Some("5.1"),
            codec: Some("HEVC"),
            source: Some("WEB-DL"),
        };
        let spans = render_media_tag_spans(&tags, &theme, false, false);
        assert_eq!(spans.len(), 8);
        assert_eq!(spans[0].style.fg, theme.rating.fg);
        let muted_spans = render_media_tag_spans(&tags, &theme, false, true);
        for span in muted_spans.iter().take(7) {
            assert_eq!(span.style.fg, theme.muted.fg);
            assert!(!span.style.add_modifier.contains(Modifier::BOLD));
        }
        let basic_spans = render_media_tag_spans(&tags, &theme, true, false);
        assert_eq!(basic_spans[0].content, "HDR");
    }
    #[test]
    fn test_provider_origin_tag() {
        assert_eq!(provider_origin_tag(ProviderKind::MovieBox), "[MovieBox]");
        assert_eq!(provider_origin_tag(ProviderKind::FourKHdHub), "[4KHD]");
        assert_eq!(
            provider_origin_tag(ProviderKind::BdixCircleFtp),
            "[CircleFTP]"
        );
        assert_eq!(
            provider_origin_tag(ProviderKind::BdixDhakaFlix),
            "[DhakaFlix]"
        );
        assert_eq!(provider_origin_tag(ProviderKind::Addons), "[Addon]");
        assert_eq!(provider_origin_tag(ProviderKind::Dramachi), "[Dramachi]");
    }

    #[test]
    fn test_extract_resolution() {
        assert_eq!(extract_resolution("Movie 1080p BluRay", None), Some(1080));
        assert_eq!(extract_resolution("Movie 4K UHD", None), Some(2160));
        assert_eq!(extract_resolution("Movie 720p WEB", None), Some(720));
        assert_eq!(extract_resolution("Movie", Some("2160p")), Some(2160));
        assert_eq!(extract_resolution("Plain Title", None), None);
    }
}